C:\Users\[Nutzername]\AppData\Roaming\Python\Python37\Scripts

Zum Weg

Erstellen Sie eine Web-App in Java

Mit Elastic Beanstalk erstellte Java-Apps werden im FAT JAR-Format erstellt

Es gibt verschiedene Möglichkeiten, Java-Webanwendungen auf Elastic Beanstalk auszuführen.

• Kriegsdatei hochladen (mit Tomcat ausführen)
• JAR-Datei hochladen (in Java SE-Umgebung ausführen)

In diesem Artikel verwenden wir die Methode zum ** Hochladen einer JAR-Datei **.

** JAR-Datei ** ist ein Produkt, das den Quellcode einer Anwendung (Webanwendung), die in Java + -abhängigen Dateien erstellt wurde, in einer JAR kombiniert. Es wird auch "** FAT JAR **" genannt, weil es mit allen ein großes JAR macht.

Der Vorteil der Verwendung von JAR ist, dass ** alles in Ordnung ist **, solange Sie die erstellte Webanwendung in eine JAR-Datei konvertieren können.

Das Framework kann Play Framework, Spring Boot, Struts, JSF (natürlich ist einfaches JSP / Servlet in Ordnung), AP-Server, Tomcat, Jetty, Glassfish, Undertow (Wildfly) sein.

** Es gibt jedoch "** Elastic Beanstalk-Methode **", um eine JAR zu erstellen und mit Elastic Beanstalk auszuführen. Schauen wir uns das also an.

Das heißt, es ist nicht schwierig.

Java-Quellcode-Konfiguration für Elastic Beanstalk

Stellen Sie sich eine Java-Web-App vor, die Jetty als Web-AP-Server verwendet.

Erstens ist das Gesamtbild wie folgt. Der mit "★" gekennzeichnete Ort ist die Konfiguration für Elastic Beanstalk Andere sind die Standard-Quellcodestruktur von Mavas Maven-Projekt

Java-Quellcode-Konfiguration für Elastic Beanstalk

elastic-beantalk-java-app
├── src/main/java ・ ・ ・ Stammverzeichnis des Java-Quellcodes
│   └── myserver 　
│       └── StartServer.java
├── src/main/resources
│ └ Webroot ・ ・ ・ Statischer Webinhalt und JSP-Stammverzeichnis
│       ├── index.html
│       └── show.jsp 
├── src/main/assembly
│   └── zip.xml ・ ・ ・ ★ Beschreiben Sie die Regeln zum Generieren von ZIP-Dateien, die auf elastische Bohnenstangen hochgeladen werden sollen
├── .elastischer Bohnenstiel ・ ・ ・ ★ Verzeichnis zum Speichern von Bereitstellungsinformationen in Elasticbeanstalk
│   └── config.yml AM ・ ・ ★ YAML-Datei mit Bereitstellungsinformationen für Elastic Beanstalk
├── Ziel ・ ・ ・ Ergebnis erstellen(Glas usw.)Verzeichnis wo
├── Procfile ・ ・ ・ ★ Schreiben Sie ein Skript, um eine JAR-Datei auf EC2 von Elastic Beanstalk auszuführen
└── pom.xml ・ ・ ・ Datei für Maven einstellen

Der Inhalt des Quellcodes und der Einstellungsdatei wird später erläutert. Lassen Sie uns zuerst sehen, wie dieser Quellcode erstellt und auf Elastic Beanstalk hochgeladen wird.

Struktur der ZIP-Datei zum Hochladen auf Elastic Beanstalk

In diesem Artikel erstellen wir den Quellcode auf Ihrem PC, verpacken ihn in eine einzelne JAR-Datei und generieren eine ZIP-Datei, die neben der JAR-Datei auch die für Elastic Beanstalk erforderlichen Dateien enthält.

