AWS Elastic Beanstalk # 1 avec Java à partir de zéro - Création d'un environnement d'application Web Java à l'aide de l'interface de ligne de commande EB-
Aperçu
--Avec AWS ** Elastic Beanstalk **, vous pouvez créer un environnement d'exécution d'application Web avec une seule commande sans avoir à configurer un système d'exploitation ou un middleware sur EC2. Étant donné que les correctifs de sécurité peuvent être appliqués automatiquement, cela présente l'avantage d'alléger les opérations, et comme la base est une combinaison de composants AWS tels que EC2, il s'agit d'un service très facile à utiliser qui peut être personnalisé de différentes manières.
- Dans cet article, nous utiliserons un outil appelé ** EB CLI ** pour créer un environnement d'exécution pour ** Java Web App ** avec une seule commande.
- Les applications Web Java ne sont pas des WAR qui s'exécutent sur Tomcat, mais des ** applications Web de Suppin (JAR) ** créées avec Java SE. (Autrement dit, le framework d'application Web peut être ** Spring Boot ** ou ** Play framework **, et le serveur d'application peut être ** Tomcat **, ** Jetty ** ou ** Glassfish **, tant que vous comprenez le concept. D'ACCORD)
- De plus, dans Sequel, définissez votre propre prise en charge de domaine, prise en charge HTTPS, prise en charge de la redirection HTTP → HTTPS et paramètres Auto Scaling.
Environnement / configuration
Créez la configuration suivante à partir de la ligne de commande (Comme il est fabriqué à partir de la ligne de commande, la production de masse et la reconstruction de l'environnement sont faciles)
- Plateforme d'application --AWS Elastic Beanstalk ** Plateforme Java 8 **
- Dans cet article, exécutez une application Web JSP / Servlet sur Jetty9.
- Environnement cloud --Service: AWS Elastic Beanstalk (EC2 + Application Loadbalancer sur VPC) --Région: Tokyo (ap-nord-est-1) → OK même si ce n'est pas Tokyo
Code source
Le code source complet présenté dans cet article peut être trouvé ici https://github.com/riversun/java-jetty-app-on-elasticbeanstalk
Histoire principale
Installation de l'interface de ligne de commande Elastic Beanstalk (EB CLI)
Les applications Elastic Beanstalk peuvent également être créées à l'aide de l'interface graphique Web, mais compte tenu des opérations de production telles que l'automatisation de la construction de l'environnement, l'utilisation de la ligne de commande permet d'économiser du temps et des efforts sans avoir à effectuer les mêmes opérations encore et encore, et l'application / l'environnement Puisque la construction / modification peut être effectuée avec une seule commande, un fonctionnement stable est possible en l'incorporant dans CI.
1. Installez EB CLI
Python est requis pour installer l'interface de ligne de commande EB. Si vous n'avez pas installé Python sur votre PC https://www.anaconda.com/distribution/ Installez à partir de. OK si vous installez la dernière version
Si Python est installé, vous pouvez installer EB CLI avec la commande suivante
pip install awsebcli --upgrade --user
2. Vérifiez la fin de l'installation avec la commande suivante
Vérifiez si l'interface de ligne de commande EB est installée et disponible sur la ligne de commande avec la commande suivante
eb --version
EB CLI 3.15.2 (Python 3.7.1)
Il semble qu'il a été installé correctement
TIPS Dans un environnement Windows, la commande eb peut être introuvable </ font>. Ce temps,
C:\Users\[Nom d'utilisateur]\AppData\Roaming\Python\Python37\Scripts
Vers le chemin
Créer une application Web en Java
Les applications Java créées avec Elastic Beanstalk sont créées au format FAT JAR
Il existe plusieurs façons d'exécuter des applications Web Java sur Elastic Beanstalk.
- Télécharger un fichier de guerre (exécuté avec Tomcat)
- Télécharger le fichier JAR (exécuté dans l'environnement Java SE)
Dans cet article, nous utiliserons la méthode de ** téléchargement d'un fichier JAR **.
** Le fichier JAR ** est un produit qui combine le code source d'une application (application Web) créée en Java + des fichiers dépendants dans un seul JAR. Il est également appelé "** FAT JAR **" car il fait un grand JAR avec tout un.
L'avantage d'utiliser JAR est que ** tout est OK ** tant que vous pouvez convertir l'application Web créée en un fichier JAR.
Le framework peut être Play Framework, Spring Boot, Struts, JSF (bien sûr, JSP / Servlet simple est OK), serveur AP, Tomcat, Jetty, Glassfish, Undertow (Wildfly).
** Cependant, ** Il existe une "** méthode Elastic Beanstalk **" pour créer un JAR et l'exécuter avec Elastic Beanstalk, alors jetons un œil là-bas.
Cela dit, ce n'est pas difficile.
Configuration du code source Java pour Elastic Beanstalk
Considérez une application Web Java qui utilise Jetty comme serveur AP Web.
Tout d'abord, l'image globale est la suivante. L'endroit marqué par "★" est la configuration pour Elastic Beanstalk D'autres sont la structure de code source standard du projet Maven de Java
Configuration du code source Java pour Elastic Beanstalk
elastic-beantalk-java-app
├── src/main/java ・ ・ ・ Répertoire racine du code source Java
│ └── myserver
│ └── StartServer.java
├── src/main/resources
│ └── webroot ・ ・ ・ Contenu Web statique et répertoire racine JSP
│ ├── index.html
│ └── show.jsp
├── src/main/assembly
│ └── zip.xml ・ ・ ・ ★ Décrivez les règles de génération de fichiers ZIP à télécharger sur Elastic Beanstalk
├── .Elasticbeanstalk ・ ・ ・ ★ Répertoire pour stocker les informations de déploiement sur Elasticbeanstalk
│ └── config.yml ・ ・ ・ ★ Fichier YAML d'informations de déploiement sur Elastic Beanstalk
├── cible ・ ・ ・ Résultat de construction(pot etc.)Répertoire où
├── Procfile ・ ・ ・ ★ Ecrire un script pour exécuter un fichier JAR sur EC2 d'Elastic Beanstalk
└── pom.xml ・ ・ ・ Fichier de réglage pour Maven
Le contenu du code source et du fichier de réglage sera expliqué plus loin. Voyons d'abord comment ce code source est construit et téléchargé sur Elastic Beanstalk.
Structure du fichier ZIP à télécharger sur Elastic Beanstalk
Dans cet article, nous allons créer le code source sur votre PC, le conditionner dans un seul fichier JAR et générer un fichier ZIP qui inclut les fichiers requis pour Elastic Beanstalk en plus du fichier JAR.
Ici, le nom de fichier du JAR FAT créé en construisant le code source Java est ** eb-app-jar-with-dependencies.jar **. (Généré par maven-assembly-plugin, expliqué plus tard) Si le nom du fichier ZIP pour le téléchargement vers Elastic Beanstalk est ** my-jetty-app-eb.zip **, la structure du contenu du fichier ZIP est la suivante.
my-jetty-app-eb.Contenu du zip
my-jetty-app-eb.zip
├── my-jetty-app-jar-with-dependencies.jar ・ ・ ・ Code source Java emballé dans un JAR
└── Procfile ・ ・ ・ Script pour exécuter JAR dans EC2 d'Elastic Beanstalk
Il existe deux fichiers ZIP, un ** fichier JAR ** qui résume les sources et un ** Procfile ** qui contient le script d'exécution. Vous pouvez donc déployer ce fichier ZIP au format en le téléchargeant sur Elastic Beanstalk via EB CLI. Il s'agit de l'une des «** pratiques Elastic Beanstalk **».
Ensuite, regardons la source de l'application Java. En particulier, j'expliquerai principalement la partie relative aux "** manières Elastic Beanstalk **"
Comment créer du code source pour l'application Java
L'environnement Elastic Beanstalk dans lequel j'essaie d'exécuter une application Java à partir de maintenant est le suivant, et les points à prendre en compte en tant qu'application Web Java sont ** écouter le numéro de port 5000 **
En d'autres termes, si vous créez un programme serveur ** qui écoute le ** numéro de port 5000 en Java, c'est OK pour le moment.
** Exemple de code ** J'ai donc mis l'exemple de code dans le référentiel suivant https://github.com/riversun/java-jetty-app-on-elasticbeanstalk
Cet exemple exécute la fonctionnalité ** Servlet / JSP / Push Notification ** sur Jetty
Si vous clonez ce code
clone https://github.com/riversun/java-jetty-app-on-elasticbeanstalk.git
Comme mentionné ci-dessus, la structure du code source est la suivante. (Certains fichiers sont omis)
Configuration du code source Java pour Elastic Beanstalk
elastic-beantalk-java-app
├── src/main/java ・ ・ ・ Répertoire racine du code source Java
│ └── myserver
│ └── StartServer.java
├── src/main/resources
│ └── webroot ・ ・ ・ Contenu Web statique et répertoire racine JSP
│ ├── index.html
│ └── show.jsp
├── src/main/assembly
│ └── zip.xml ・ ・ ・ ★ Décrivez les règles de génération de fichiers ZIP à télécharger sur Elastic Beanstalk
├── .Elasticbeanstalk ・ ・ ・ ★ Répertoire pour stocker les informations de déploiement sur Elasticbeanstalk
│ └── config.yml ・ ・ ・ ★ Fichier YAML d'informations de déploiement sur Elastic Beanstalk
├── cible ・ ・ ・ Résultat de construction(pot etc.)Répertoire où
├── Procfile ・ ・ ・ ★ Ecrire un script pour exécuter un fichier JAR sur EC2 d'Elastic Beanstalk
└── pom.xml ・ ・ ・ Fichier de réglage pour Maven
- La partie marquée "★" est la configuration pour Elastic Beanstalk.
La classe principale (point d'entrée) en tant qu'application Java est ** StartServer.java **. Si vous l'exécutez localement et accédez à http: // localhost: 5000 /, vous verrez quelque chose comme ceci: C'est un exemple qui vous permet d'essayer des implémentations simples telles que JSP et Servlet.
À partir de là, les points importants du code source sont expliqués ci-dessous.
src/main/java myserver.StartServer.java
Classe principale. Démarrez Jetty, hébergez le servlet / JSP et écoutez sur le port 5000
/pom.xml
pom.xml(Extrait)
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">
<modelVersion>4.0.0</modelVersion>
<groupId>org.riversun</groupId>
<artifactId>my-jetty-app</artifactId>
<version>1.0.0</version>
<packaging>jar</packaging>
<name>my-jetty-app</name>
<description>jetty app on elastic beanstalk</description>
pom.xml
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">
<modelVersion>4.0.0</modelVersion>
<groupId>org.riversun</groupId>
<artifactId>my-jetty-app</artifactId>
<version>1.0.0</version>
<packaging>jar</packaging>
<name>my-jetty-app</name>
<description>jetty app on elastic beanstalk</description>
<properties>
<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
<jetty-version>9.4.19.v20190610</jetty-version>
</properties>
<dependencies>
<!-- for server -->
<dependency>
<groupId>javax.servlet</groupId>
<artifactId>javax.servlet-api</artifactId>
<version>3.1.0</version>
</dependency>
<dependency>
<groupId>org.eclipse.jetty</groupId>
<artifactId>jetty-annotations</artifactId>
<version>${jetty-version}</version>
</dependency>
<dependency>
<groupId>org.eclipse.jetty</groupId>
<artifactId>jetty-webapp</artifactId>
<version>${jetty-version}</version>
</dependency>
<dependency>
<groupId>org.eclipse.jetty</groupId>
<artifactId>apache-jsp</artifactId>
<version>${jetty-version}</version>
<type>jar</type>
</dependency>
<dependency>
<groupId>org.eclipse.jetty</groupId>
<artifactId>apache-jstl</artifactId>
<version>${jetty-version}</version>
<type>pom</type>
</dependency>
<dependency>
<groupId>com.fasterxml.jackson.core</groupId>
<artifactId>jackson-databind</artifactId>
<version>2.9.9</version>
</dependency>
</dependencies>
<build>
<plugins>
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-compiler-plugin</artifactId>
<version>3.8.1</version>
<configuration>
<source>1.8</source>
<target>1.8</target>
<excludes>
<exclude>examples/**/*</exclude>
</excludes>
</configuration>
</plugin>
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-javadoc-plugin</artifactId>
<version>3.1.0</version>
<executions>
<execution>
<id>attach-javadocs</id>
<goals>
<goal>jar</goal>
</goals>
</execution>
</executions>
<configuration>
<author>true</author>
<source>1.7</source>
<show>protected</show>
<encoding>UTF-8</encoding>
<charset>UTF-8</charset>
<docencoding>UTF-8</docencoding>
<doclint>none</doclint>
<additionalJOption>-J-Duser.language=en</additionalJOption>
</configuration>
</plugin>
<!-- add source folders -->
<plugin>
<groupId>org.codehaus.mojo</groupId>
<artifactId>build-helper-maven-plugin</artifactId>
<version>3.0.0</version>
<executions>
<execution>
<phase>generate-sources</phase>
<goals>
<goal>add-source</goal>
</goals>
<configuration>
<sources>
<source>src/main/java</source>
</sources>
</configuration>
</execution>
</executions>
</plugin>
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-assembly-plugin</artifactId>
<executions>
<!--Fat le code source-pot-->
<execution>
<id>package-jar</id>
<phase>package</phase>
<goals>
<goal>single</goal>
</goals>
<configuration>
<appendAssemblyId>true</appendAssemblyId>
<archive>
<manifest>
<mainClass>myserver.StartServer</mainClass>
</manifest>
</archive>
<finalName>${project.artifactId}</finalName>
<descriptorRefs>
<descriptorRef>jar-with-dependencies</descriptorRef>
</descriptorRefs>
</configuration>
</execution>
<!--Zip à télécharger sur Elastic Beanstalk(fat.Inclut les fichiers bocaux et les fichiers associés)Créer-->
<execution>
<id>package-zip</id>
<phase>package</phase>
<goals>
<goal>single</goal>
</goals>
<configuration>
<appendAssemblyId>true</appendAssemblyId>
<finalName>${project.artifactId}</finalName>
<descriptors>
<descriptor>src/main/assembly/zip.xml</descriptor>
</descriptors>
</configuration>
</execution>
</executions>
</plugin>
</plugins>
<resources>
<resource>
<directory>src/main/resources</directory>
</resource>
</resources>
</build>
</project>
Ci-dessous, je ne regarderai que les points.
maven artifactId
Ce qui suit est ** my-jetty-app ** en tant que ** artifactId **. La valeur de cet ** artifactId ** est également utilisée pour le nom de fichier etc. généré dans la construction suivante.
<groupId>org.riversun</groupId>
<artifactId>my-jetty-app</artifactId>
Paramètres de maven-assembly-plugin
Ce qui suit est le paramètre de ** maven-assembly-plugin **. maven-assembly-plugin est un plug-in maven pour créer des fichiers jar et des fichiers zip pour la distribution. Ce maven-assembly-plugin a deux tâches.
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-assembly-plugin</artifactId>
<executions>
<!--Fat le code source-pot-->
<execution>
<id>package-jar</id>
<phase>package</phase>
<goals>
<goal>single</goal>
</goals>
<configuration>
<appendAssemblyId>true</appendAssemblyId>
<archive>
<manifest>
<mainClass>myserver.StartServer</mainClass>
</manifest>
</archive>
<finalName>${project.artifactId}</finalName>
<descriptorRefs>
<descriptorRef>jar-with-dependencies</descriptorRef>
</descriptorRefs>
</configuration>
</execution>
<!--Zip à télécharger sur Elastic Beanstalk(fat.Inclut les fichiers bocaux et les fichiers associés)Créer-->
<execution>
<id>package-zip</id>
<phase>package</phase>
<goals>
<goal>single</goal>
</goals>
<configuration>
<appendAssemblyId>true</appendAssemblyId>
<finalName>${project.artifactId}</finalName>
<descriptors>
<descriptor>src/main/assembly/zip.xml</descriptor>
</descriptors>
</configuration>
</execution>
</executions>
</plugin>
** Partie 1 Génération de fichiers JAR ** Tout d'abord, faites attention aux paramètres de la première moitié.
<execution>
<id>package-jar</id>
<phase>package</phase>
<goals>
<goal>single</goal>
</goals>
<configuration>
<appendAssemblyId>true</appendAssemblyId>
<archive>
<manifest>
<mainClass>myserver.StartServer</mainClass>
</manifest>
</archive>
<finalName>${project.artifactId}</finalName>
<descriptorRefs>
<descriptorRef>jar-with-dependencies</descriptorRef>
</descriptorRefs>
</configuration>
</execution>
Ce que nous écrivons ici est de combiner le code source Java dans un fichier JAR. En d'autres termes, il s'agit d'un paramètre de tâche pour créer un JAR FAT.
``
<finalName> $ {project.artifactId} </ finalName> est la valeur spécifiée par ** artifactId ** pour le nom de fichier du fichier JAR final = ** my-jetty-app- [AssemblyId ] .jar **.
<descriptorRef> jar-with-dependencies </ descriptors </ descriptorRef> conditionne également les bibliothèques dépendantes décrites dans ** dependencies ** de maven sous forme de fichier JAR.
``
Pour générer un fichier JAR dans les conditions définies ici
mvn package
Et c'est suffisant. Cela générera ** my-jetty-app-jar-with-dependencies.jar ** dans le répertoire ** target **.
** Partie 2 Génération de fichiers ZIP **
Vient ensuite le réglage de la seconde moitié
<execution>
<id>package-zip</id>
<phase>package</phase>
<goals>
<goal>single</goal>
</goals>
<configuration>
<appendAssemblyId>true</appendAssemblyId>
<finalName>${project.artifactId}</finalName>
<descriptors>
<descriptor>src/main/assembly/zip.xml</descriptor>
</descriptors>
</configuration>
</execution>
Ce qui est décrit ici est la tâche de combiner le fichier JAR créé ci-dessus et les fichiers liés à Elastic Beanstalk (Procfile, etc.) dans un fichier ZIP.
Lorsque ``
La règle de génération ZIP est définie dans le fichier de paramètres externe ``
src/main/assembly/zip.xml
Jetons maintenant un œil au fichier zip.xml qui a été supprimé.
C'est la règle de génération lorsque le fichier ZIP est finalement généré.
``
zip.xml
<?xml version="1.0" encoding="UTF-8"?>
<assembly
xmlns="http://maven.apache.org/plugins/maven-assembly-plugin/assembly/1.1.2"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/plugins/maven-assembly-plugin/assembly/1.1.2 http://maven.apache.org/xsd/assembly-1.1.2.xsd">
<id>eb</id>
<baseDirectory>/</baseDirectory>
<formats>
<format>zip</format>
</formats>
<fileSets>
<fileSet>
<directory>${project.basedir}</directory>
<outputDirectory>/</outputDirectory>
<includes>
<include>Procfile</include>
<include>Buildfile</include>
<include>.ebextensions/*</include>
</includes>
</fileSet>
<fileSet>
<directory>${project.build.directory}</directory>
<outputDirectory>/</outputDirectory>
<includes>
<include>my-jetty-app-jar-with-dependencies.jar</include>
<!-- <include>*.jar</include> -->
</includes>
</fileSet>
</fileSets>
</assembly>
Le nom de fichier du fichier ZIP final sera ** my-jetty-app- [id] .zip **.
Dans zip.xml, ``
En résumé, lorsque vous exécutez la commande maven mvn package pour générer les packages requis ** my-jetty-app-jar-with-dependencies.jar ** et ** my-jetty-app-eb.zip * Les deux * seront générés sous le répertoire ** target **.
Nous le vérifierons à nouveau plus tard lorsque nous générerons réellement le fichier de déploiement.
/Procfile
Procfile est un fichier pour exécuter JAR dans EC2 d'Elastic Beanstalk.
La commande pour démarrer l'application sur EC2 d'Elastic Beanstalk est décrite sous `` web: ''.
Procfile
web: java -jar my-jetty-app-jar-with-dependencies.jar
Il est correct de décrire l'option de démarrage comme ↓
web: java -jar my-jetty-app-jar-with-dependencies.jar -Xms256m
Voir Officiel pour plus de détails.
.elasticbeanstalk/config.yml
Décrire les informations de déploiement dans config.yml
Le fichier target / my-jetty-app-eb.zip à déployer sur Elastic Beansalk est spécifié ici.
config.yml
deploy:
artifact: target/my-jetty-app-eb.zip
Ce fichier est référencé lors du déploiement sur Elastic Beanstalk.
Actuellement, seul `` deploy: artifact: '' est décrit, mais dans le processus de configuration du déploiement d'Elastic Beanstalk à l'aide de l'interface de ligne de commande EB à partir de maintenant, les valeurs nécessaires seront ajoutées à ce ** config.yml **. J'irai.
Déployer des applications à l'aide de l'interface de ligne de commande EB
Maintenant que vous avez une idée approximative de ce que signifie le fichier, déployez votre application sur Elastic Beanstalk.
Créez une application Elastic Beanstalk sur AWS à l'aide de l'interface de ligne de commande EB
** 1. Accédez au répertoire de l'application **
cd java-jetty-app-on-elasticbeanstalk
** 2. Créez une boîte Java * dans Elastic Beanstalk ** (* Boîte = application)
La commande EB CLI pour cela est au format suivant.
| eb init Nom de l'application --region Nom de la région --platform Plate-forme |
Ici, le nom de l'application est ** my-eb-app , la région est la région de Tokyo ( ap-nord-est-1 **) et la plate-forme est ** java-8 **.
La commande ressemble à ceci:
eb init my-eb-app --region ap-northeast-1 --platform java-8
Puis
Application my-eb-app has been created.
Un message apparaît, Une boîte d'applications est créée sur AWS Elastic beanstalk
Si vous le cochez sur la console Web à la fois, une boîte (application) est créée
https://ap-northeast-1.console.aws.amazon.com/elasticbeanstalk/home
Maintenant, jetez un œil à ** / .elasticbeanstalk / config.yml ** dans le code source.
Avec la commande ci-dessus, ** config.yml ** a également été mis à jour pour ressembler à ceci:
config.yml
branch-defaults:
master:
environment: null
deploy:
artifact: target/my-jetty-app-eb.zip
global:
application_name: my-eb-app
branch: null
default_ec2_keyname: null
default_platform: java-8
default_region: ap-northeast-1
include_git_submodules: true
instance_profile: null
platform_name: null
platform_version: null
profile: eb-cli
repository: null
sc: git
workspace_type: Application
TIPS ------------
Si les informations d'identification ne sont pas enregistrées </ font>, il vous sera demandé ** aws-access-id ** et ** aws-secret-key ** comme indiqué ci-dessous, alors entrez-les. ..
eb init my-eb-app --region ap-northeast-1 --platform java-8
You have not yet set up your credentials or your credentials are incorrect
You must provide your credentials.
(aws-access-id): xxxxx
(aws-secret-key): xxxxx
Application my-eb-app has been created.
Si vous le saisissez une fois, un fichier de configuration sera créé sous le répertoire [user] /. Aws, vous ne serez donc pas invité à nouveau.
------------
Créer un package pour le déploiement
Comme nous l'avons vu précédemment, générez un fichier ** ZIP ** pour le déploiement sur Elastic Beanstalk.
Puisque la génération ZIP est effectuée par Maven, appuyez sur la commande `` maven package ''
(Si vous nettoyez également, la commande est la suivante)
mvn clean package
Comme indiqué ci-dessous, ** my-jetty-app-eb.zip ** a été généré avec succès dans le répertoire ** target / **.
[INFO] --- maven-assembly-plugin:2.2-beta-5:single (package-zip) @ my-jetty-app ---
[INFO] Reading assembly descriptor: src/main/assembly/zip.xml
[INFO] Building zip: jetty-app-on-eb\target\my-jetty-app-eb.zip
[INFO] ------------------------------------------------------------------------
[INFO] BUILD SUCCESS
[INFO] ------------------------------------------------------------------------
[INFO] Total time: 32.984 s
[INFO] Finished at: 2019-07-01T15:55:14+09:00
[INFO] Final Memory: 37M/449M
[INFO] ------------------------------------------------------------------------
Déployer sur Elastic Beanstalk et créer un environnement
À partir de maintenant, déployez le fichier ZIP créé sur Elastic Beanstalk à l'aide de l'interface de ligne de commande EB.
Utilisez la commande ** eb create ** pour déployer sur Elastic Beanstalk
** Comment utiliser la commande eb create **
Spécifiez la commande eb create comme suit.
| eb create Nom de l'environnement [Option] [Option] ・ ・ ・ [Option] |
Les options sont:
| Options | Description |
| --cname | Spécifiez le CNAME de l'URL. Exemple Si vous spécifiez my-jetty-app-test pour CNAME, http://my-jetty-app-test.ap-northeast-1.elasticbeanstalk.com/ Accessible en tant que |
| --instance_type | Type d'instance. VPC requis pour spécifier la série t2 |
| --elb-type | Type d'équilibreur de charge Si vous spécifiez "application" Devenez un équilibreur de charge d'application. Plus tard, lors de la prise en charge de votre propre domaine ou HTTPS Il est facile d’avoir un équilibreur de route |
| --vpc.id | ID VPC |
| --vpc.elbpublic | Équilibreur de charge Placer dans un sous-réseau public |
| --vpc.elbsubnets | Spécifiez l'ID de sous-réseau de l'équilibreur de charge. Lorsque vous spécifiez plusieurs éléments, séparez-les par des virgules |
| --vpc.publicip | Elastic Beanstalk EC2 Placer dans un sous-réseau public |
| --vpc.ec2subnets | Elastic Beanstalk Spécifiez l'ID de sous-réseau EC2. Lorsque vous spécifiez plusieurs éléments, séparez-les par des virgules |
Pour plus de détails, reportez-vous à Officiel
Eh bien Depuis la ligne de commande:
eb create my-jetty-app-test --cname my-jetty-app-test --instance_type t2.small --elb-type application --vpc.id vpc-xxxxxxxxxxxxxxxxx --vpc.elbpublic --vpc.elbsubnets subnet-xxxxxxxxxxxxxxxxx,subnet-yyyyyyyyyyyyyyyyy --vpc.publicip --vpc.ec2subnets subnet-xxxxxxxxxxxxxxxxx,subnet-yyyyyyyyyyyyyyyyy
Dans ce qui précède, l'ID réel, etc. est factice, mais le nom de l'environnement ** my-jetty-app-test **, cname est ** my-jetty-app-test ** et le type d'instance EC2 est ** t2.small ** , ELB (load balancer) est ** application ** load balancer, VPC ID est ** vpc-xxxxxxxxxxxxxxxxx ** et il s'agit d'une commande pour déployer le fichier ZIP.
(Le fichier ZIP qui sera téléversé est spécifié dans **. Elasticbeanstalk / config.yml **, alors consultez-le.)
En outre, ** - vpc.elbpublic ** et ** - vpc.publicip ** indiquent que ELB (équilibreur de charge) et EC2 d'Elastic Beanstalk seront exécutés dans le sous-réseau public dans le VPC spécifié. ** - vpc.elbsubnets ** et ** - vpc.ec2subnets ** ont respectivement les mêmes sous-réseaux publics (2). Les ELB ne peuvent accéder aux applications que s'ils peuvent accéder au public, alors placez-les dans le sous-réseau public. Du côté EC2, il existe une méthode pour le placer dans le sous-réseau public et une méthode pour le placer dans le sous-réseau privé. Dans l'exemple de cet article, bien qu'il se trouve dans le sous-réseau public, il est uniquement accessible depuis l'ELB par le groupe de sécurité généré automatiquement. Cependant, une adresse IP publique est attribuée. (Pour le rendre plus sûr, vous pouvez inventer comme placer EC2 dans un sous-réseau privé. , Il s'agit d'un problème de sécurité autour d'EC2 et de VPC plutôt que d'Elastic Beanstalk, je vais donc l'omettre ici.)
En passant, lorsque la commande ci-dessus est exécutée, le processus du téléchargement à la construction de l'environnement est automatiquement exécuté comme indiqué ci-dessous.
Uploading: [##################################################] 100% Done...
Environment details for: my-jetty-app-test
Application name: my-eb-app
Region: ap-northeast-1
Deployed Version: app-1d5f-190705_00000
Environment ID: e-2abc
Platform: arn:aws:elasticbeanstalk:ap-northeast-1::platform/Java 8 running on 64bit Amazon Linux/2.8.6
Tier: WebServer-Standard-1.0
CNAME: my-jetty-app-test.ap-northeast-1.elasticbeanstalk.com
Updated: 2019-07-01 07:08:01.989000+00:00
Printing Status:
2019-07-01 07:08:00 INFO createEnvironment is starting.
2019-07-01 07:08:02 INFO Using elasticbeanstalk-ap-northeast-1-000000000000 as Amazon S3 storage bucket for environment data.
2019-07-01 07:08:23 INFO Created target group named: arn:aws:elasticloadbalancing:ap-northeast-1:000000000000:targetgroup/awseb-AWSEB-LMAAAA/000000000
2019-07-01 07:08:23 INFO Created security group named: sg-11111111111111111
2019-07-01 07:08:39 INFO Created security group named: sg-22222222222222222
2019-07-01 07:08:39 INFO Created Auto Scaling launch configuration named: awseb-e-xxxxxxxxxx-stack-AWSEBAutoScalingLaunchConfiguration-3V
2019-07-01 07:09:41 INFO Created Auto Scaling group named: awseb-e-xxxxxxxxxx-stack-AWSEBAutoScalingGroup-XXXXXXXXXXXX
2019-07-01 07:09:41 INFO Waiting for EC2 instances to launch. This may take a few minutes.
2019-07-01 07:09:41 INFO Created Auto Scaling group policy named: arn:aws:autoscaling:ap-northeast-1:000000000000:scalingPolicy:4e:autoScalingGroupName/awseb-e-
xxxxxxxxxx-stack-AWSEBAutoScalingGroup-XXXXXXXXXXXX:policyName/awseb-e-xxxxxxxxxx-stack-AWSEBAutoScalingScaleUpPolicy-FA
2019-07-01 07:09:42 INFO Created Auto Scaling group policy named: arn:aws:autoscaling:ap-northeast-1:000000000000:scalingPolicy:8a:autoScalingGroupName/awseb-e-
xxxxxxxxxx-stack-AWSEBAutoScalingGroup-XXXXXXXXXXXX:policyName/awseb-e-xxxxxxxxxx-stack-AWSEBAutoScalingScaleDownPolicy-SSZW
2019-07-01 07:09:57 INFO Created CloudWatch alarm named: awseb-e-xxxxxxxxxx-stack-AWSEBCloudwatchAlarmHigh-H0N
2019-07-01 07:09:57 INFO Created CloudWatch alarm named: awseb-e-xxxxxxxxxx-stack-AWSEBCloudwatchAlarmLow-BX
2019-07-01 07:10:34 INFO Created load balancer named: arn:aws:elasticloadbalancing:ap-northeast-1:000000000000:loadbalancer/app/awseb-AWSEB-1BQ
2019-07-01 07:10:34 INFO Created Load Balancer listener named: arn:aws:elasticloadbalancing:ap-northeast-1:000000000000:listener/app/awseb-AWSEB-1BQ
2019-07-01 07:11:05 INFO Application available at my-jetty-app-test.ap-northeast-1.elasticbeanstalk.com.
2019-07-01 07:11:05 INFO Successfully launched environment: my-jetty-app-test
Une fois la construction de l'environnement lancée, la situation peut être appréhendée sur la console Web.
Il semble qu'il a pu être déployé
L'application semble avoir été déployée avec succès sur http://my-jetty-app-test.ap-northeast-1.elasticbeanstalk.com/
Lorsque vous accédez
Il semble que JSP et Servlet fonctionnent correctement
Résumé
-
Introduction de la procédure de déploiement d'une application Web à l'aide de Java SE sur AWS Elastic Beanstalk à l'aide de l'interface de ligne de commande EB de manière pratique.
-
En conséquence, nous avons pu créer la configuration suivante à partir de la commande.
--Cliquez ici pour tout le code source introduit https://github.com/riversun/java-jetty-app-on-elasticbeanstalk.git
- Sequel "AWS Elastic Beanstalk # 2 à partir de zéro" décrit la prise en charge du domaine d'origine, la prise en charge HTTPS, la prise en charge de la redirection HTTP → HTTPS et les paramètres Auto Scaling. , Manipuler.
Recommended Posts