Hier lautet der Dateiname der FAT-JAR, die durch Erstellen des Java-Quellcodes erstellt wurde, ** eb-app-jar-with-dependencies.jar **. (Erstellt durch das Maven-Assembly-Plugin, später erklärt) Wenn der Name der ZIP-Datei für das Hochladen auf Elastic Beanstalk ** my-jetty-app-eb.zip ** lautet, lautet die Inhaltsstruktur der ZIP-Datei wie folgt.

my-jetty-app-eb.Inhalt der Reißverschluss

my-jetty-app-eb.zip
├── my-jetty-app-jar-with-dependencies.jar ・ ・ ・ Java-Quellcode in einer JAR
└── Procfile ・ ・ ・ Skript zum Ausführen von JAR in EC2 von Elastic Beanstalk

Es gibt zwei ZIP-Dateien, eine ** JAR-Datei **, die die Quellen zusammenfasst, und eine ** Procfile , die das Ausführungsskript enthält. Sie können diese ZIP-Datei im Format bereitstellen, indem Sie sie über EB CLI auf Elastic Beanstalk hochladen. Dies ist eine der " Elastic Beanstalk-Praktiken **".

Schauen wir uns als nächstes die Java-App-Quelle an. Insbesondere werde ich hauptsächlich den Teil erklären, der sich auf "** Elastic Beanstalk Manieren **" bezieht.

So erstellen Sie den Quellcode für die Java-App

Die Elastic Beanstalk-Umgebung, in der ich von nun an versuche, eine Java-App auszuführen, sieht wie folgt aus. Die Punkte, die als Java-Web-App beachtet werden sollten, sind ** Port Nummer 5000 abhören **

Mit anderen Worten, wenn Sie ein Serverprogramm erstellen, das die Portnummer 5000 in Java abhört, ist dies vorerst in Ordnung.

** Beispielcode ** Also habe ich den Beispielcode in das folgende Repository gestellt https://github.com/riversun/java-jetty-app-on-elasticbeanstalk

In diesem Beispiel wird die Funktion ** Servlet / JSP / Push-Benachrichtigung ** auf Jetty ausgeführt

Wenn Sie diesen Code klonen

clone https://github.com/riversun/java-jetty-app-on-elasticbeanstalk.git

Wie oben erwähnt, ist die Quellcodestruktur wie folgt. (Einige Dateien werden weggelassen)

Java-Quellcode-Konfiguration für Elastic Beanstalk

elastic-beantalk-java-app
├── src/main/java ・ ・ ・ Stammverzeichnis des Java-Quellcodes
│   └── myserver 　
│       └── StartServer.java
├── src/main/resources
│ └ Webroot ・ ・ ・ Statischer Webinhalt und JSP-Stammverzeichnis
│       ├── index.html
│       └── show.jsp 
├── src/main/assembly
│   └── zip.xml ・ ・ ・ ★ Beschreiben Sie die Regeln zum Generieren von ZIP-Dateien, die auf elastische Bohnenstangen hochgeladen werden sollen
├── .elastischer Bohnenstiel ・ ・ ・ ★ Verzeichnis zum Speichern von Bereitstellungsinformationen in Elasticbeanstalk
│   └── config.yml AM ・ ・ ★ YAML-Datei mit Bereitstellungsinformationen für Elastic Beanstalk
├── Ziel ・ ・ ・ Ergebnis erstellen(Glas usw.)Verzeichnis wo
├── Procfile ・ ・ ・ ★ Schreiben Sie ein Skript, um eine JAR-Datei auf EC2 von Elastic Beanstalk auszuführen
└── pom.xml ・ ・ ・ Datei für Maven einstellen

• Der mit "★" gekennzeichnete Teil ist die Konfiguration für Elastic Beanstalk.

Die Hauptklasse (Einstiegspunkt) als Java-Anwendung ist ** StartServer.java **. Wenn Sie dies lokal ausführen und auf http: // localhost: 5000 / zugreifen, wird Folgendes angezeigt: Es ist ein Beispiel, mit dem Sie einfache Implementierungen wie JSP und Servlet ausprobieren können.

Von hier aus werden die wichtigen Punkte im Quellcode unten erläutert.

src/main/java myserver.StartServer.java

Hauptklasse. Starten Sie Jetty, hosten Sie Servlet / JSP und warten Sie auf Port 5000

/pom.xml

pom.xml(Auszug)

<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>
					<!--Fetten Sie den Quellcode-Krug-->
					<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 zum Hochladen auf Elastic Beanstalk(fat.Enthält Gläser und verwandte Dateien)Erschaffen-->
					<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>

Im Folgenden werde ich nur auf die Punkte eingehen.

Maven ArtefaktId

Das Folgende ist ** my-jetty-app ** als ** Artefakt-ID **. Der Wert dieser ** Artefakt-ID ** wird auch für den Dateinamen usw. verwendet, der im nachfolgenden Build generiert wird.

	<groupId>org.riversun</groupId>
	<artifactId>my-jetty-app</artifactId>

Einstellungen für das Maven-Assembly-Plugin

Das Folgende ist die Einstellung von ** Maven-Assembly-Plugin **. Das Maven-Assembly-Plugin ist ein Maven-Plug-In zum Erstellen von JAR-Dateien und Zip-Dateien für die Verteilung. Dieses Maven-Assembly-Plugin hat zwei Aufgaben.

<plugin>
  <groupId>org.apache.maven.plugins</groupId>
  <artifactId>maven-assembly-plugin</artifactId>
  <executions>
    <!--Fetten Sie den Quellcode-Krug-->
    <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 zum Hochladen auf Elastic Beanstalk(fat.Enthält Gläser und verwandte Dateien)Erschaffen-->
    <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>

** Teil 1 JAR-Dateierzeugung ** Achten Sie zunächst auf die Einstellungen in der ersten Hälfte.

  <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>

Wir schreiben hier, um Java-Quellcode in einer JAR-Datei zu kombinieren. Mit anderen Worten, es ist eine Aufgabeneinstellung zum Erstellen eines FAT JAR.

<mainClass> myserver.StartServer </ mainClass> ist die Startklasse beim Ausführen einer JAR-Datei.

<finalName> $ {project.artifactId} </ finalName> ist der von ** ArtefaktId ** angegebene Wert für den Dateinamen der endgültigen JAR-Datei = ** my-jetty-app- [AssemblyId ] .Krug **.

<descriptorRef> jar-with-dependencies </ Descriptors </ descriptorRef> verpackt auch die in ** Abhängigkeiten ** von maven beschriebenen abhängigen Bibliotheken als JAR-Datei.

<appendAssemblyId> true </ appendAssemblyId> legt fest, ob AssemblyId zum Dateinamen der generierten JAR-Datei hinzugefügt werden soll. Wenn dies ** wahr ** ist, lautet der Name der JAR-Datei ** my-jetty-app-jar-with-dependencies.jar **.

So generieren Sie eine JAR-Datei unter den hier festgelegten Bedingungen

mvn package

Und es ist ausreichend. Dadurch wird ** my-jetty-app-jar-with-dependencies.jar ** im ** Zielverzeichnis ** generiert.

** Teil 2 Generierung von ZIP-Dateien **

Als nächstes folgt die Einstellung für die zweite Hälfte

   <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>

Was hier beschrieben wird, ist die Aufgabe, die oben erstellte JAR-Datei und Elastic Beanstalk-bezogene Dateien (Procfile usw.) zu einer ZIP-Datei zu kombinieren.

Wenn <finalName> $ {project.artifactId} </ finalName> `verwendet wird, wird der generierte Dateiname wie im Fall von JAR angegeben.

Die ZIP-Generierungsregel wird in der externen Einstellungsdatei <descriptor> src / main / Assembly / zip.xml </ descriptor> festgelegt.

src/main/assembly/zip.xml

Schauen wir uns nun die entfernte zip.xml an.

Dies ist die Generierungsregel, wenn die ZIP-Datei endgültig generiert wird.

<include> gibt eine JAR-Datei und eine Procfile usw. an und weist an, wie eine ZIP-Datei in dem Format generiert wird, das auf Elastic Beanstalk hochgeladen werden soll.

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>

Der Dateiname der endgültigen ZIP-Datei lautet ** my-jetty-app- [id] .zip **. In zip.xml wird <id> eb </ id> angegeben, sodass der generierte ZIP-Dateiname ** my-jetty-app-eb.zip ** lautet.

Zusammenfassend, wenn Sie den maven-Befehl mvn package ausführen, um die erforderlichen Pakete zu generieren ** my-jetty-app-jar-with-dependencies.jar ** und ** my-jetty-app-eb.zip * Beide * werden im ** Zielverzeichnis ** generiert.

Wir werden dies später erneut überprüfen, wenn wir die Bereitstellungsdatei tatsächlich generieren.

/Procfile

Procfile ist eine Datei zum Ausführen von JAR in EC2 von Elastic Beanstalk.

Der Befehl zum Starten der Anwendung auf EC2 von Elastic Beanstalk wird unter web: beschrieben.

Procfile

web: java -jar my-jetty-app-jar-with-dependencies.jar

Es ist in Ordnung, die Startoption wie ↓ zu beschreiben

web: java -jar my-jetty-app-jar-with-dependencies.jar -Xms256m

Weitere Informationen finden Sie unter Offiziell.

.elasticbeanstalk/config.yml

Beschreiben der Bereitstellungsinformationen in config.yml Hier wird die Datei target / my-jetty-app-eb.zip angegeben, die für Elastic Beansalk bereitgestellt werden soll.

config.yml

deploy:
  artifact: target/my-jetty-app-eb.zip

Auf diese Datei wird bei der Bereitstellung auf Elastic Beanstalk verwiesen.

Derzeit wird nur deploy: Artefakt: beschrieben. Beim Festlegen der Bereitstellung von Elastic Beanstalk mithilfe der EB-CLI werden jedoch von nun an die erforderlichen Werte zu dieser ** config.yml ** hinzugefügt. Ich werde gehen.

Stellen Sie Apps mithilfe der EB CLI bereit

Nachdem Sie eine ungefähre Vorstellung davon haben, was die Datei bedeutet, stellen Sie die App auf Elastic Beanstalk bereit.

Erstellen Sie eine Elastic Beanstalk-Anwendung auf AWS mithilfe der EB-CLI

** 1. Wechseln Sie in das App-Verzeichnis **

cd java-jetty-app-on-elasticbeanstalk

** 2. Erstellen Sie eine Java-Box * in Elastic Beanstalk ** (* Box = Bewerbung)

Der EB CLI-Befehl dafür hat das folgende Format.

Hier lautet der App-Name ** my-eb-app , die Region ist die Region Tokio ( ap-northeast-1 **) und die Plattform ist ** java-8 **.

Der Befehl sieht folgendermaßen aus:

eb init my-eb-app --region ap-northeast-1 --platform java-8

Dann

Application my-eb-app has been created.

Nachricht erscheint, Auf AWS Elastic Beanstalk wird eine Box mit Anwendungen erstellt

Wenn Sie es sofort auf der Webkonsole aktivieren, wird ein Kontrollkästchen (Anwendung) erstellt

https://ap-northeast-1.console.aws.amazon.com/elasticbeanstalk/home

Schauen Sie sich jetzt ** / .elasticbeanstalk / config.yml ** im Quellcode an.

Mit dem obigen Befehl wurde auch ** config.yml ** so aktualisiert:

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 ------------

Wenn Anmeldeinformationen nicht registriert sind </ font>, werden Sie wie unten gezeigt nach ** aws-access-id ** und ** aws-secret-key ** gefragt. Geben Sie diese also ein. ..

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.

mvn clean package

[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] ------------------------------------------------------------------------

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

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