Die vorliegende Übersetzung wurde maschinell erstellt. Im Falle eines Konflikts oder eines Widerspruchs zwischen dieser übersetzten Fassung und der englischen Fassung (einschließlich infolge von Verzögerungen bei der Übersetzung) ist die englische Fassung maßgeblich.

# Bereitstellung von Java-Anwendungen mit Elastic Beanstalk
<a name="create_deploy_Java"></a>

Dieses Kapitel enthält Anweisungen zur Konfiguration und Bereitstellung Ihrer Java-Anwendungen auf. AWS Elastic Beanstalk Elastic Beanstalk macht es einfach, Ihre Java-Webanwendungen mithilfe von Amazon Web Services bereitzustellen, zu verwalten und zu skalieren.

Sie können Ihre Anwendung in nur wenigen Minuten mithilfe der Elastic Beanstalk Command Line Interface (EB CLI) oder der Elastic Beanstalk Beanstalk-Konsole bereitstellen. Nachdem Sie Ihre Elastic Beanstalk Beanstalk-Anwendung bereitgestellt haben, können Sie weiterhin die EB-CLI verwenden, um Ihre Anwendung und Umgebung zu verwalten, oder Sie können die Elastic Beanstalk Beanstalk-Konsole verwenden, AWS CLI oder die. APIs

Folgen Sie den step-by-step Anweisungen [QuickStart für Java](java-quickstart.md) zum Erstellen und Bereitstellen einer *Hello World* Java-Webanwendung mit der EB CLI. Wenn Sie an step-by-step Anleitungen zur Erstellung einer einfachen *Hello World* Java-JSP-Anwendung interessiert sind, die Sie mit der EB-CLI auf unserer Tomcat-basierten Plattform bereitstellen können, probieren Sie die. [QuickStart für Java auf Tomcat](tomcat-quickstart.md)

**Die Java-Plattform verzweigt**  
AWS Elastic Beanstalk unterstützt zwei Plattformen für Java-Anwendungen.
+ **Tomcat** — Eine Plattform, die auf *Apache Tomcat* basiert, einem Open-Source-Webcontainer für Anwendungen, die Java-Servlets und JavaServer Pages (JSPs) zur Bearbeitung von HTTP-Anfragen verwenden. Tomcat vereinfacht die Entwicklung von Webanwendungen durch Multithreading, eine deklarative Sicherheitskonfiguration und umfassende Anpassungsmöglichkeiten. Elastic Beanstalk hat Plattform-Branchen für jede der aktuellen Hauptversionen von Tomcat. Weitere Informationen finden Sie unter [Die Tomcat-Plattform](java-tomcat-platform.md).
+ **Java SE** — Eine Plattform für Anwendungen, die keinen Webcontainer oder einen anderen als Tomcat verwenden, wie Jetty oder. GlassFish Sie können jede Java-Archivbibliothek (JARs), die von Ihrer Anwendung verwendet wird, in das Quellpaket aufnehmen, das Sie auf Elastic Beanstalk bereitstellen. Weitere Informationen finden Sie unter [Die Java SE-Plattform](java-se-platform.md).

Neuere Zweige der Tomcat- und Java SE-Plattformen basieren auf Amazon Linux 2 und höher und verwenden *Corretto*, die AWS Java SE-Distribution. *Die Namen dieser Plattformzweige enthalten das Wort *Corretto* anstelle von Java.*

Eine Liste der aktuellen Plattformversionen finden Sie unter [Tomcat](https://docs.aws.amazon.com/elasticbeanstalk/latest/platforms/platforms-supported.html#platforms-supported.java) und [Java SE](https://docs.aws.amazon.com/elasticbeanstalk/latest/platforms/platforms-supported.html#platforms-supported.javase) im *AWS Elastic Beanstalk Plattform-Handbuch*.

**AWS Werkzeuge**  
AWS bietet mehrere Tools für die Arbeit mit Java und Elastic Beanstalk. Unabhängig davon, für welchen Plattformzweig Sie sich entscheiden, können Sie das [AWS SDK for Java](java-development-environment.md#java-development-environment-sdk) verwenden, um andere AWS Dienste aus Ihrer Java-Anwendung heraus zu verwenden. Das AWS SDK for Java besteht aus einer Reihe von Bibliotheken, mit denen Sie Code AWS APIs aus Ihrer Anwendung verwenden können, ohne die rohen HTTP-Aufrufe von Grund auf neu schreiben zu müssen.

Wenn Sie Ihre Anwendungen lieber über die Befehlszeile verwalten möchten, installieren Sie das [Elastic Beanstalk Command Line Interface](eb-cli3.md) (EB CLI) und verwenden Sie es, um Ihre Elastic Beanstalk Beanstalk-Umgebungen zu erstellen, zu überwachen und zu verwalten. Wenn Sie mehrere Umgebungen für Ihre Anwendung ausführen, kann die EB CLI in Git integriert werden, sodass Sie jede Umgebung einer anderen Git-Branche zuordnen können.

**Topics**
+ [QuickStart: Eine Java-Anwendung auf Elastic Beanstalk bereitstellen](java-quickstart.md)
+ [QuickStart: Stellen Sie eine Java-JSP-Webanwendung für Tomcat auf Elastic Beanstalk bereit](tomcat-quickstart.md)
+ [Einrichten der Java-Entwicklungsumgebung](java-development-environment.md)
+ [Weitere Elastic Beanstalk Beanstalk-Beispielanwendungen und Tutorials für Java](java-getstarted.md)
+ [Elastic Beanstalk Tomcat-Plattform verwenden](java-tomcat-platform.md)
+ [Elastic Beanstalk Java SE-Plattform verwenden](java-se-platform.md)
+ [Hinzufügen einer Amazon RDS-DB-Instance zu Ihrer Java Elastic Beanstalk Beanstalk-Umgebung](java-rds.md)
+ [Java-Tools und -Ressourcen](create_deploy_Java.resources.md)

# QuickStart: Eine Java-Anwendung auf Elastic Beanstalk bereitstellen
<a name="java-quickstart"></a>

Dieses QuickStart Tutorial führt Sie durch den Prozess der Erstellung einer Java-Anwendung und deren Bereitstellung in einer AWS Elastic Beanstalk Umgebung.

**Nicht für den Produktionsgebrauch**  
Beispiele dienen nur zur Veranschaulichung. Verwenden Sie keine Beispielanwendungen in der Produktion.

**Topics**
+ [Ihr AWS Konto](#java-quickstart-aws-account)
+ [Voraussetzungen](#java-quickstart-prereq)
+ [Schritt 1: Erstellen Sie eine Java-Anwendung](#java-quickstart-create-app)
+ [Schritt 2: Führen Sie Ihre Anwendung lokal aus](#java-quickstart-run-local)
+ [Schritt 3: Stellen Sie Ihre Java-Anwendung mit der EB CLI bereit](#java-quickstart-deploy)
+ [Schritt 4: Führen Sie Ihre Anwendung auf Elastic Beanstalk aus](#java-quickstart-run-eb-ap)
+ [Schritt 5: Bereinigen](#java-tutorial-cleanup)
+ [AWS Ressourcen für Ihre Anwendung](#java-quickstart-eb-resources)
+ [Nächste Schritte](#java-quickstart-next-steps)
+ [Bereitstellung mit der Elastic Beanstalk Beanstalk-Konsole](#java-quickstart-console)

## Ihr AWS Konto
<a name="java-quickstart-aws-account"></a>

Wenn Sie noch kein AWS Kunde sind, müssen Sie ein AWS Konto erstellen. Wenn Sie sich registrieren, können Sie auf Elastic Beanstalk und andere AWS Dienste zugreifen, die Sie benötigen.

Wenn Sie bereits ein AWS Konto haben, können Sie weitermachen zu. [Voraussetzungen](#java-quickstart-prereq)

### Erstellen Sie ein AWS Konto
<a name="java-quickstart-aws-account-procedure"></a>

#### Melde dich an für ein AWS-Konto
<a name="sign-up-for-aws"></a>

Wenn Sie noch keine haben AWS-Konto, führen Sie die folgenden Schritte aus, um eine zu erstellen.

**Um sich für eine anzumelden AWS-Konto**

1. Öffnen Sie [https://portal.aws.amazon.com/billing/die Anmeldung.](https://portal.aws.amazon.com/billing/signup)

1. Folgen Sie den Online-Anweisungen.

   Während der Anmeldung erhalten Sie einen Telefonanruf oder eine Textnachricht und müssen einen Verifizierungscode über die Telefontasten eingeben.

   Wenn Sie sich für eine anmelden AWS-Konto, *Root-Benutzer des AWS-Kontos*wird eine erstellt. Der Root-Benutzer hat Zugriff auf alle AWS-Services und Ressourcen des Kontos. Als bewährte Sicherheitsmethode weisen Sie einem Benutzer Administratorzugriff zu und verwenden Sie nur den Root-Benutzer, um [Aufgaben auszuführen, die Root-Benutzerzugriff erfordern](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_root-user.html#root-user-tasks).

AWS sendet Ihnen nach Abschluss des Anmeldevorgangs eine Bestätigungs-E-Mail. Sie können Ihre aktuellen Kontoaktivitäten jederzeit einsehen und Ihr Konto verwalten, indem Sie zu [https://aws.amazon.com/](https://aws.amazon.com/)gehen und **Mein Konto** auswählen.

#### Erstellen eines Benutzers mit Administratorzugriff
<a name="create-an-admin"></a>

Nachdem Sie sich für einen angemeldet haben AWS-Konto, sichern Sie Ihren Root-Benutzer des AWS-Kontos AWS IAM Identity Center, aktivieren und erstellen Sie einen Administratorbenutzer, sodass Sie den Root-Benutzer nicht für alltägliche Aufgaben verwenden.

**Sichern Sie Ihre Root-Benutzer des AWS-Kontos**

1.  Melden Sie sich [AWS-Managementkonsole](https://console.aws.amazon.com/)als Kontoinhaber an, indem Sie **Root-Benutzer** auswählen und Ihre AWS-Konto E-Mail-Adresse eingeben. Geben Sie auf der nächsten Seite Ihr Passwort ein.

   Hilfe bei der Anmeldung mit dem Root-Benutzer finden Sie unter [Anmelden als Root-Benutzer](https://docs.aws.amazon.com/signin/latest/userguide/console-sign-in-tutorials.html#introduction-to-root-user-sign-in-tutorial) im *AWS-Anmeldung -Benutzerhandbuch* zu.

1. Aktivieren Sie die Multi-Faktor-Authentifizierung (MFA) für den Root-Benutzer.

   Anweisungen finden Sie unter [Aktivieren eines virtuellen MFA-Geräts für Ihren AWS-Konto Root-Benutzer (Konsole)](https://docs.aws.amazon.com/IAM/latest/UserGuide/enable-virt-mfa-for-root.html) im *IAM-Benutzerhandbuch*.

**Erstellen eines Benutzers mit Administratorzugriff**

1. Aktivieren Sie das IAM Identity Center.

   Anweisungen finden Sie unter [Aktivieren AWS IAM Identity Center](https://docs.aws.amazon.com//singlesignon/latest/userguide/get-set-up-for-idc.html) im *AWS IAM Identity Center -Benutzerhandbuch*.

1. Gewähren Sie einem Administratorbenutzer im IAM Identity Center Benutzerzugriff.

   *Ein Tutorial zur Verwendung von IAM-Identity-Center-Verzeichnis als Identitätsquelle finden Sie IAM-Identity-Center-Verzeichnis im Benutzerhandbuch unter [Benutzerzugriff mit der Standardeinstellung konfigurieren](https://docs.aws.amazon.com//singlesignon/latest/userguide/quick-start-default-idc.html).AWS IAM Identity Center *

**Anmelden als Administratorbenutzer**
+ Um sich mit Ihrem IAM-Identity-Center-Benutzer anzumelden, verwenden Sie die Anmelde-URL, die an Ihre E-Mail-Adresse gesendet wurde, als Sie den IAM-Identity-Center-Benutzer erstellt haben.

  Hilfe bei der Anmeldung mit einem IAM Identity Center-Benutzer finden Sie [im *AWS-Anmeldung Benutzerhandbuch* unter Anmeldung beim AWS Access-Portal](https://docs.aws.amazon.com/signin/latest/userguide/iam-id-center-sign-in-tutorial.html).

**Weiteren Benutzern Zugriff zuweisen**

1. Erstellen Sie im IAM-Identity-Center einen Berechtigungssatz, der den bewährten Vorgehensweisen für die Anwendung von geringsten Berechtigungen folgt.

   Anweisungen hierzu finden Sie unter [ Berechtigungssatz erstellen](https://docs.aws.amazon.com//singlesignon/latest/userguide/get-started-create-a-permission-set.html) im *AWS IAM Identity Center -Benutzerhandbuch*.

1. Weisen Sie Benutzer einer Gruppe zu und weisen Sie der Gruppe dann Single Sign-On-Zugriff zu.

   Eine genaue Anleitung finden Sie unter [ Gruppen hinzufügen](https://docs.aws.amazon.com//singlesignon/latest/userguide/addgroups.html) im *AWS IAM Identity Center -Benutzerhandbuch*.

## Voraussetzungen
<a name="java-quickstart-prereq"></a>

Um die Verfahren in diesem Leitfaden zu befolgen, benötigen Sie ein Befehlszeilen-Terminal oder eine Shell für die Ausführung der Befehle. Befehle werden ggf. in Auflistungen mit einem vorangestellten Eingabeaufforderungssymbol (\$1) und dem Namen des aktuellen Verzeichnisses angezeigt.

```
~/eb-project$ this is a command
this is output
```

In Linux und macOS können Sie Ihren bevorzugten Shell- und Paket-Manager verwenden. Unter Windows können Sie [das Windows-Subsystem für Linux installieren](https://docs.microsoft.com/en-us/windows/wsl/install-win10), um eine Windows-integrierte Version von Ubuntu und Bash zu erhalten.

### EB-CLI
<a name="java-quickstart-prereq.ebcli"></a>

Dieses Tutorial verwendet die Befehlszeilenschnittstelle Elastic Beanstalk Command Line Interface (EB CLI). Detaillierte Anweisungen zum Installieren und Konfigurieren der EB CLI finden Sie unter [EB CLI mit Setup-Skript installieren (empfohlen)](eb-cli3.md#eb-cli3-install) und [Konfigurieren der EB CLI](eb-cli3-configuration.md).

### Java und Maven
<a name="java-quickstart-prereq.runtime"></a>

Wenn Sie Amazon Corretto nicht auf Ihrem lokalen Computer installiert haben, können Sie es installieren, indem Sie den [Installationsanweisungen](https://docs.aws.amazon.com/corretto/latest/corretto-21-ug/amazon-linux-install.html) im *Amazon Corretto-Benutzerhandbuch* folgen.

Überprüfen Sie Ihre Java-Installation, indem Sie den folgenden Befehl ausführen.

```
~$ java -version 
```

Dieses Tutorial verwendet Maven. Folgen Sie den [Download](https://maven.apache.org/download.cgi) - und [Installationsanweisungen](https://maven.apache.org/install.html) auf der Apache Maven Project-Website. Weitere Informationen zu Maven finden Sie im Maven [Users Center auf der Apache Maven](https://maven.apache.org/users/index.html) Project-Website.

Überprüfen Sie Ihre Maven-Installation, indem Sie den folgenden Befehl ausführen.

```
~$ mvn -v
```

## Schritt 1: Erstellen Sie eine Java-Anwendung
<a name="java-quickstart-create-app"></a>

Erstellen Sie ein Projektverzeichnis.

```
~$ mkdir eb-java
~$ cd eb-java
```

Erstellen Sie anschließend eine Anwendung, die Sie mit Elastic Beanstalk bereitstellen. Wir werden einen „Hello World“ RESTful -Webservice erstellen.

In diesem Beispiel wird das [Spring Boot-Framework](https://spring.io/projects/spring-boot) verwendet. Diese Anwendung öffnet einen Listener auf Port 5000. Elastic Beanstalk leitet Anfragen standardmäßig an Port 5000 an Ihre Anwendung weiter.

Erstellen Sie die folgenden Dateien:

Diese Datei erstellt eine einfache Spring Boot-Anwendung.

**Example `~/eb-java/src/main/java/com/example/Application.java`**  

```
package com.example;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
public class Application {

    public static void main(String[] args) {
        SpringApplication.run(Application.class, args);
    }
}
```

Diese Datei erstellt ein Mapping, das eine Zeichenfolge zurückgibt, die wir hier definieren.

**Example `~/eb-java/src/main/java/com/example/Controller.java`**  

```
package com.example;
    
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;
    
@RestController
public class Controller {
    
    @GetMapping("/")
    public String index() {
       return "Hello Elastic Beanstalk!";
    }
}
```

Diese Datei definiert die Maven-Projektkonfiguration.

**Example `~/eb-java/pom.xml`**  

```
<?xml version="1.0" encoding="UTF-8"?>
<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/xsd/maven-4.0.0.xsd">
  <modelVersion>4.0.0</modelVersion>

  <parent>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-parent</artifactId>
    <version>3.2.3</version>
  </parent>

  <groupId>com.example</groupId>
  <artifactId>BeanstalkJavaExample</artifactId>
  <version>1.0-SNAPSHOT</version>

  <properties>
    <java.version>21</java.version>
  </properties>

  <dependencies>
    <dependency>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-data-rest</artifactId>
    </dependency>
  </dependencies>

  <build>
    <plugins>
      <plugin>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-maven-plugin</artifactId>
      </plugin>
    </plugins>
  </build>

</project>
```

Diese Eigenschaftendatei überschreibt den Standardport 5000. Dies ist der Standardport, an den Elastic Beanstalk Traffic für Java-Anwendungen sendet.

**Example `~/eb-java/application.properties`**  

```
server.port=5000
```

## Schritt 2: Führen Sie Ihre Anwendung lokal aus
<a name="java-quickstart-run-local"></a>

Package Sie Ihre Anwendung mit dem folgenden Befehl:

```
~/eb-java$ mvn clean package
```

Führen Sie Ihre Anwendung lokal mit dem folgenden Befehl aus:

```
~/eb-java$ java -jar target/BeanstalkJavaExample-1.0-SNAPSHOT.jar
```

Während die Anwendung ausgeführt wird, navigieren Sie `http://127.0.0.1:5000/` in Ihrem Browser zu. Du solltest den Text „Hello Elastic Beanstalk\$1“ sehen.

## Schritt 3: Stellen Sie Ihre Java-Anwendung mit der EB CLI bereit
<a name="java-quickstart-deploy"></a>

Bevor wir Ihre Java-Anwendung auf Elastic Beanstalk bereitstellen, löschen wir die Build-Anwendung aus Ihrem Verzeichnis und erstellen ein [Buildfile und ein [Procfile](java-se-procfile.md)](java-se-buildfile.md), um zu kontrollieren, wie die Anwendung in Ihrer Elastic Beanstalk Beanstalk-Umgebung erstellt und ausgeführt wird.

**Um die Anwendungsbereitstellung vorzubereiten und zu konfigurieren**

1. Reinigen Sie die erstellte Anwendung.

   ```
   ~/eb-java$ mvn clean
   ```

1. Erstellen Sie Ihr `Buildfile`.  
**Example `~/eb-java/Buildfile`**  

   ```
   build: mvn clean package
   ```

   Dies `Buildfile` gibt den Befehl an, mit dem Ihre Anwendung erstellt wurde. Wenn Sie a `Buildfile` für eine Java-Anwendung nicht angeben, versucht Elastic Beanstalk nicht, Ihre Anwendung zu erstellen.

1. Erstellen Sie Ihr `Procfile`.  
**Example `~/eb-java/Procfile`**  

   ```
   web: java -jar target/BeanstalkJavaExample-1.0-SNAPSHOT.jar
   ```

   Dies `Procfile` gibt den Befehl an, mit dem Ihre Anwendung ausgeführt wird. Wenn Sie a `Procfile` für eine Java-Anwendung nicht angeben, geht Elastic Beanstalk davon aus, dass sich im Stammverzeichnis Ihres Quellpakets eine JAR-Datei befindet, und versucht, sie mit dem `java -jar` Befehl auszuführen.

 Nachdem Sie nun die Konfigurationsdateien zum Erstellen und Starten Ihrer Anwendung eingerichtet haben, können Sie sie bereitstellen. 

**Um eine Umgebung zu erstellen und Ihre Java-Anwendung bereitzustellen**

1. Initialisieren Sie mit dem Befehl **eb init** das EB CLI-Repository. 

   ```
   ~/eb-java eb init -p corretto java-tutorial --region us-east-2
           
   Application java-tutorial has been created.
   ```

   Dieser Befehl erstellt eine Anwendung mit dem Namen `java-tutorial` und konfiguriert Ihr lokales Repository so, dass Umgebungen mit der neuesten Version der Java-Plattform erstellt werden.

1. (Optional) Führen Sie **eb init** erneut aus, um ein Standardschlüsselpaar für die SSH-Verbindung zur EC2-Instance (auf der die Anwendung ausgeführt wird) zu konfigurieren.

   ```
   ~/eb-java$ eb init
   Do you want to set up SSH for your instances?
   (y/n): y
   Select a keypair.
   1) my-keypair
   2) [ Create new KeyPair ]
   ```

   Wählen Sie ein Schlüsselpaar aus (sofern vorhanden) oder befolgen Sie die Anweisungen, um ein Schlüsselpaar zu erstellen. Falls keine Anweisungen angezeigt werden oder Sie die Einstellungen später ändern möchten, führen Sie **eb init -i** aus.

1. Verwenden Sie **eb create**, um eine Umgebung zu erstellen und die Anwendung darin bereitzustellen. Elastic Beanstalk erstellt automatisch eine Zip-Datei für Ihre Anwendung und startet sie auf Port 5000.

   ```
   ~/eb-java$ eb create java-env
   ```

   Es dauert etwa fünf Minuten, bis Elastic Beanstalk Ihre Umgebung erstellt hat.

## Schritt 4: Führen Sie Ihre Anwendung auf Elastic Beanstalk aus
<a name="java-quickstart-run-eb-ap"></a>

Wenn der Prozess zur Erstellung Ihrer Umgebung abgeschlossen ist, öffnen Sie Ihre Website mit. **eb open**

```
~/eb-java eb open
```

Herzlichen Glückwunsch\$1 Sie haben eine Java-Anwendung mit Elastic Beanstalk bereitgestellt\$1 Es wird ein Browserfenster mit dem für die Anwendung erstellten Domainnamen geöffnet.

## Schritt 5: Bereinigen
<a name="java-tutorial-cleanup"></a>

Sie können Ihre Umgebung beenden, wenn Sie mit der Arbeit an Ihrer Anwendung fertig sind. Elastic Beanstalk beendet alle AWS Ressourcen, die mit Ihrer Umgebung verknüpft sind.

Führen Sie den folgenden Befehl aus, um Ihre Elastic Beanstalk Beanstalk-Umgebung mit der EB-CLI zu beenden.

```
~/eb-java$ eb terminate
```

## AWS Ressourcen für Ihre Anwendung
<a name="java-quickstart-eb-resources"></a>

Sie haben gerade eine Einzelinstanzanwendung erstellt. Es dient als einfache Beispielanwendung mit einer einzigen EC2-Instance, sodass kein Lastenausgleich oder auto Skalierung erforderlich sind. Für Einzelinstanzanwendungen erstellt Elastic Beanstalk die folgenden Ressourcen: AWS 
+ **EC2 instance (EC2-Instance)** – Eine virtuelle Amazon EC2-Maschine zum Ausführen von Webanwendungen auf der von Ihnen ausgewählten Plattform.

  Jede Plattform führt eine andere Gruppe von Software, Konfigurationsdateien und Skripts zur Unterstützung einer bestimmten Sprachversion, eines Framework, Webcontainers oder einer Kombination daraus aus. Die meisten Plattformen verwenden entweder Apache oder nginx als Reverse-Proxy, der Web-Datenverkehr vor Ihrer Web-App verarbeitet, Anforderungen an sie weiterleitet, statische Komponenten verarbeitet und Zugriffs- und Fehlerprotokolle generiert.
+ **Instance security group (Instance-Sicherheitsgruppe)** – Eine Amazon EC2-Sicherheitsgruppe, die so konfiguriert ist, dass eingehender Datenverkehr auf Port 80 zugelassen wird. Mit dieser Ressource kann HTTP-Datenverkehr vom Load Balancer die EC2-Instance mit Ihrer Web-App erreichen. Standardmäßig ist Datenverkehr ist auf anderen Ports nicht zulässig.
+ **Amazon S3-Bucket** – Ein Speicherort für Ihren Quellcode, Protokolle und andere Artefakte, die bei der Verwendung von Elastic Beanstalk erstellt werden.
+ ** CloudWatch Amazon-Alarme** — Zwei CloudWatch Alarme, die die Auslastung der Instances in Ihrer Umgebung überwachen und ausgelöst werden, wenn die Last zu hoch oder zu niedrig ist. Wenn ein Alarm ausgelöst wird, wird Ihre Auto Scaling-Gruppe nach oben oder nach unten skaliert.
+ **CloudFormation stack** — Elastic Beanstalk verwendet CloudFormation , um die Ressourcen in Ihrer Umgebung zu starten und Konfigurationsänderungen zu propagieren. Die Ressourcen werden in einer Vorlage definiert, die Sie in der [CloudFormation -Konsole](https://console.aws.amazon.com/cloudformation) anzeigen können.
+  **Domainname** *— Ein Domainname, der in der Form an Ihre Web-App weitergeleitet wird. *subdomain* *region*.elasticbeanstalk.com*. 

Elastic Beanstalk verwaltet all diese Ressourcen. Wenn Sie die Umgebung beenden, werden alle darin enthaltenen Ressourcen von Elastic Beanstalk beendet.

## Nächste Schritte
<a name="java-quickstart-next-steps"></a>

Nachdem Sie eine Umgebung erstellt haben, in der eine Anwendung ausgeführt wird, können Sie jederzeit eine neue Version der Anwendung oder eine andere Anwendung bereitstellen. Das Bereitstellen einer neuen Anwendungsversion geht sehr schnell, da keine EC2-Instances bereitgestellt oder neu gestartet werden müssen. Sie können Ihre neue Umgebung auch mit der Elastic Beanstalk Beanstalk-Konsole erkunden. Ausführliche Schritte finden [Sie unter Erkunden Sie Ihre Umgebung](GettingStarted.md#GettingStarted.Explore) im Kapitel *Erste Schritte* dieses Handbuchs.

**Probieren Sie weitere Tutorials aus**  
Wenn Sie andere Tutorials mit anderen Beispielanwendungen ausprobieren möchten, finden Sie weitere Informationen unter[Beispielanwendungen und Tutorials](java-getstarted.md).

Wenn Sie eine oder zwei Beispielanwendungen bereitgestellt haben und bereit sind, Java-Anwendungen lokal zu entwickeln und auszuführen, finden Sie weitere Informationen unter[Einrichten der Java-Entwicklungsumgebung](java-development-environment.md). 

## Bereitstellung mit der Elastic Beanstalk Beanstalk-Konsole
<a name="java-quickstart-console"></a>

Sie können die Beispielanwendung auch mit der Elastic Beanstalk Beanstalk-Konsole starten. Ausführliche Schritte finden Sie unter [Erstellen einer Beispielanwendung](GettingStarted.md#GettingStarted.CreateApp) im Kapitel *Erste Schritte* dieses Handbuchs.

# QuickStart: Stellen Sie eine Java-JSP-Webanwendung für Tomcat auf Elastic Beanstalk bereit
<a name="tomcat-quickstart"></a>

Dieses Tutorial führt Sie durch den Prozess der Erstellung einer einfachen Java-Webanwendung mithilfe von JavaServer Pages ()JSPs. Wenn Sie mehrere Webanwendungen in Form von WAR-Dateien in einer einzigen Elastic Beanstalk Beanstalk-Umgebung bündeln möchten, finden Sie weitere Informationen unter. [Bündeln mehrerer WAR-Dateien für Tomcat-Umgebungen](java-tomcat-multiple-war-files.md)

**Nicht für Produktionszwecke**  
Beispiele dienen nur zur Veranschaulichung. Verwenden Sie keine Beispielanwendungen in der Produktion.

**Topics**
+ [Ihr AWS Konto](#tomcat-quickstart-aws-account)
+ [Voraussetzungen](#tomcat-quickstart-prereq)
+ [Schritt 1: Erstellen Sie eine Java-JSP-Anwendung](#tomcat-quickstart-create-app)
+ [Schritt 2: Stellen Sie Ihre Java-JSP-Anwendung mit der EB CLI bereit](#tomcat-quickstart-deploy)
+ [Schritt 3: Führen Sie Ihre Anwendung auf Elastic Beanstalk aus](#tomcat-quickstart-run-eb-ap)
+ [Schritt 4: Bereinigen](#go-tutorial-cleanup)
+ [AWS Ressourcen für Ihre Anwendung](#tomcat-quickstart-eb-resources)
+ [Nächste Schritte](#tomcat-quickstart-next-steps)
+ [Bereitstellung mit der Elastic Beanstalk Beanstalk-Konsole](#tomcat-quickstart-console)

## Ihr AWS Konto
<a name="tomcat-quickstart-aws-account"></a>

Wenn Sie noch kein AWS Kunde sind, müssen Sie ein AWS Konto erstellen. Wenn Sie sich registrieren, können Sie auf Elastic Beanstalk und andere AWS Dienste zugreifen, die Sie benötigen.

Wenn Sie bereits ein AWS Konto haben, können Sie weitermachen zu. [Voraussetzungen](#tomcat-quickstart-prereq)

### Erstellen Sie ein AWS Konto
<a name="tomcat-quickstart-aws-account-procedure"></a>

#### Melde dich an für ein AWS-Konto
<a name="sign-up-for-aws"></a>

Wenn Sie noch keine haben AWS-Konto, führen Sie die folgenden Schritte aus, um eine zu erstellen.

**Um sich für eine anzumelden AWS-Konto**

1. Öffnen Sie [https://portal.aws.amazon.com/billing/die Anmeldung.](https://portal.aws.amazon.com/billing/signup)

1. Folgen Sie den Online-Anweisungen.

   Während der Anmeldung erhalten Sie einen Telefonanruf oder eine Textnachricht und müssen einen Verifizierungscode über die Telefontasten eingeben.

   Wenn Sie sich für eine anmelden AWS-Konto, *Root-Benutzer des AWS-Kontos*wird eine erstellt. Der Root-Benutzer hat Zugriff auf alle AWS-Services und Ressourcen des Kontos. Als bewährte Sicherheitsmethode weisen Sie einem Benutzer Administratorzugriff zu und verwenden Sie nur den Root-Benutzer, um [Aufgaben auszuführen, die Root-Benutzerzugriff erfordern](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_root-user.html#root-user-tasks).

AWS sendet Ihnen nach Abschluss des Anmeldevorgangs eine Bestätigungs-E-Mail. Du kannst jederzeit deine aktuellen Kontoaktivitäten einsehen und dein Konto verwalten, indem du zu [https://aws.amazon.com/](https://aws.amazon.com/)gehst und **Mein Konto** auswählst.

#### Erstellen eines Benutzers mit Administratorzugriff
<a name="create-an-admin"></a>

Nachdem Sie sich für einen angemeldet haben AWS-Konto, sichern Sie Ihren Root-Benutzer des AWS-Kontos AWS IAM Identity Center, aktivieren und erstellen Sie einen Administratorbenutzer, sodass Sie den Root-Benutzer nicht für alltägliche Aufgaben verwenden.

**Sichern Sie Ihre Root-Benutzer des AWS-Kontos**

1.  Melden Sie sich [AWS-Managementkonsole](https://console.aws.amazon.com/)als Kontoinhaber an, indem Sie **Root-Benutzer** auswählen und Ihre AWS-Konto E-Mail-Adresse eingeben. Geben Sie auf der nächsten Seite Ihr Passwort ein.

   Hilfe bei der Anmeldung mit dem Root-Benutzer finden Sie unter [Anmelden als Root-Benutzer](https://docs.aws.amazon.com/signin/latest/userguide/console-sign-in-tutorials.html#introduction-to-root-user-sign-in-tutorial) im *AWS-Anmeldung -Benutzerhandbuch* zu.

1. Aktivieren Sie die Multi-Faktor-Authentifizierung (MFA) für den Root-Benutzer.

   Anweisungen finden Sie unter [Aktivieren eines virtuellen MFA-Geräts für Ihren AWS-Konto Root-Benutzer (Konsole)](https://docs.aws.amazon.com/IAM/latest/UserGuide/enable-virt-mfa-for-root.html) im *IAM-Benutzerhandbuch*.

**Erstellen eines Benutzers mit Administratorzugriff**

1. Aktivieren Sie das IAM Identity Center.

   Anweisungen finden Sie unter [Aktivieren AWS IAM Identity Center](https://docs.aws.amazon.com//singlesignon/latest/userguide/get-set-up-for-idc.html) im *AWS IAM Identity Center -Benutzerhandbuch*.

1. Gewähren Sie einem Administratorbenutzer im IAM Identity Center Benutzerzugriff.

   *Ein Tutorial zur Verwendung von IAM-Identity-Center-Verzeichnis als Identitätsquelle finden Sie IAM-Identity-Center-Verzeichnis im Benutzerhandbuch unter [Benutzerzugriff mit der Standardeinstellung konfigurieren](https://docs.aws.amazon.com//singlesignon/latest/userguide/quick-start-default-idc.html).AWS IAM Identity Center *

**Anmelden als Administratorbenutzer**
+ Um sich mit Ihrem IAM-Identity-Center-Benutzer anzumelden, verwenden Sie die Anmelde-URL, die an Ihre E-Mail-Adresse gesendet wurde, als Sie den IAM-Identity-Center-Benutzer erstellt haben.

  Hilfe bei der Anmeldung mit einem IAM Identity Center-Benutzer finden Sie [im *AWS-Anmeldung Benutzerhandbuch* unter Anmeldung beim AWS Access-Portal](https://docs.aws.amazon.com/signin/latest/userguide/iam-id-center-sign-in-tutorial.html).

**Weiteren Benutzern Zugriff zuweisen**

1. Erstellen Sie im IAM-Identity-Center einen Berechtigungssatz, der den bewährten Vorgehensweisen für die Anwendung von geringsten Berechtigungen folgt.

   Anweisungen hierzu finden Sie unter [ Berechtigungssatz erstellen](https://docs.aws.amazon.com//singlesignon/latest/userguide/get-started-create-a-permission-set.html) im *AWS IAM Identity Center -Benutzerhandbuch*.

1. Weisen Sie Benutzer einer Gruppe zu und weisen Sie der Gruppe dann Single Sign-On-Zugriff zu.

   Eine genaue Anleitung finden Sie unter [ Gruppen hinzufügen](https://docs.aws.amazon.com//singlesignon/latest/userguide/addgroups.html) im *AWS IAM Identity Center -Benutzerhandbuch*.

## Voraussetzungen
<a name="tomcat-quickstart-prereq"></a>

Um die Verfahren in diesem Leitfaden zu befolgen, benötigen Sie ein Befehlszeilen-Terminal oder eine Shell für die Ausführung der Befehle. Befehle werden ggf. in Auflistungen mit einem vorangestellten Eingabeaufforderungssymbol (\$1) und dem Namen des aktuellen Verzeichnisses angezeigt.

```
~/eb-project$ this is a command
this is output
```

In Linux und macOS können Sie Ihren bevorzugten Shell- und Paket-Manager verwenden. Unter Windows können Sie [das Windows-Subsystem für Linux installieren](https://docs.microsoft.com/en-us/windows/wsl/install-win10), um eine Windows-integrierte Version von Ubuntu und Bash zu erhalten.

### EB-CLI
<a name="tomcat-quickstart-prereq.ebcli"></a>

Dieses Tutorial verwendet die Befehlszeilenschnittstelle Elastic Beanstalk Command Line Interface (EB CLI). Detaillierte Anweisungen zum Installieren und Konfigurieren der EB CLI finden Sie unter [EB CLI mit Setup-Skript installieren (empfohlen)](eb-cli3.md#eb-cli3-install) und [Konfigurieren der EB CLI](eb-cli3-configuration.md).

## Schritt 1: Erstellen Sie eine Java-JSP-Anwendung
<a name="tomcat-quickstart-create-app"></a>

Erstellen Sie ein Projektverzeichnis.

```
~$ mkdir eb-tomcat
~$ cd eb-tomcat
```

Erstellen Sie anschließend eine Anwendung, die Sie mit Elastic Beanstalk bereitstellen. Wir werden eine „Hello World“ -Webanwendung erstellen.

Erstellen Sie eine einfache JSP-Datei mit dem Namen`index.jsp`.

**Example `~/eb-tomcat/index.jsp`**  

```
<html>
  <body>
    <%out.println("Hello Elastic Beanstalk!");%>
  </body>
</html>
```

## Schritt 2: Stellen Sie Ihre Java-JSP-Anwendung mit der EB CLI bereit
<a name="tomcat-quickstart-deploy"></a>

Führen Sie die folgenden Befehle aus, um eine Elastic Beanstalk Beanstalk-Umgebung für diese Anwendung zu erstellen.

 

**Um eine Umgebung zu erstellen und Ihre Java-JSP-Anwendung bereitzustellen**

1. Initialisieren Sie mit dem Befehl **eb init** das EB CLI-Repository.

   ```
   ~/eb-tomcat$ eb init -p tomcat tomcat-tutorial --region us-east-2
   ```

   Dieser Befehl erstellt eine Anwendung mit dem Namen `tomcat-tutorial` und konfiguriert Ihr lokales Repository so, dass Umgebungen mit der neuesten Tomcat-Plattformversion erstellt werden.

1. (Optional) Führen Sie **eb init** erneut aus, um ein Standardschlüsselpaar für die SSH-Verbindung zur EC2-Instance (auf der die Anwendung ausgeführt wird) zu konfigurieren.

   ```
   ~/eb-go$ eb init
   Do you want to set up SSH for your instances?
   (y/n): y
   Select a keypair.
   1) my-keypair
   2) [ Create new KeyPair ]
   ```

   Wählen Sie ein Schlüsselpaar aus (sofern vorhanden) oder befolgen Sie die Anweisungen, um ein Schlüsselpaar zu erstellen. Falls keine Anweisungen angezeigt werden oder Sie die Einstellungen später ändern möchten, führen Sie **eb init -i** aus.

1. Verwenden Sie **eb create**, um eine Umgebung zu erstellen und die Anwendung darin bereitzustellen. Elastic Beanstalk erstellt automatisch eine Zip-Datei für Ihre Anwendung und startet sie auf Port 5000.

   ```
   ~/eb-tomcat$ eb create tomcat-env
   ```

   Es dauert etwa fünf Minuten, bis Elastic Beanstalk Ihre Umgebung erstellt hat.

## Schritt 3: Führen Sie Ihre Anwendung auf Elastic Beanstalk aus
<a name="tomcat-quickstart-run-eb-ap"></a>

Wenn der Prozess zur Erstellung Ihrer Umgebung abgeschlossen ist, öffnen Sie Ihre Website mit. **eb open**

```
~/eb-tomcat$ eb open
```

Herzlichen Glückwunsch\$1 Sie haben eine Java-JSP-Anwendung mit Elastic Beanstalk bereitgestellt\$1 Es wird ein Browserfenster mit dem für die Anwendung erstellten Domainnamen geöffnet.

## Schritt 4: Bereinigen
<a name="go-tutorial-cleanup"></a>

Sie können Ihre Umgebung beenden, wenn Sie mit der Arbeit an Ihrer Anwendung fertig sind. Elastic Beanstalk beendet alle AWS Ressourcen, die mit Ihrer Umgebung verknüpft sind.

Führen Sie den folgenden Befehl aus, um Ihre Elastic Beanstalk Beanstalk-Umgebung mit der EB-CLI zu beenden.

```
~/eb-tomcat$ eb terminate
```

## AWS Ressourcen für Ihre Anwendung
<a name="tomcat-quickstart-eb-resources"></a>

Sie haben gerade eine Einzelinstanzanwendung erstellt. Es dient als einfache Beispielanwendung mit einer einzigen EC2-Instance, sodass kein Lastenausgleich oder auto Skalierung erforderlich sind. Für Einzelinstanzanwendungen erstellt Elastic Beanstalk die folgenden Ressourcen: AWS 
+ **EC2 instance (EC2-Instance)** – Eine virtuelle Amazon EC2-Maschine zum Ausführen von Webanwendungen auf der von Ihnen ausgewählten Plattform.

  Jede Plattform führt eine andere Gruppe von Software, Konfigurationsdateien und Skripts zur Unterstützung einer bestimmten Sprachversion, eines Framework, Webcontainers oder einer Kombination daraus aus. Die meisten Plattformen verwenden entweder Apache oder nginx als Reverse-Proxy, der Web-Datenverkehr vor Ihrer Web-App verarbeitet, Anforderungen an sie weiterleitet, statische Komponenten verarbeitet und Zugriffs- und Fehlerprotokolle generiert.
+ **Instance security group (Instance-Sicherheitsgruppe)** – Eine Amazon EC2-Sicherheitsgruppe, die so konfiguriert ist, dass eingehender Datenverkehr auf Port 80 zugelassen wird. Mit dieser Ressource kann HTTP-Datenverkehr vom Load Balancer die EC2-Instance mit Ihrer Web-App erreichen. Standardmäßig ist Datenverkehr ist auf anderen Ports nicht zulässig.
+ **Amazon S3-Bucket** – Ein Speicherort für Ihren Quellcode, Protokolle und andere Artefakte, die bei der Verwendung von Elastic Beanstalk erstellt werden.
+ ** CloudWatch Amazon-Alarme** — Zwei CloudWatch Alarme, die die Auslastung der Instances in Ihrer Umgebung überwachen und ausgelöst werden, wenn die Last zu hoch oder zu niedrig ist. Wenn ein Alarm ausgelöst wird, wird Ihre Auto Scaling-Gruppe nach oben oder nach unten skaliert.
+ **CloudFormation stack** — Elastic Beanstalk verwendet CloudFormation , um die Ressourcen in Ihrer Umgebung zu starten und Konfigurationsänderungen zu propagieren. Die Ressourcen werden in einer Vorlage definiert, die Sie in der [CloudFormation -Konsole](https://console.aws.amazon.com/cloudformation) anzeigen können.
+  **Domainname** *— Ein Domainname, der in der Form an Ihre Web-App weitergeleitet wird. *subdomain* *region*.elasticbeanstalk.com*. 

Elastic Beanstalk verwaltet all diese Ressourcen. Wenn Sie die Umgebung beenden, werden alle darin enthaltenen Ressourcen von Elastic Beanstalk beendet.

## Nächste Schritte
<a name="tomcat-quickstart-next-steps"></a>

Nachdem Sie eine Umgebung erstellt haben, in der eine Anwendung ausgeführt wird, können Sie jederzeit eine neue Version der Anwendung oder eine andere Anwendung bereitstellen. Das Bereitstellen einer neuen Anwendungsversion geht sehr schnell, da keine EC2-Instances bereitgestellt oder neu gestartet werden müssen. Sie können Ihre neue Umgebung auch mit der Elastic Beanstalk Beanstalk-Konsole erkunden. Ausführliche Schritte finden [Sie unter Erkunden Sie Ihre Umgebung](GettingStarted.md#GettingStarted.Explore) im Kapitel *Erste Schritte* dieses Handbuchs.

**Probieren Sie weitere Tutorials aus**  
Wenn Sie andere Tutorials mit anderen Beispielanwendungen ausprobieren möchten, finden Sie weitere Informationen unter[Beispielanwendungen und Tutorials](java-getstarted.md).

Wenn Sie eine oder zwei Beispielanwendungen bereitgestellt haben und bereit sind, mit der Entwicklung und Ausführung von Java-Anwendungen in einem lokalen Tomcat-Webcontainer zu beginnen, finden Sie weitere Informationen unter[Einrichten der Java-Entwicklungsumgebung](java-development-environment.md). 

## Bereitstellung mit der Elastic Beanstalk Beanstalk-Konsole
<a name="tomcat-quickstart-console"></a>

Sie können die Beispielanwendung auch mit der Elastic Beanstalk Beanstalk-Konsole starten. Ausführliche Schritte finden Sie unter [Erstellen einer Beispielanwendung](GettingStarted.md#GettingStarted.CreateApp) im Kapitel *Erste Schritte* dieses Handbuchs.

# Einrichten der Java-Entwicklungsumgebung
<a name="java-development-environment"></a>

Dieses Thema enthält Anweisungen zum Einrichten einer Java-Entwicklungsumgebung, um Ihre Anwendung lokal zu testen, bevor Sie sie bereitstellen AWS Elastic Beanstalk. Außerdem wird auf Websites verwiesen, die Installationsanweisungen für nützliche Tools bereitstellen.

**Topics**
+ [Installieren des Java Development Kits](#java-development-environment-jdk)
+ [Installieren eines Webcontainers](#java-development-environment-tomcat)
+ [Herunterladen von Bibliotheken](#java-development-environment-libraries)
+ [Das AWS SDK for Java installieren](#java-development-environment-sdk)
+ [Installieren einer IDE oder eines Texteditors](#java-development-environment-ide)

## Installieren des Java Development Kits
<a name="java-development-environment-jdk"></a>

Installieren des Java Development Kits (JDK). Falls Sie keine Version bevorzugen, wählen Sie die neueste aus. Laden Sie das JDK unter [oracle.com](http://www.oracle.com/technetwork/java/javase/downloads/index.html) herunter. 

Das JDK enthält den Java-Compiler, mit dem Sie Quelldateien in Klassendateien erstellen können, die sich auf einem Elastic Beanstalk-Webserver ausführen lassen.

## Installieren eines Webcontainers
<a name="java-development-environment-tomcat"></a>

Wenn Sie noch keinen anderen Webcontainer oder Framework haben, installieren Sie eine Version von Tomcat, die Elastic Beanstalk für Ihr Amazon Linux-Betriebssystem unterstützt. *Eine Liste der aktuellen Versionen von Apache Tomcat, die Elastic Beanstalk unterstützt, finden Sie unter [Tomcat](https://docs.aws.amazon.com/elasticbeanstalk/latest/platforms/platforms-supported.html#platforms-supported.java) im Dokument Platforms.AWS Elastic Beanstalk * [Laden Sie die Tomcat-Version, die für Ihre Umgebung gilt, von der Apache Tomcat-Website herunter.](http://tomcat.apache.org) 

## Herunterladen von Bibliotheken
<a name="java-development-environment-libraries"></a>

Elastic Beanstalk-Plattformen enthalten standardmäßig nur wenige Bibliotheken. Laden Sie die Bibliotheken, die von der Anwendung genutzt werden, herunter und speichern Sie diese im Projektordner, um sie im Quell-Bundle der Anwendung bereitzustellen.

Wenn Sie Tomcat lokal installiert haben, können Sie die Servlet-API und die JavaServer Pages (JSP) -API-Bibliotheken aus dem Installationsordner kopieren. Wenn die Bereitstellung für eine Tomcat-Plattformversion erfolgt, ist es nicht nötig, diese Dateien in das Quell-Bundle einzubinden. Allerdings müssen Sie zur Kompilierung aller Klassen, die sie verwenden, im `classpath` vorhanden sein.

JUnit, Google Guava und Apache Commons bieten mehrere nützliche Bibliotheken. Weitere Informationen finden Sie auf den entsprechenden Homepages:
+  [Download JUnit](https://github.com/junit-team/junit/wiki/Download-and-Install) 
+  [Google Guava herunterladen](https://code.google.com/p/guava-libraries/) 
+  [Apache Commons herunterladen](http://commons.apache.org/downloads/) 

## Das AWS SDK for Java installieren
<a name="java-development-environment-sdk"></a>

Wenn Sie AWS Ressourcen von Ihrer Anwendung aus verwalten müssen, installieren Sie das AWS SDK for Java. Mit dem können Sie beispielsweise Amazon DynamoDB (DynamoDB) verwenden AWS SDK für Java, um den Sitzungsstatus von Apache Tomcat-Anwendungen auf mehreren Webservern gemeinsam zu nutzen. Weitere Informationen finden Sie unter [Tomcat-Sitzungsstatus mit Amazon DynamoDB verwalten in der Dokumentation](https://docs.aws.amazon.com/AWSSdkDocsJava/latest/DeveloperGuide/java-dg-tomcat-session-manager.html) zum AWS SDK for Java.

Weitere Informationen und Installationsanleitungen finden Sie auf der [AWS Homepage SDK für Java](https://aws.amazon.com/sdk-for-java/).

## Installieren einer IDE oder eines Texteditors
<a name="java-development-environment-ide"></a>

Integrierte Entwicklungsumgebungen (IDEs) bieten eine Vielzahl von Funktionen, die die Anwendungsentwicklung erleichtern. Falls Sie noch keine IDE für die Java-Entwicklung eingesetzt haben, probieren Sie Eclipse und IntelliJ aus. Dann sehen Sie, welche IDE für Sie am besten geeignet ist.
+  [Eclipse IDE for Java EE Developers installieren](https://www.eclipse.org/downloads/) 
+  [IntelliJ installieren](https://www.jetbrains.com/idea/) 

Mit einer IDE werden dem Projektordner möglicherweise Dateien hinzugefügt, die Sie unter Umständen nicht an die Quellüberwachung übergeben möchten. Damit diese Dateien nicht an die Quellüberwachung übergeben werden, setzen Sie `.gitignore` oder die Entsprechung Ihres Quellüberwachungstools ein.

Wenn Sie gerade mit dem Programmieren beginnen und nicht alle Funktionen einer IDE benötigen, können Sie [installing Sublime Text (Installieren von Sublime Text)](http://www.sublimetext.com/) auswählen.

**Anmerkung**  
Am 31. Mai 2023 hat er das Ende seiner Lebensdauer [AWS Toolkit for Eclipse](https://docs.aws.amazon.com//toolkit-for-eclipse/v1/user-guide/welcome.html)erreicht und wird nicht mehr von unterstützt AWS. Weitere Informationen zum Ende des Lebenszyklus von finden Sie in der AWS Toolkit for Eclipse Datei [README.md](https://github.com/aws/aws-toolkit-eclipse) im Repository. AWS Toolkit for Eclipse GitHub 

# Weitere Elastic Beanstalk Beanstalk-Beispielanwendungen und Tutorials für Java
<a name="java-getstarted"></a>

Dieser Abschnitt enthält zusätzliche Anwendungen und Tutorials. Die [QuickStart für Java auf Tomcat](tomcat-quickstart.md) Themen [QuickStart für Java](java-quickstart.md) und weiter oben in diesem Thema führen Sie durch das Starten einer Java-Beispielanwendung mit der EB CLI.

Für den Einstieg in Java-Anwendungen benötigen Sie lediglich ein [Anwendungsquellpaket AWS Elastic Beanstalk](applications-sourcebundle.md), das Sie als erste Anwendungsversion hochladen und in einer Umgebung bereitstellen können. Im Rahmen der Umgebungserstellung werden von Elastic Beanstalk alle erforderlichen AWS Ressourcen für eine skalierbare Webanwendung zugewiesen.

## Starten einer Umgebung mit einer Java-Beispielanwendung
<a name="java-getstarted-samples"></a>

Elastic Beanstalk bietet einseitige Beispielanwendungen für jede Plattform sowie komplexere Beispiele, die die Verwendung zusätzlicher AWS Ressourcen wie Amazon RDS und sprach- oder plattformspezifische Funktionen und zeigen. APIs

Die einzelnen Seitenbeispiele haben den gleichen Code, den Sie auch erhalten, wenn Sie eine Umgebung erstellen, ohne Ihren eigenen Quellcode anzugeben. Die komplexeren Beispiele werden auf gehostet GitHub und müssen möglicherweise vor der Bereitstellung in einer Elastic Beanstalk Beanstalk-Umgebung kompiliert oder erstellt werden.

 


**Beispiele**  

|  Name  |  Unterstützte Versionen  |  Umgebungstyp  |  Quelle  |  Beschreibung  | 
| --- | --- | --- | --- | --- | 
|  Tomcat (einzelne Seite)  |  Alle *Tomcat mit Corretto*-Branches der Plattform  |  Webserver Worker  |   [tomcat.zip](samples/tomcat.zip)   |  Tomcat-Webanwendung mit einer Seite (`index.jsp`), die im Stamm der Website angezeigt wird. Für [Worker-Umgebungen](using-features-managing-env-tiers.md) enthält dieses Beispiel eine `cron.yaml`-Datei, mit der eine geplante Aufgabe konfiguriert wird, die `scheduled.jsp` einmal pro Minute aufruft. Wenn `scheduled.jsp` aufgerufen wird, schreibt sie in eine Protokolldatei unter `/tmp/sample-app.log`. Schließlich ist eine Konfigurationsdatei in `.ebextensions` enthalten, die die Protokolle aus `/tmp/` in die Standorte kopiert, die von Elastic Beanstalk gelesen werden, wenn Sie Umgebungsprotokolle anfordern. Wenn Sie in einer Umgebung, auf der dieses Beispiel ausgeführt wird, [X-Ray-Integration aktivieren](environment-configuration-debugging.md), zeigt diese Anwendung zusätzlichen Inhalt hinsichtlich X-Ray und bietet eine Option zum Generieren von Debug-Informationen, die Sie in der X-Ray-Konsole anzeigen können.  | 
|  Corretto (einzelne Seite)  |  Corretto 11 Corretto 8  |  Webserver  |  [corretto.zip](samples/corretto.zip)  |  Corretto-Anwendung mit `Buildfile`- und `Procfile`-Konfigurationsdateien. Wenn Sie in einer Umgebung, auf der dieses Beispiel ausgeführt wird, [X-Ray-Integration aktivieren](environment-configuration-debugging.md), zeigt diese Anwendung zusätzlichen Inhalt hinsichtlich X-Ray und bietet eine Option zum Generieren von Debug-Informationen, die Sie in der X-Ray-Konsole anzeigen können.  | 
|  Scorekeep  | Java 8 | Webserver | [Klonen Sie das Repo auf .com GitHub](https://github.com/awslabs/eb-java-scorekeep) |  *Scorekeep* ist eine RESTful Web-API, die das Spring-Framework verwendet, um eine Schnittstelle für die Erstellung und Verwaltung von Benutzern, Sitzungen und Spielen bereitzustellen. Die API ist mit einer Angular 1.5-Web-App gebündelt, von der die API über HTTP eingesetzt wird. Die Anwendung nutzt Funktionen der Java SE-Plattform, um Abhängigkeiten herunterzuladen und auf Instances zu erstellen, und minimiert so die Größe des Quell-Bundles. Die Anwendung umfasst auch nginx-Konfigurationsdateien, mit denen die Standardkonfiguration überschrieben wird, sodass die Bereitstellung der Frontend-Webanwendung statisch auf Port 80 über den Proxy erfolgt und Anforderungen über Pfade unter `/api` an die auf `localhost:5000` ausgeführte API weitergeleitet werden. Scorekeep enthält auch eine `xray`-Verzweigung, die zeigt, wie eine Java-Anwendung für die Verwendung mit AWS X-Ray instrumentiert wird. Es zeigt die Instrumentierung eingehender HTTP-Anfragen mit einem Servlet-Filter, die automatische und manuelle AWS SDK-Client-Instrumentierung, die Rekorderkonfiguration und die Instrumentierung ausgehender HTTP-Anfragen und SQL-Clients. Anweisungen finden Sie in der Readme-Datei oder verwenden Sie das [AWS X-Ray Tutorial Erste Schritte](https://docs.aws.amazon.com/xray/latest/devguide/xray-gettingstarted.html), um die Anwendung mit X-Ray auszuprobieren.  | 
|  Does it Have Snakes?  | Tomcat 8 mit Java 8 | Webserver | [Klonen Sie das Repo auf .com GitHub](https://github.com/awslabs/eb-tomcat-snakes) |  *Hat es Schlangen?* ist eine Tomcat-Webanwendung, die die Verwendung von Elastic Beanstalk Beanstalk-Konfigurationsdateien, Amazon RDS, JDBC, PostgreSQL, Servlets, Simple Tag Support, Tag Files JSPs, Log4J, Bootstrap und Jackson zeigt. Der Quellcode für dieses Projekt enthält ein minimales Build-Skript, das die Servlets und Modelle in Klassendateien kompiliert und die erforderlichen Dateien in ein Webarchiv verpackt, das Sie in einer Elastic Beanstalk-Umgebung bereitstellen können. Vollständige Anweisungen dazu finden Sie in der Readme-Datei im Projekt-Repository.  | 
| Locust Load Generator | Java 8 | Webserver | [ GitHubKlonen Sie das Repo auf .com](https://github.com/awslabs/eb-locustio-sample) |  Webanwendung, die Sie verwenden können, um eine andere laufende Webanwendung in einer Elastic Beanstalk-Umgebung zu testen. Zeigt die Verwendung von `Buildfile`- und `Procfile`-Dateien, DynamoDB und [Locust](http://locust.io/), ein Open-Source-Tool für Belastungstests.  | 

Laden Sie eine Beispielanwendung herunter und stellen Sie diese in Elastic Beanstalk bereit. Führen Sie dazu die folgenden Schritte aus:

**Um eine Umgebung mit einer Anwendung (Konsole) zu starten**

1. Öffnen Sie die [Elastic Beanstalk Beanstalk-Konsole](https://console.aws.amazon.com/elasticbeanstalk) und wählen Sie in der Liste **Regionen** Ihre aus. AWS-Region

1. Wählen Sie im Navigationsbereich **Applications (Anwendungen)**. Wählen Sie eine bestehende Anwendung in der Liste aus. Sie können sich auch dafür entscheiden, eine zu erstellen, indem Sie den Anweisungen unter folgen[Verwalten von -Anwendungen](applications.md).

1. Wählen Sie auf der Seite mit der Anwendungsübersicht die Option **Umgebung erstellen** aus.

   Dadurch wird der Assistent **Create environment** (Umgebung erstellen) gestartet. Der Assistent enthält eine Reihe von Schritten, mit denen Sie eine neue Umgebung erstellen können.

1. Wählen Sie für die **Umgebungsebene** die **Webserver-Umgebung** oder die Umgebungsebene **[Worker-Umgebung](concepts.md#concepts-tier)** aus. Nach der Erstellung lässt sich die Umgebungsebene nicht mehr ändern.
**Anmerkung**  
Die [.NET-Plattform auf Windows Server](create_deploy_NET.md) unterstützt die Worker-Umgebungsebene nicht.

   Die Standardfelder für **Anwendungsinformationen** basieren auf der Anwendung, die Sie zuvor ausgewählt haben.

   In der Gruppe **Umgebungsinformationen** wird der **Umgebungsname** standardmäßig auf der Grundlage des Anwendungsnamens voreingestellt. Wenn Sie einen anderen Umgebungsnamen bevorzugen, können Sie einen anderen Wert in das Feld eingeben. Sie können optional einen **Domainnamen** eingeben. Andernfalls generiert Elastic Beanstalk automatisch einen Wert. **Sie können optional auch eine Beschreibung der Umgebung eingeben.**

1. Wählen Sie in **Platform (Plattform)** die Plattform und die Plattformbranche aus, die/der mit der Sprache Ihrer Anwendung übereinstimmt.
**Anmerkung**  
Elastic Beanstalk unterstützt mehrere [Versionen](concepts.platforms.md) für die meisten Plattformen, die aufgelistet sind. Standardmäßig wählt die Konsole die empfohlene Version für die gewählte Plattform und Plattformvariante. Wenn Ihre Anwendung eine andere Version erfordert, können Sie diese hier auswählen. Informationen zu unterstützten Plattformversionen finden Sie unter [Von Elastic Beanstalk unterstützte Plattformen](concepts.platforms.md).

1. Beim **Anwendungscode** haben Sie mehrere Möglichkeiten, fortzufahren.
   + Um die Standard-Beispielanwendung ohne Angabe des Quellcodes zu starten, wählen Sie **Beispielanwendung**. Diese Aktion wählt die Einzelseitenanwendung aus, die Elastic Beanstalk für die zuvor ausgewählte Plattform bereitstellt.
   + Wenn Sie eine Beispielanwendung aus diesem Handbuch heruntergeladen haben oder Ihren eigenen Quellcode für eine Anwendung haben, gehen Sie wie folgt vor.

     1. Wählen Sie **Code hochladen** aus.

     1. Wählen Sie als Nächstes **Lokale Datei** und dann unter **Anwendung hochladen** die Option **Datei auswählen** aus.

     1. Das Betriebssystem Ihres Client-Computers bietet Ihnen eine Oberfläche zur Auswahl der lokalen Datei, die Sie heruntergeladen haben. Wählen Sie die Quellpaketdatei aus und fahren Sie fort.

1. Ihre Wahl für **Voreinstellungen** hängt von Ihrem Verwendungszweck für die Umgebung ab.
   + Wenn Sie eine Beispielumgebung erstellen, um mehr über Elastic Beanstalk oder eine Entwicklungsumgebung zu erfahren, wählen Sie **Single Instance (kostenloses Kontingent berechtigt**).
   + Wenn Sie eine Produktionsumgebung oder eine Umgebung erstellen, um mehr über Load Balancing zu erfahren, wählen Sie eine der Optionen für **hohe Verfügbarkeit**.

1. Wählen Sie **Weiter** aus.

**Um den Servicezugriff zu konfigurieren**  
Als Nächstes benötigen Sie zwei Rollen. Eine *Service-Rolle* ermöglicht es Elastic Beanstalk, Ihre EC2-Instances zu überwachen und die Plattform Ihrer Umgebung zu aktualisieren. Eine *EC2-Instance-Profilrolle* ermöglicht Aufgaben wie das Schreiben von Logs und die Interaktion mit anderen Services.

**Um die Service-Rolle zu erstellen oder auszuwählen**

1. Wenn Sie zuvor eine **Servicerolle** erstellt haben und eine vorhandene auswählen möchten, wählen Sie den Wert aus der Dropdownliste **Servicerolle** aus und überspringen Sie die restlichen Schritte, um eine Servicerolle zu erstellen.

1. Wenn keine Werte für die **Servicerolle** aufgeführt sind oder Sie eine neue erstellen möchten, fahren Sie mit den nächsten Schritten fort.

1. Wählen Sie für **Servicerolle** die Option **Rolle erstellen** aus.

1. Wählen Sie unter **Vertrauenswürdiger Entitätstyp** die Option **AWS -Service** aus.

1. Wählen Sie als **Anwendungsfall** **Elastic Beanstalk —** Environment.

1. Wählen Sie **Weiter** aus.

1. **Vergewissern Sie sich, dass **die Berechtigungsrichtlinien** Folgendes beinhalten, und wählen Sie dann Weiter aus:**
   + `AWSElasticBeanstalkEnhancedHealth`
   + `AWSElasticBeanstalkManagedUpdatesCustomerRolePolicy`

1. Wählen Sie **Rolle erstellen** aus.

1. Kehren **Sie zur Registerkarte Dienstzugriff konfigurieren** zurück, aktualisieren Sie die Liste und wählen Sie dann die neu erstellte Servicerolle aus.

**Um ein EC2-Instanzprofil zu erstellen oder auszuwählen**

1. Wenn Sie zuvor ein **EC2-Instanzprofil** erstellt haben und ein vorhandenes auswählen möchten, wählen Sie den Wert aus der Dropdownliste für das **EC2-Instanzprofil** aus und überspringen Sie die restlichen Schritte, um ein EC2-Instanzprofil zu erstellen.

1. Wenn keine Werte für das **EC2-Instanzprofil** aufgeführt sind oder Sie ein neues erstellen möchten, fahren Sie mit den nächsten Schritten fort.

1. Wählen Sie **Rolle erstellen** aus.

1. Wählen Sie unter **Vertrauenswürdiger Entitätstyp** die Option **AWS -Service** aus.

1. Wählen Sie als **Anwendungsfall** **Elastic Beanstalk — Compute**.

1. Wählen Sie **Weiter** aus.

1. **Vergewissern Sie sich, dass **die Berechtigungsrichtlinien** Folgendes beinhalten, und wählen Sie dann Weiter aus:**
   + `AWSElasticBeanstalkWebTier`
   + `AWSElasticBeanstalkWorkerTier`
   + `AWSElasticBeanstalkMulticontainerDocker`

1. Wählen Sie **Rolle erstellen** aus.

1. Kehren **Sie zur Registerkarte Dienstzugriff konfigurieren** zurück, aktualisieren Sie die Liste und wählen Sie dann das neu erstellte EC2-Instanzprofil aus.

**Um die Konfiguration und Erstellung Ihrer Anwendung abzuschließen**

1. (Optional) Wenn Sie zuvor ein EC2-Schlüsselpaar erstellt haben, können Sie es aus der Dropdownliste für das **EC2-Schlüsselpaarfeld** auswählen. Sie würden es verwenden, um sich sicher bei der Amazon EC2-Instance anzumelden, die Elastic Beanstalk für Ihre Anwendung bereitstellt. Wenn Sie diesen Schritt überspringen, können Sie jederzeit ein EC2-Schlüsselpaar erstellen und zuweisen, nachdem die Umgebung erstellt wurde. Weitere Informationen finden Sie unter [EC2 key pair](using-features.managing.security.md#using-features.managing.security.keypair).

1. Wählen Sie auf der Seite **Configure service access** (Servicezugriff konfigurieren) die Option **Skip to Review** (Zur Überprüfung springen).

1. Auf der Seite **Review** (Überprüfung) wird eine Zusammenfassung all Ihrer Auswahlmöglichkeiten angezeigt.

   Um Ihre Umgebung weiter anzupassen, wählen Sie neben dem Schritt, der alle Elemente enthält, die Sie konfigurieren möchten, die Option **Edit** (Bearbeiten). Sie können die folgenden Optionen nur während des Erstellens der Umgebung festlegen:
   + Environment name
   + Domainname
   + Version der Plattform
   + Prozessor
   + Load balancer type (Load-Balancer-Typ)
   + Stufe

   Sie können die folgenden Einstellungen nach der Umgebungserstellung zwar ändern, jedoch müssen dafür neue Instances oder andere Ressourcen bereitgestellt werden, deren Anwendung viel Zeit in Anspruch nehmen kann:
   + Instance-Typ, Root-Volume, key pair und AWS Identity and Access Management (IAM-) Rolle
   + Interne Amazon RDS-Datenbank
   + VPC

   Weitere Informationen zu allen verfügbaren Einstellungen finden Sie unter [Der Assistent zum Erstellen einer neuen Umgebung](environments-create-wizard.md).

1. Wählen Sie unten auf der Seite **Submit** (Senden), um die Erstellung Ihrer neuen Umgebung zu initialisieren.

## Nächste Schritte
<a name="java-getstarted-next"></a>

Nachdem Sie eine Umgebung erstellt haben, in der eine Anwendung ausgeführt wird, können Sie jederzeit [eine neue Version](using-features.deploy-existing-version.md) der Anwendung oder eine gänzlich andere Anwendung bereitstellen. Das Bereitstellen einer neuen Anwendungsversion geht sehr schnell, da keine EC2-Instances bereitgestellt oder neu gestartet werden müssen.

Wenn Sie ein oder zwei Beispielanwendungen bereitgestellt haben, können Sie mit der lokalen Entwicklung und Ausführung von Java-Anwendungen beginnen. Die entsprechenden Informationen zum Einrichten einer Java-Entwicklungsumgebung und zu allen benötigten Tools und Bibliotheken finden Sie im [nächsten Abschnitt](java-development-environment.md).

# Elastic Beanstalk Tomcat-Plattform verwenden
<a name="java-tomcat-platform"></a>

In diesem Thema wird beschrieben, wie Sie Ihre Java-Anwendungen, die auf der Elastic Beanstalk Tomcat-Plattform ausgeführt werden, konfigurieren, erstellen und ausführen.

Die AWS Elastic Beanstalk Tomcat-Plattform besteht aus einer Reihe von [Plattformversionen](https://docs.aws.amazon.com/elasticbeanstalk/latest/platforms/platforms-supported.html#platforms-supported.java) für Java-Webanwendungen, die in einem Tomcat-Webcontainer ausgeführt werden können. Tomcat läuft hinter einem nginx-Proxy-Server. Jeder Plattformzweig entspricht einer Hauptversion von Tomcat.

In der Elastic Beanstalk-Konsole sind Konfigurationsoptionen für das [Ändern der Konfiguration einer ausgeführten Umgebung](environment-configuration-methods-after.md) verfügbar. Um zu verhindern, dass die Umgebungskonfiguration beim Beenden verloren geht, können Sie [gespeicherte Konfigurationen](environment-configuration-savedconfig.md) verwenden, um Ihre Einstellungen zu speichern und sie später für eine andere Umgebung zu übernehmen.

Zum Speichern der Einstellungen im Quellcode können Sie [Konfigurationsdateien](ebextensions.md) einschließen. Die Einstellungen in Konfigurationsdateien werden jedes Mal verwendet, wenn Sie eine Umgebung erstellen oder Ihre Anwendung bereitstellen. Mit Konfigurationsdateien können Sie auch Pakete installieren, Skripts ausführen und andere Instance-Anpassungen bei Bereitstellungen vornehmen.

Die Elastic Beanstalk Tomcat-Plattform beinhaltet einen Reverse-Proxy-Server, der Anforderungen an die Anwendung weiterleitet. Sie können [Konfigurationsoptionen](#java-tomcat-namespaces) verwenden, um den Proxy-Server zur Verarbeitung statischer Komponenten aus einem Ordner im Quellcode zu konfigurieren und so die Auslastung für die Anwendung zu reduzieren. In erweiterten Szenarien können Sie [eigene `.conf`-Dateien in das Quell-Bundle einbinden](java-tomcat-proxy.md), um die Proxy-Konfiguration von Elastic Beanstalk zu erweitern oder zu überschreiben.

**Anmerkung**  
Elastic Beanstalk unterstützt [nginx](https://www.nginx.com/) (Standard) und [Apache HTTP Server](https://httpd.apache.org/) als Proxy-Server auf der Tomcat-Plattform. Wenn Ihre Elastic Beanstalk Tomcat-Umgebung einen Branch der Amazon-Linux-AMI-Plattform (vor Amazon Linux 2) verwendet, haben Sie auch die Möglichkeit, [Apache HTTP Server Version 2.2](https://httpd.apache.org/docs/2.2/) zu verwenden. Apache (neueste) ist der Standardwert für diese älteren Plattformzweige.   
 [Am 18. Juli 2022](https://docs.aws.amazon.com/elasticbeanstalk/latest/relnotes/release-2022-07-18-linux-al1-retire.html) **hat Elastic Beanstalk den Status aller Plattformbranches, die auf Amazon Linux AMI (AL1) basieren, auf eingestellt gesetzt.** Weitere Informationen zur Migration zu einem aktuellen und vollständig unterstützten Plattformzweig für Amazon Linux 2023 finden Sie unter [Migrieren der Elastic-Beanstalk-Linux-Anwendung zu Amazon Linux 2023 oder Amazon Linux 2](using-features.migration-al.md).

Java-Anwendungen müssen in einem Webanwendungsarchiv (WAR-Datei) mit einer bestimmten Struktur platziert werden. Weitere Informationen zur erforderlichen Struktur und deren Bezug zur Projektverzeichnisstruktur finden Sie unter [Strukturieren Ihres Projektordners](java-tomcat-platform-directorystructure.md).

Für die Ausführung von mehreren Anwendungen auf demselben Webserver können Sie in einem einzigen Quell-Bundle [mehrere WAR-Dateien bündeln](java-tomcat-multiple-war-files.md). Jede Anwendung in einem Quell-Bundle mit mehreren WAR-Dateien wird je nach dem WAR-Dateinamen entweder mit dem Stammpfad (`ROOT.war` mit `myapp.elasticbeanstalk.com/`) oder mit einem direkt darunter liegenden Pfad (`app2.war` mit `myapp.elasticbeanstalk.com/app2/`) ausgeführt. In einem Quell-Bundle mit einer einzigen WAR-Datei wird die Anwendung immer mit dem Stammpfad ausgeführt.

Die in der Elastic Beanstalk-Konsole angewendeten Einstellungen überschreiben die entsprechenden Einstellungen in Konfigurationsdateien, wenn vorhanden. So sind Standardeinstellungen in Konfigurationsdateien möglich, die Sie mit umgebungsspezifischen Einstellungen in der Konsole überschreiben können. Für weitere Informationen zur Rangfolge und zu anderen Methoden zum Ändern der Einstellungen siehe [Konfigurationsoptionen](command-options.md).

Details zu den verschiedenen Möglichkeiten für das Erweitern einer Linux-basierten Elastic Beanstalk-Plattform finden Sie unter [Erweitern von Elastic Beanstalk-Linux-Plattformen](platforms-linux-extend.md).

**Topics**
+ [Konfigurieren Ihrer Tomcat-Umgebung](#java-tomcat-options)
+ [Tomcat-Konfigurations-Namespaces](#java-tomcat-namespaces)
+ [Bündeln mehrerer WAR-Dateien für Tomcat-Umgebungen](java-tomcat-multiple-war-files.md)
+ [Strukturieren Ihres Projektordners](java-tomcat-platform-directorystructure.md)
+ [Konfigurieren des Proxy-Server](java-tomcat-proxy.md)

## Konfigurieren Ihrer Tomcat-Umgebung
<a name="java-tomcat-options"></a>

Die Elastic Beanstalk Tomcat-Plattform bietet einige plattformspezifische Optionen zusätzlich zu den Standard-Optionen, die allen Plattformen gemeinsam sind. Mit diesen Optionen können Sie die JVM (Java Virtual Machine) konfigurieren, die auf den Webservern der Umgebung ausgeführt wird, und die Systemeigenschaften definieren, die Zeichenfolgen mit Konfigurationsinformationen für die Anwendung bereitstellen.

Mit der Elastic Beanstalk-Konsole können Sie die Protokollrotation für Amazon S3 aktivieren und Variablen konfigurieren, die die Anwendung in der Umgebung lesen kann.

**So konfigurieren Sie Ihre Tomcat-Umgebung in der Elastic Beanstalk-Konsole:**

1. Öffnen Sie die [Elastic Beanstalk Beanstalk-Konsole](https://console.aws.amazon.com/elasticbeanstalk) und wählen Sie in der Liste **Regionen** Ihre aus. AWS-Region

1. Wählen Sie im Navigationsbereich **Environments (Umgebungen)** aus und wählen Sie dann in der Liste den Namen Ihrer Umgebung aus.

1. Wählen Sie im Navigationsbereich **Configuration (Konfiguration)** aus.

1. Wählen Sie in der Konfigurationskategorie **Updates, monitoring and logging ** (Updates, Überwachung und Protokolle) die Option **Edit** (Bearbeiten) aus.

### Container-Optionen
<a name="java-tomcat-options-container"></a>

Sie können die folgenden plattformspezifischen Optionen angeben:
+ **Proxy server (Proxy-Server)** – Der Proxy-Server, der in Ihren Umgebungs-Instances verwendet werden soll. Standardmäßig wird nginx verwendet.

### JVM-Containeroptionen
<a name="java-tomcat-options-jvm"></a>

Über die Heap-Größe in der JVM wird bestimmt, wie viele Objekte die Anwendung im Speicher erstellen kann, bevor eine *[garbage collection (Speicherbereinigung)](https://docs.oracle.com/javase/8/docs/technotes/guides/vm/gctuning/introduction.html)* erfolgt. Sie können die **Ursprüngliche JVM-Heap-Größe** (`-Xms option`) und eine **Maximale JVM-Heap-Größe** (`-Xmx`-Option) ändern. Wenn Sie einen höheren Wert für die anfängliche Heap-Größe angeben, können mehr Objekte erstellt werden, bevor eine Speicherbereinigung ausgeführt wird. Jedoch dauert es länger, bis der Heap im Rahmen der Garbage Collection (Speicherbereinigung) komprimiert ist. Die maximale Heap-Größe gibt die maximale Größe des Arbeitsspeichers an, die bei einer großen Auslastung von der JVM für die Heap-Erweiterung zugewiesen werden kann.

**Anmerkung**  
Der verfügbare Speicher hängt vom Amazon EC2-Instance-Typ ab. Weitere Informationen zu den für die Elastic Beanstalk-Umgebung verfügbaren EC2-Instance-Typen finden Sie unter [Instance Types (Instance-Typen)](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/instance-types.html) im *Amazon Elastic Compute Cloud-Benutzerhandbuch für Linux-Instances*.

Der JVM-Heap verfügt über einen Bereich für *permanente Generierung*, in dem Klassendefinitionen und zugehörige Metadaten gespeichert werden. Um die Größe der permanenten Generierung zu ändern, geben Sie die neue Größe in die Option **Maximale PermGen JVM-Größe** (`-XX:MaxPermSize`) ein. Diese Einstellung gilt nur für Java 7 und frühere Versionen. **Diese Option war in JDK 8 veraltet und wurde durch die Option Size () ersetzt. MaxMetaspace** `-XX:MaxMetaspaceSize`

**Wichtig**  
JDK 17 hat die Unterstützung der `-XX:MaxPermSize` Java-Option entfernt. Die Verwendung dieser Option in einer Umgebung, die auf einem Elastic-Beanstalk-Plattformzweig mit Corretto 17 läuft, führt zu einem Fehler. Elastic Beanstalk veröffentlichte am [13. Juli 2023](https://docs.aws.amazon.com/elasticbeanstalk/latest/relnotes/release-2023-07-13-al2023.html) seinen ersten Plattformzweig, auf dem Tomcat mit Corretto 17 ausgeführt wird.  
Weitere Informationen finden Sie in den folgenden Ressourcen.  
Website zur Oracle-Java-Dokumentation: [Java-Optionen entfernt](https://docs.oracle.com/en/java/javase/17/docs/specs/man/java.html#removed-java-options) 
Website zur Oracle-Java-Dokumentation: Abschnitt *Klassenmetadaten* in [Weitere Überlegungen](https://docs.oracle.com/javase/8/docs/technotes/guides/vm/gctuning/considerations.html)

Weitere Informationen zu Elastic-Beanstalk-Plattformen und ihren Komponenten finden Sie unter [Unterstützte Plattformen](https://docs.aws.amazon.com/elasticbeanstalk/latest/platforms/platforms-supported.html) im *AWS Elastic Beanstalk -Plattformhandbuch*.

### Protokolloptionen
<a name="java-tomcat-options-logs"></a>

Im Abschnitt mit den **Protokolloptionen** sind zwei Einstellungen vorhanden:
+ **Instance profile (Instance-Profil)** – Gibt das Instance-Profil an, das zum Zugriff auf den entsprechenden Amazon S3-Bucket der Anwendung berechtigt ist.
+ **Enable log file rotation to Amazon S3** (Protokolldateirotation für Amazon S3 aktivieren) – Gibt an, ob die Protokolldateien für die Amazon-EC2-Instances der Anwendung in den der Anwendung zugeordneten Amazon-S3-Bucket kopiert werden.

### Statische Dateien
<a name="java-tomcat-options-staticfiles"></a>

Um die Leistung zu verbessern, können Sie den Abschnitt **Static files** (Statische Dateien) benutzen, um den Proxy-Server so zu konfigurieren, dass er statische Dateien (z. B. HTML oder Bilder) aus Verzeichnissen innerhalb Ihrer Webanwendung bereitstellt. Legen Sie für jedes Verzeichnis den virtuellen Pfad zum Verzeichnis-Mapping fest. Wenn der Proxy-Server eine Anfrage nach einer Datei unter dem angegebenen Pfad erhält, stellt er die Datei direkt bereit, anstatt die Anfrage an Ihre Anwendung weiterzuleiten.

Weitere Informationen zum Konfigurieren statischer Dateien mit der Elastic Beanstalk-Konsole finden Sie unter [Bereitstellen von statischen Dateien](environment-cfg-staticfiles.md).

### Umgebungseigenschaften
<a name="java-tomcat-options-properties"></a>

Im Bereich **Environment Properties (Umgebungseigenschaften)** können Sie die Einstellungen für die Umgebungskonfiguration der Amazon-EC2-Instances angeben, auf denen die Anwendung ausgeführt wird. Umgebungseigenschaften werden als Schlüssel-Wert-Paare an die Anwendung weitergeleitet. 

Die Tomcat-Plattform definiert für Tomcat-Umgebungen die Platzhaltereigenschaft `JDBC_CONNECTION_STRING`, um eine Verbindungszeichenfolge an eine externe Datenbank zu übergeben.

**Anmerkung**  
Wenn Sie eine RDS DB-Instance an Ihre Umgebung anhängen, konstruieren Sie die JDBC-Verbindungszeichenfolge dynamisch aus den Eigenschaften der Amazon Relational Database Service (Amazon RDS)-Umgebung, die von Elastic Beanstalk bereitgestellt werden. Verwenden Sie JDBC\$1CONNECTION\$1STRING nur für Datenbank-Instances, die nicht mithilfe von Elastic Beanstalk bereitgestellt werden.  
Weitere Informationen zur Verwendung von Amazon RDS mit Ihrer Java-Anwendung finden Sie unter [Hinzufügen einer Amazon RDS-DB-Instance zu Ihrer Java Elastic Beanstalk Beanstalk-Umgebung](java-rds.md).

Bei Tomcat-Plattformversionen, die vor dem [26. März 2025 veröffentlicht wurden,](https://docs.aws.amazon.com/elasticbeanstalk/latest/relnotes/release-2025-03-26-windows.html) kann auf Umgebungsvariablen zugegriffen werden über. `System.getProperty()` Sie könnten beispielsweise eine `API_ENDPOINT` aus einer Variablen benannte Eigenschaft mit dem folgenden Code lesen.

```
String endpoint = System.getProperty("API_ENDPOINT");
```

Tomcat-Plattformversionen, die am oder nach dem [26. März 2025 veröffentlicht wurden,](https://docs.aws.amazon.com/elasticbeanstalk/latest/relnotes/release-2025-03-26-windows.html) können auch für den `System.getenv` Zugriff auf Klartext-Umgebungsvariablen verwendet werden. Sie können es weiterhin für den Zugriff `System.getProperty` auf Klartext-Umgebungsvariablen verwenden. [Umgebungsvariablen, die als Geheimnisse gespeichert](AWSHowTo.secrets.env-vars.md) sind, sind jedoch nur über `System.getenv` verfügbar. Sie könnten beispielsweise eine Umgebungsvariable lesen, die `API_KEY` mit dem folgenden Code benannt ist.

```
String apiKey = System.getenv("API_KEY");
```

**Wichtig**  
Der zusätzliche `System.getenv()` Zugriff auf Umgebungsvariablen in Versionen der Tomcat-Plattform, die am oder nach dem [26. März 2025 veröffentlicht wurden,](https://docs.aws.amazon.com/elasticbeanstalk/latest/relnotes/release-2025-03-26-windows.html) kann zu unerwartetem Verhalten in Anwendungen führen, die Umgebungsvariablen Vorrang vor Java-Systemeigenschaften geben, oder wenn explizit von `System.getProperty()` zu gewechselt wird. `System.getenv()`  
Da Systemeigenschaften (die über die Befehlszeile übergeben werden) Shell-Escaping für Sonderzeichen erfordern, Umgebungsvariablen jedoch nicht, können Werte anders aufgelöst werden, wenn Umgebungsvariablen anstelle von Java-Systemeigenschaften verwendet werden.  
Wenn Ihre Anwendung betroffen ist, sollten Sie Folgendes berücksichtigen:  
Entfernen Sie Escape-Zeichen aus den Eigenschaftswerten Ihrer Umgebung, wenn Sie `System.getenv()`
Konfiguration Ihrer Anwendung für die explizite Verwendung `System.getProperty()`
Testen Sie Ihre Anwendung beim Upgrade gründlich, um ein konsistentes Verhalten sicherzustellen

Weitere Informationen finden Sie unter [Umgebungsvariablen und andere Softwareeinstellungen](environments-cfg-softwaresettings.md).

## Tomcat-Konfigurations-Namespaces
<a name="java-tomcat-namespaces"></a>

Mithilfe einer [Konfigurationsdatei](ebextensions.md) können Sie im Rahmen der Bereitstellung Konfigurationsoptionen festlegen und andere Instance-Konfigurationsaufgaben ausführen. Die Konfigurationsoptionen können [plattformspezifisch](command-options-specific.md) sein oder für [alle Plattformen](command-options-general.md) im Elastic Beanstalk-Service als Ganzes gelten. *Die Konfigurationsoptionen sind in Namespaces organisiert.*

Die Tomcat-Plattform unterstützt neben den [unterstützten Optionen für alle Elastic Beanstalk-Umgebungen](command-options-general.md) auch Optionen in den folgenden Namespaces:
+ `aws:elasticbeanstalk:container:tomcat:jvmoptions` – Ändern von JVM-Einstellungen. Die Optionen in diesem Namespace entsprechen wie folgt den Optionen in der Managementkonsole:
  + `Xms` – **JVM-Befehlszeilenoptionen**
  + `JVM Options` – **JVM-Befehlszeilenoptionen**
+ `aws:elasticbeanstalk:environment:proxy` – Wählen Sie den Proxy-Server der Umgebung aus.

In der folgenden Beispielkonfigurationsdatei wird die Verwendung von Tomcat-spezifischen Konfigurationsoptionen veranschaulicht.

**Example .ebextensions/tomcat-settings.config**  

```
option_settings:
  aws:elasticbeanstalk:container:tomcat:jvmoptions:
    Xms: 512m
    JVM Options: '-Xmn128m'
  aws:elasticbeanstalk:application:environment:
    API_ENDPOINT: mywebapi.zkpexsjtmd.us-west-2.elasticbeanstalk.com
  aws:elasticbeanstalk:environment:proxy:
    ProxyServer: apache
```

Elastic Beanstalk bietet zahlreiche Konfigurationsoptionen für die Anpassung Ihrer Umgebung. Neben den Konfigurationsdateien können Sie die Konfigurationsoptionen auch unter Verwendung der Konsole, gespeicherter Konfigurationen, der EB CLI oder der AWS CLI einrichten. Weitere Informationen finden Sie unter [Konfigurationsoptionen](command-options.md).

## Die Amazon Linux-AMI (vor Amazon Linux 2) Tomcat-Plattform
<a name="tomcat.alami"></a>

Falls Ihre Elastic Beanstalk Tomcat-Umgebung eine Amazon Linux AMI-Plattformversion (vor Amazon Linux 2) verwendet, lesen Sie die zusätzlichen Informationen in diesem Abschnitt.

**Hinweise**  
Die Informationen in diesem Thema gelten nur für Plattformbranches, die auf Amazon Linux AMI (AL1) basieren. AL2023/AL2 Plattformbranches sind nicht mit früheren Amazon Linux AMI (AL1) -Plattformversionen kompatibel und *erfordern andere Konfigurationseinstellungen*.
 [Am 18. Juli 2022](https://docs.aws.amazon.com/elasticbeanstalk/latest/relnotes/release-2022-07-18-linux-al1-retire.html) **hat Elastic Beanstalk den Status aller Plattformbranches, die auf Amazon Linux AMI (AL1) basieren, auf eingestellt gesetzt.** Weitere Informationen zur Migration zu einem aktuellen und vollständig unterstützten Plattformzweig für Amazon Linux 2023 finden Sie unter [Migrieren der Elastic-Beanstalk-Linux-Anwendung zu Amazon Linux 2023 oder Amazon Linux 2](using-features.migration-al.md).

### Namespaces für die Tomcat-Konfiguration — Amazon Linux AMI () AL1
<a name="tomcat.alami.namespaces"></a>

Die Tomcat Amazon Linux AMI-Plattform unterstützt zusätzliche Optionen in den folgenden Namespaces:
+ `aws:elasticbeanstalk:container:tomcat:jvmoptions` – Zusätzlich zu den oben auf dieser Seite für diesen Namespace erwähnten Optionen unterstützen ältere Amazon Linux-AMI-Plattformversionen auch Folgendes:
  + `XX:MaxPermSize` – **Maximale Größe für die permanente JVM-Generierung**
+ `aws:elasticbeanstalk:environment:proxy` – Konfigurieren Sie nicht nur den Proxy-Server, sondern auch die Antwortkomprimierung.

In der folgenden Beispielkonfigurationsdatei wird die Verwendung der Proxy-Namespace-Konfigurationsoptionen veranschaulicht.

**Example .ebextensions/tomcat-settings.config**  

```
option_settings:
  aws:elasticbeanstalk:environment:proxy:
    GzipCompression: 'true'
    ProxyServer: nginx
```

### Elastic Beanstalk Beanstalk-Konfigurationsdateien einbeziehen — Amazon Linux AMI () AL1
<a name="java-tomcat-ebextensions"></a>

Um `.ebextensions`-Konfigurationsdateien bereitzustellen, schließen Sie sie in Ihre Anwendungsquelle ein. Fügen Sie für eine einzelne Anwendung `.ebextensions` zu einer komprimierten WAR-Datei hinzu, indem Sie den folgenden Befehl ausführen:

**Example**  

```
zip -ur your_application.war .ebextensions
```

Für eine Anwendung, die mehrere WAR-Dateien benötigt, finden Sie weitere Anweisungen unter [Bündeln mehrerer WAR-Dateien für Tomcat-Umgebungen](java-tomcat-multiple-war-files.md).

# Bündeln mehrerer WAR-Dateien für Tomcat-Umgebungen
<a name="java-tomcat-multiple-war-files"></a>

Wenn Ihre Web-App mehrere Web-Anwendungskomponenten umfasst, können Sie die Bereitstellung vereinfachen und die Betriebskosten senken, indem Sie Komponenten in einer einzigen Umgebung ausführen, anstatt eine separate Umgebung für jede Komponente auszuführen. Diese Strategie ist für leichte Anwendungen effektiv, die nicht viele Ressourcen erfordern, und für Entwicklungs- und Testumgebungen.

Zur Bereitstellung von mehreren Webanwendungen in Ihrer Umgebung kombinieren Sie die WAR-Dateien jeder Komponente zu einem einzelnen [Quell-Bundle](applications-sourcebundle.md).

Zum Erstellen eines Quell-Bundle der Anwendung mit mehreren WAR-Dateien organisieren Sie die WAR-Dateien mithilfe der folgenden Struktur.

```
MyApplication.zip
├── .ebextensions
├── .platform
├── foo.war
├── bar.war
└── ROOT.war
```

Wenn Sie ein Quellpaket mit mehreren WAR-Dateien in einer AWS Elastic Beanstalk Umgebung bereitstellen, ist jede Anwendung über einen anderen Pfad außerhalb des Stammdomänennamens zugänglich. Das vorausgehende Beispiel enthält drei Anwendungen: `foo`, `bar` und `ROOT`. `ROOT.war` ist ein spezieller Dateiname, der Elastic Beanstalk auffordert, diese Anwendung in der Stamm-Domäne auszuführen, damit die drei Anwendungen unter `http://MyApplication.elasticbeanstalk.com/foo`, `http://MyApplication.elasticbeanstalk.com/bar` und `http://MyApplication.elasticbeanstalk.com` verfügbar sind.

Das Quellpaket kann WAR-Dateien, einen optionalen `.ebextensions`-Ordner und einen optionalen `.platform`-Ordner enthalten. Weitere Informationen zu diesen optionalen Konfigurationsordnern finden Sie unter [Erweitern von Elastic Beanstalk-Linux-Plattformen](platforms-linux-extend.md).

**So starten Sie eine Umgebung (Konsole)**

1. [Öffnen Sie die Elastic Beanstalk Beanstalk-Konsole mit diesem vorkonfigurierten Link: console.aws.amazon. com/elasticbeanstalk/home\$1/newApplication? Anwendungsname=Tutorials&EnvironmentType= LoadBalanced](https://console.aws.amazon.com/elasticbeanstalk/home#/newApplication?applicationName=tutorials&environmentType=LoadBalanced)

1. Wählen Sie für **Platform (Plattform)** die Plattform und den Plattformzweig aus, die der von Ihrer Anwendung verwendeten Sprache entsprechen, oder die Docker-Plattform für containerbasierte Anwendungen.

1. Wählen Sie für **Application code (Anwendungscode)** die Option **Upload your code (Eigenen Code hochladen)**.

1. Wählen Sie **Local file (Lokale Datei)**, wählen Sie **Choose file (Datei wählen)** und öffnen Sie das Quell-Bundle.

1. Klicken Sie auf **Review and launch (Überprüfen und starten)**.

1. Prüfen Sie die verfügbaren Einstellungen und wählen Sie **Create app (Anwendung erstellen)** aus.

Weitere Informationen zum Erstellen von Quell-Bundles finden Sie unter [Ein Elastic Beanstalk Beanstalk-Anwendungsquellpaket erstellen](applications-sourcebundle.md).

# Strukturieren Ihres Projektordners
<a name="java-tomcat-platform-directorystructure"></a>

Damit auf einem Tomcat-Server bereitgestellte kompilierte Java EE (*Java Platform Enterprise Edition*)-Webanwendungsarchive (WAR-Dateien) genutzt werden können, müssen sie nach bestimmten [Richtlinien](https://docs.oracle.com/javaee/7/tutorial/packaging003.htm) strukturiert sein. Ihr Projektverzeichnis muss nicht denselben Standards entsprechen, dies wäre aber sinnvoll, da Kompilierung und Paketerstellung vereinfacht werden. Wenn Sie den Projektordner genauso strukturieren wie die WAR-Dateiinhalte, können Sie die Beziehung der Dateien untereinander und deren Verhalten auf dem Webserver leichter nachvollziehen.

In der folgenden empfohlenen Hierarchie wird der Quellcode der Webanwendung im Verzeichnis `src` platziert und so vom Build-Skript und der generierten WAR-Datei separiert.

```
~/workspace/my-app/
|-- build.sh            - Build script that compiles classes and creates a WAR
|-- README.MD           - Readme file with information about your project, notes
|-- ROOT.war            - Source bundle artifact created by build.sh
`-- src                 - Source code folder
    |-- WEB-INF         - Folder for private supporting files
    |   |-- classes     - Compiled classes
    |   |-- lib         - JAR libraries
    |   |-- tags        - Tag files
    |   |-- tlds        - Tag Library Descriptor files
    |   `-- web.xml     - Deployment Descriptor
    |-- com             - Uncompiled classes
    |-- css             - Style sheets
    |-- images          - Image files
    |-- js              - JavaScript files
    `-- default.jsp     - JSP (JavaServer Pages) webpage
```

Die Ordnerinhalte von `src` sind identisch mit den Daten, die Sie packen und auf dem Server bereitstellen, mit Ausnahme des Ordners `com`. Der `com`-Ordner enthält die nicht kompilierten Klassen (`.java`-Dateien). Diese müssen kompiliert und im Verzeichnis `WEB-INF/classes` gespeichert werden, damit der Anwendungscode darauf zugreifen kann.

Das Verzeichnis `WEB-INF` enthält Code und Konfigurationen, die nicht öffentlich auf dem Webserver bereitgestellt werden. Die anderen Ordner im Stamm des Quellverzeichnisses (`css`, `images` und `js`) sind unter dem entsprechenden Pfad öffentlich auf dem Webserver verfügbar.

Das folgende Beispiel ist identisch mit dem vorherigen Projektverzeichnis, weist aber mehr Dateien und Unterverzeichnisse auf. Dieses Beispielprojekt umfasst einfache Tags, Modell- und Support-Klassen sowie eine JSP (Java Server Pages)-Datei für eine `record`-Ressource. Es enthält auch ein Stylesheet und JavaScript für [Bootstrap](http://getbootstrap.com/) eine Standard-JSP-Datei und eine Fehlerseite für 404-Fehler.

`WEB-INF/lib` enthält eine JAR-Datei (Java Archive) mit dem JDBC-Treiber (Java Database Connectivity) für PostgreSQL. `WEB-INF/classes` ist leer, da die Klassendateien noch nicht kompiliert wurden.

```
~/workspace/my-app/
|-- build.sh
|-- README.MD
|-- ROOT.war
`-- src
    |-- WEB-INF
    |   |-- classes
    |   |-- lib
    |   |   `-- postgresql-9.4-1201.jdbc4.jar
    |   |-- tags
    |   |   `-- header.tag
    |   |-- tlds
    |   |   `-- records.tld
    |   `-- web.xml
    |-- com
    |   `-- myapp
    |       |-- model
    |       |   `-- Record.java
    |       `-- web
    |           `-- ListRecords.java
    |-- css
    |   |-- bootstrap.min.css
    |   `-- myapp.css
    |-- images
    |   `-- myapp.png
    |-- js
    |   `-- bootstrap.min.js
    |-- 404.jsp
    |-- default.jsp
    `-- records.jsp
```

## Erstellen einer WAR-Datei mit einem Shell-Skript
<a name="java-tomcat-platform-directorystructure-building"></a>

`build.sh` ist ein sehr einfaches Shell-Skript, das Java-Klassen kompiliert, eine WAR-Datei erstellt und diese für lokale Tests in das Tomcat-Verzeichnis `webapps` kopiert:

```
cd src
javac -d WEB-INF/classes com/myapp/model/Record.java
javac -classpath WEB-INF/lib/*:WEB-INF/classes -d WEB-INF/classes com/myapp/model/Record.java
javac -classpath WEB-INF/lib/*:WEB-INF/classes -d WEB-INF/classes com/myapp/web/ListRecords.java

jar -cvf ROOT.war *.jsp images css js WEB-INF
cp ROOT.war /Library/Tomcat/webapps
mv ROOT.war ../
```

Die Struktur in der WAR-Datei entspricht der Struktur im Verzeichnis `src` aus dem vorigen Beispiel, mit Ausnahme des Ordners `src/com`. Mit dem Befehl `jar` wird die Datei `META-INF/MANIFEST.MF` automatisch erstellt.

```
~/workspace/my-app/ROOT.war
|-- META-INF
|   `-- MANIFEST.MF
|-- WEB-INF
|   |-- classes
|   |   `-- com
|   |       `-- myapp
|   |           |-- model
|   |           |   `-- Records.class
|   |           `-- web
|   |               `-- ListRecords.class
|   |-- lib
|   |   `-- postgresql-9.4-1201.jdbc4.jar
|   |-- tags
|   |   `-- header.tag
|   |-- tlds
|   |   `-- records.tld
|   `-- web.xml
|-- css
|   |-- bootstrap.min.css
|   `-- myapp.css
|-- images
|   `-- myapp.png
|-- js
|   `-- bootstrap.min.js
|-- 404.jsp
|-- default.jsp
`-- records.jsp
```

## benutze `.gitignore`
<a name="java-tomcat-platform-gitignore"></a>

Damit keine kompilierten Klassendateien und WAR-Dateien an das Git-Repository übergeben oder diesbezügliche Meldungen beim Ausführen von Git-Befehlen angezeigt werden, fügen Sie die entsprechenden Dateitypen zur Datei `.gitignore` im Projektordner hinzu:

**\$1/workspace/myapp/.gitignore**

```
*.zip
*.class
```

# Konfigurieren des Proxy-Server
<a name="java-tomcat-proxy"></a>

Die Tomcat-Plattform verwendet [nginx](https://www.nginx.com/) (die Standardeinstellung) oder [Apache HTTP Server](https://httpd.apache.org/) als Reverse-Proxy, um Anfragen von Port 80 auf der Instance an Ihren Tomcat Web-Container weiterzuleiten, der auf Port 8080 lauscht. Elastic Beanstalk bietet eine Proxy-Standardkonfiguration, die Sie entweder erweitern oder gänzlich mit einer eigenen Konfiguration überschreiben können.

**Konfigurieren des Proxy-Servers auf Ihrer Plattformversion**  
Alle AL2023 AL2 /-Plattformen unterstützen eine einheitliche Proxykonfigurationsfunktion. Weitere Informationen zur Konfiguration des Proxyservers auf Ihren Plattformversionen, auf denen AL2023/ausgeführt wirdAL2, finden Sie unter[Reverse-Proxy-Konfiguration](platforms-linux-extend.proxy.md). 

## Proxy auf der Amazon Linux AMI (vor Amazon Linux 2) Tomcat-Plattform konfigurieren
<a name="java-tomcat-proxy.alami"></a>

Falls Ihre Elastic Beanstalk Tomcat-Umgebung eine Amazon Linux AMI-Plattformversion (vor Amazon Linux 2) verwendet, lesen Sie die zusätzlichen Informationen in diesem Abschnitt.

**Hinweise**  
Die Informationen in diesem Thema gelten nur für Plattformbranches, die auf Amazon Linux AMI (AL1) basieren. AL2023/AL2 platform Branches sind nicht mit früheren Amazon Linux AMI (AL1) -Plattformversionen kompatibel und *erfordern andere Konfigurationseinstellungen*.
 [Am 18. Juli 2022](https://docs.aws.amazon.com/elasticbeanstalk/latest/relnotes/release-2022-07-18-linux-al1-retire.html) **hat Elastic Beanstalk den Status aller Plattformbranches, die auf Amazon Linux AMI (AL1) basieren, auf eingestellt gesetzt.** Weitere Informationen zur Migration zu einem aktuellen und vollständig unterstützten Plattformzweig für Amazon Linux 2023 finden Sie unter [Migrieren der Elastic-Beanstalk-Linux-Anwendung zu Amazon Linux 2023 oder Amazon Linux 2](using-features.migration-al.md).

### Auswahl eines Proxyservers für Ihre Tomcat-Umgebung — Amazon Linux AMI () AL1
<a name="java-tomcat-proxy.alami"></a>

Tomcat-Plattformversionen, die auf Amazon Linux-AMIs (vor Amazon Linux 2) basieren, verwenden standardmäßig [Apache 2.4](https://httpd.apache.org/docs/2.4/) für den Proxy. Sie können [Apache 2.2](https://httpd.apache.org/docs/2.2/) oder [nginx](https://www.nginx.com/) verwenden, indem Sie eine [Konfigurationsdatei](ebextensions.md) in Ihren Quellcode einbinden. Im folgenden Beispiel wird Elastic Beanstalk für die Verwendung von nginx konfiguriert.

**Example .ebextensions/nginx-proxy.config**  

```
option_settings:
  aws:elasticbeanstalk:environment:proxy:
    ProxyServer: nginx
```

### Migration von Apache 2.2 auf Apache 2.4 — Amazon Linux AMI () AL1
<a name="java-tomcat-proxy-apache-migrate"></a>

Wenn Ihre Anwendung für [Apache 2.2 entwickelt wurde](https://httpd.apache.org/docs/2.2/), lesen Sie diesen Abschnitt, um mehr über die Migration zu [Apache 2.4](https://httpd.apache.org/docs/2.4/) zu erfahren.

Beginnend mit Tomcat-Plattform Version 3.0.0- Konfigurationen, die mit der [Java mit Tomcat-Plattformaktualisierung am 24. Mai 2018 veröffentlicht wurden](https://aws.amazon.com/releasenotes/release-aws-elastic-beanstalk-platform-update-for-the-java-with-tomcat-platform-on-may-24-2018/), ist Apache 2.4 ist der standardmäßige Proxy der Tomcat-Plattform. Die Apache 2.4 `.conf`-Dateien sind häufig, aber nicht vollständig abwärtskompatibel zu denjenigen von Apache 2.2. Elastic Beanstalk enthält standardmäßige `.conf`-Dateien, die einwandfrei mit jeder Apache-Version funktionieren. Wenn Ihre Anwendung die Apache-Konfiguration nicht anpasst, wie unter [Erweiterung und Außerkraftsetzung der Apache-Standardkonfiguration — Amazon Linux AMI () AL1](#java-tomcat-proxy-apache) beschrieben , sollte es bei der Migration zu Apache 2.4 keine Probleme geben.

Wenn Ihre Anwendung die Konfiguration von Apache erweitert oder überschreibt, müssen Sie möglicherweise einige Änderungen vornehmen, um zu Apache 2.4 zu migrieren. Weitere Informationen finden Sie unter [Upgrading to 2.4 from 2.2 (Upgrade von 2.2 auf 2.4)](https://httpd.apache.org/docs/current/upgrading.html) auf der Website von *Apache Software Foundation*. Bis zur erfolgreichen Migration auf Apache 2.4 können Sie den Apache 2.2 mit Ihrer Anwendung verwenden, indem Sie die folgende [Konfigurationsdatei](ebextensions.md) in Ihren Quellcode aufnehmen.

**Example .ebeextensions/ .config apache-legacy-proxy**  

```
option_settings:
  aws:elasticbeanstalk:environment:proxy:
    ProxyServer: apache/2.2
```

Für eine schnelle Lösung können Sie auch den Proxy-Server in der Elastic Beanstalk-Konsole auswählen.

**So wählen Sie den Proxy-Server in Ihrer Tomcat-Umgebung in der Elastic Beanstalk-Konsole aus:**

1. Öffnen Sie die [Elastic Beanstalk Beanstalk-Konsole](https://console.aws.amazon.com/elasticbeanstalk) und wählen Sie in der Liste **Regionen** Ihre aus. AWS-Region

1. Wählen Sie im Navigationsbereich **Environments (Umgebungen)** aus und wählen Sie dann in der Liste den Namen Ihrer Umgebung aus.

1. Wählen Sie im Navigationsbereich **Configuration (Konfiguration)** aus.

1. Wählen Sie in der Konfigurationskategorie **Updates, monitoring and logging ** (Updates, Überwachung und Protokolle) die Option **Edit** (Bearbeiten) aus.

1. Für **Proxy-Server** wählen Sie `Apache 2.2 (deprecated)`.

1. Wählen Sie unten auf der Seite die Option **Apply** (Anwenden) aus, um die Änderungen zu speichern.

![\[Auswahl eines Proxys für eine Tomcat-Umgebung in der Kategorie für Software-Konfiguration in der Elastic Beanstalk-Konsole\]](http://docs.aws.amazon.com/de_de/elasticbeanstalk/latest/dg/images/java-tomcat-proxy-selection.png)


### Erweiterung und Außerkraftsetzung der Apache-Standardkonfiguration — Amazon Linux AMI () AL1
<a name="java-tomcat-proxy-apache"></a>

Sie können die Elastic Beanstalk-Apache-Standardkonfiguration mit Ihren zusätzlichen Konfigurationsdateien erweitern. Alternativ können Sie die Apache-Standardkonfiguration von Elastic Beanstalk vollständig überschreiben.

**Anmerkung**  
Alle Amazon Linux 2-Plattformen unterstützen eine einheitliche Proxykonfigurations-Features. Einzelheiten zur Konfiguration des Proxyservers auf Tomcat-Plattformversionen, auf denen Amazon Linux 2 ausgeführt wird, finden Sie unter[Reverse-Proxy-Konfiguration](platforms-linux-extend.proxy.md).
Wenn Sie Ihre Elastic Beanstalk-Anwendung auf eine Amazon Linux 2-Plattform migrieren, lesen Sie auch die Informationen unter [Migrieren der Elastic-Beanstalk-Linux-Anwendung zu Amazon Linux 2023 oder Amazon Linux 2](using-features.migration-al.md).

Um die Apache-Standardkonfiguration von Elastic Beanstalk zu erweitern, fügen Sie `.conf`-Konfigurationsdateien zum Ordner `.ebextensions/httpd/conf.d` im Quell-Bundle der Anwendung hinzu. Die Apache-Konfiguration von Elastic Beanstalk fügt `.conf`-Dateien automatisch zu diesem Ordner hinzu.

```
~/workspace/my-app/
|-- .ebextensions
|   -- httpd
|      -- conf.d
|         -- myconf.conf
|         -- ssl.conf
-- index.jsp
```

Beispielsweise wird mit der folgenden Apache 2.4-Konfiguration ein Listener auf Port 5000 hinzugefügt:

**Example . ebextensions/httpd/conf.d/port5000.conf**  

```
listen 5000
<VirtualHost *:5000>
  <Proxy *>
    Require all granted
  </Proxy>
  ProxyPass / http://localhost:8080/ retry=0
  ProxyPassReverse / http://localhost:8080/
  ProxyPreserveHost on

  ErrorLog /var/log/httpd/elasticbeanstalk-error_log
</VirtualHost>
```

Um die Apache-Standardkonfiguration von Elastic Beanstalk vollständig zu überschreiben, fügen Sie bei eine Konfiguration in das Quellpaket ei `.ebextensions/httpd/conf/httpd.conf`.

```
~/workspace/my-app/
|-- .ebextensions
|   `-- httpd
|       `-- conf
|           `-- httpd.conf
`-- index.jsp
```

Wenn Sie die Apache-Konfiguration von Elastic Beanstalk überschreiben, fügen Sie folgende Zeilen zu `httpd.conf` hinzu, damit die Konfigurationen von Elastic Beanstalk für [Verbesserte Gesundheitsberichterstattung und Überwachung in Elastic Beanstalk](health-enhanced.md), Antwortkomprimierungen und statische Dateien einbezogen werden.

```
IncludeOptional conf.d/*.conf
IncludeOptional conf.d/elasticbeanstalk/*.conf
```

Wenn Ihre Umgebung Apache 2.2 als Proxy verwendet, ersetzen Sie die `IncludeOptional`-Anweisungen durch `Include`. Einzelheiten zum Verhalten dieser beiden Direktiven in den beiden Apache-Versionen finden Sie unter [Include in Apache 2.4, IncludeOptional in Apache 2.4](https://httpd.apache.org/docs/2.4/mod/core.html#include) [und Include](https://httpd.apache.org/docs/2.4/mod/core.html#includeoptional) [in Apache](https://httpd.apache.org/docs/2.2/mod/core.html#include) 2.2.

**Anmerkung**  
Um den Standard-Listener auf Port 80 zu überschreiben, binden Sie eine Datei mit dem Namen `00_application.conf` bei `.ebextensions/httpd/conf.d/elasticbeanstalk/` ein, um die Konfiguration von Elastic Beanstalk zu überschreiben.

Ein funktionierendes Beispiel für die Elastic Beanstalk-Standardkonfigurationsdatei finden Sie unter `/etc/httpd/conf/httpd.conf` auf einer Umgebungs-Instance. Alle Dateien im Ordner `.ebextensions/httpd` des Quell-Bundles werden bei Bereitstellungen in `/etc/httpd` kopiert.

### Erweiterung der Standard-Nginx-Konfiguration — Amazon Linux AMI () AL1
<a name="java-tomcat-proxy-nginx"></a>

Um die nginx-Standardkonfiguration von Elastic Beanstalk zu überschreiben, fügen Sie `.conf`-Konfigurationsdateien zum Ordner `.ebextensions/nginx/conf.d/` im Quell-Bundle der Anwendung hinzu. Die nginx-Konfiguration von Elastic Beanstalk fügt `.conf`-Dateien automatisch zu diesem Ordner hinzu.

```
~/workspace/my-app/
|-- .ebextensions
|   `-- nginx
|       `-- conf.d
|           |-- elasticbeanstalk
|           |   `-- my-server-conf.conf
|           `-- my-http-conf.conf
`-- index.jsp
```

Dateien mit der Erweiterung ".conf" im Ordner `conf.d` sind im `http`-Block der Standardkonfiguration enthalten. Dateien im Ordner `conf.d/elasticbeanstalk` befinden sich im `server`-Block innerhalb des `http`-Blocks.

Um die nginx-Standardkonfiguration von Elastic Beanstalk vollständig zu überschreiben, fügen Sie bei eine Konfiguration in das Quellpaket ei `.ebextensions/nginx/nginx.conf`.

```
~/workspace/my-app/
|-- .ebextensions
|   `-- nginx
|       `-- nginx.conf
`-- index.jsp
```

**Hinweise**  
Wenn Sie die nginx-Konfiguration von Elastic Beanstalk überschreiben, fügen Sie folgende Zeile zum `server`-Block der Konfiguration hinzu, damit die Konfigurationen von Elastic Beanstalk für den Listener auf Port 80, Antwortkomprimierungen und statische Dateien einbezogen werden.  

  ```
   include conf.d/elasticbeanstalk/*.conf;
  ```
Um den Standard-Listener auf Port 80 zu überschreiben, binden Sie eine Datei mit dem Namen `00_application.conf` bei `.ebextensions/nginx/conf.d/elasticbeanstalk/` ein, um die Konfiguration von Elastic Beanstalk zu überschreiben.
Fügen Sie zudem die folgende Zeile in den `http`Block der Konfiguration ein, damit die Konfigurationen von Elastic Beanstalk für [Verbesserte Gesundheitsberichterstattung und Überwachung in Elastic Beanstalk](health-enhanced.md) und Protokollierung einbezogen werden.  

  ```
      include       conf.d/*.conf;
  ```

Ein funktionierendes Beispiel für die Elastic Beanstalk-Standardkonfigurationsdatei finden Sie unter `/etc/nginx/nginx.conf` auf einer Umgebungs-Instance. Alle Dateien im Ordner `.ebextensions/nginx` des Quell-Bundles werden bei Bereitstellungen in `/etc/nginx` kopiert.

# Elastic Beanstalk Java SE-Plattform verwenden
<a name="java-se-platform"></a>

In diesem Thema wird beschrieben, wie Sie Ihre Java-Anwendungen, die auf der AWS Elastic Beanstalk Java SE-Plattform ausgeführt werden, konfigurieren, erstellen und ausführen.

Die Elastic Beanstalk Java SE-Plattform besteht aus einer Reihe von [Plattformversionen](https://docs.aws.amazon.com/elasticbeanstalk/latest/platforms/platforms-supported.html#platforms-supported.javase) für Java-Webanwendungen, die aus einer kompilierten JAR-Datei eigenständig ausgeführt werden können. Sie können Ihre Anwendung lokale kompilieren oder den Quellcode mit einem Build-Skript hochladen, um die Anwendung auf der Instance zu kompilieren. Die Versionen der Java SE-Plattform sind in Plattformzweige gruppiert, von denen jede einer Hauptversion von Java entspricht.

**Anmerkung**  
Elastic Beanstalk analysiert die JAR-Datei Ihrer Anwendung nicht. Speichern Sie Dateien, die Elastic Beanstalk benötigt, außerhalb der JAR-Datei auf. Beziehen Sie beispielsweise die `cron.yaml`-Datei einer [Worker-Umgebung](using-features-managing-env-tiers.md) im Stammverzeichnis des Quell-Bundles Ihrer Anwendung neben der JAR-Datei ein.

In der Elastic Beanstalk-Konsole sind Konfigurationsoptionen für das [Ändern der Konfiguration einer ausgeführten Umgebung](environment-configuration-methods-after.md) verfügbar. Um zu verhindern, dass die Umgebungskonfiguration beim Beenden verloren geht, können Sie [gespeicherte Konfigurationen](environment-configuration-savedconfig.md) verwenden, um Ihre Einstellungen zu speichern und sie später für eine andere Umgebung zu übernehmen.

Zum Speichern der Einstellungen im Quellcode können Sie [Konfigurationsdateien](ebextensions.md) einschließen. Die Einstellungen in Konfigurationsdateien werden jedes Mal verwendet, wenn Sie eine Umgebung erstellen oder Ihre Anwendung bereitstellen. Mit Konfigurationsdateien können Sie auch Pakete installieren, Skripts ausführen und andere Instance-Anpassungen bei Bereitstellungen vornehmen.

Die Java SE-Plattform in Elastic Beanstalk umfasst einen [nginx](https://www.nginx.com/)-Server, der als Reverse-Proxy-Server fungiert und zwischengespeicherte statische Inhalte liefert sowie Anforderungen an die Anwendung weiterleitet. Die Plattform stellt auch Konfigurationsoptionen bereit, um den Proxy-Server zur Verarbeitung statischer Komponenten aus einem Ordner im Quellcode zu konfigurieren und so die Auslastung für die Anwendung zu reduzieren. In erweiterten Szenarien können Sie [eigene CONF-Dateien in das Quell-Bundle einbinden](java-se-nginx.md), um die Proxy-Konfiguration von Elastic Beanstalk zu erweitern oder zu überschreiben. 

Wenn Sie nur eine einzelne JAR-Datei für Ihre Anwendungsquelle bereitstellen (allein, nicht innerhalb eines Quellpakets), benennt Elastic Beanstalk die JAR-Datei in `application.jar` um und führt sie dann mit `java -jar application.jar` aus. Schließen Sie eine optionale [Procfile-Datei](java-se-procfile.md) in Ihr Quell-Bundle ein, um die Prozesse zu konfigurieren, die auf den Server-Instances in Ihrer Umgebung ausgeführt werden. Wenn Ihr Quell-Bundle mehrere JAR-Dateien enthält oder wenn Sie den Java-Befehl zum Festlegen von JVM-Optionen anpassen möchten, benötigen Sie eine `Procfile`-Datei.

Wir empfehlen, immer eine `Procfile` im Quellpaket mit Ihrer Anwendung bereitzustellen. Auf diese Weise können Sie genau steuern, welche Prozesse Elastic Beanstalk für Ihre Anwendung ausführt und welche Argumente diese Prozesse erhalten.

Um Java-Klassen zu kompilieren und andere Build-Befehle für die EC2 Instanzen in Ihrer Umgebung während der Bereitstellung auszuführen, fügen Sie Ihrem Anwendungsquellpaket eine [Buildfile hinzu](java-se-buildfile.md). A `Buildfile` ermöglicht es Ihnen, Ihren Quellcode unverändert bereitzustellen und auf dem Server zu bauen, anstatt ihn lokal zu kompilieren. JARs Die Java SE-Plattform bietet gängige Build-Tools für Server-Builds.

Details zu den verschiedenen Möglichkeiten für das Erweitern einer Linux-basierten Elastic Beanstalk-Plattform finden Sie unter [Erweitern von Elastic Beanstalk-Linux-Plattformen](platforms-linux-extend.md).

## Konfigurieren der Java SE-Umgebung
<a name="java-se-options"></a>

Mit den Java SE-Plattformeinstellungen können Sie das Verhalten Ihrer EC2 Amazon-Instances optimieren. Sie können die EC2 Amazon-Instance-Konfiguration der Elastic Beanstalk Beanstalk-Umgebung mithilfe der Elastic Beanstalk Beanstalk-Konsole bearbeiten.

Mithilfe der Elastic Beanstalk-Konsole aktivieren Sie die Protokollrotation an Amazon S3 und konfigurieren Variablen, die die Anwendung aus der Umgebung auslesen kann.

**So konfigurieren Sie Ihre Java SE-Umgebung in der Elastic Beanstalk-Konsole:**

1. Öffnen Sie die [Elastic Beanstalk Beanstalk-Konsole](https://console.aws.amazon.com/elasticbeanstalk) und wählen Sie in der Liste **Regionen** Ihre aus. AWS-Region

1. Wählen Sie im Navigationsbereich **Environments (Umgebungen)** aus und wählen Sie dann in der Liste den Namen Ihrer Umgebung aus.

1. Wählen Sie im Navigationsbereich **Configuration (Konfiguration)** aus.

1. Wählen Sie in der Konfigurationskategorie **Updates, monitoring and logging ** (Updates, Überwachung und Protokolle) die Option **Edit** (Bearbeiten) aus.

### Protokolloptionen
<a name="java-se-options-logs"></a>

Im Abschnitt mit den Protokolloptionen sind zwei Einstellungen vorhanden:
+ **Instance profile (Instance-Profil)** – Gibt das Instance-Profil an, das zum Zugriff auf den entsprechenden Amazon S3-Bucket der Anwendung berechtigt ist.
+ **Rotation der Protokolldateien nach Amazon S3 aktivieren** — Gibt an, ob Protokolldateien für die EC2 Amazon-Instances Ihrer Anwendung in den Amazon S3-Bucket kopiert werden, der Ihrer Anwendung zugeordnet ist.

### Statische Dateien
<a name="java-se-options-staticfiles"></a>

Um die Leistung zu verbessern, können Sie den Abschnitt **Static files** (Statische Dateien) benutzen, um den Proxy-Server so zu konfigurieren, dass er statische Dateien (z. B. HTML oder Bilder) aus Verzeichnissen innerhalb Ihrer Webanwendung bereitstellt. Legen Sie für jedes Verzeichnis den virtuellen Pfad zum Verzeichnis-Mapping fest. Wenn der Proxy-Server eine Anfrage nach einer Datei unter dem angegebenen Pfad erhält, stellt er die Datei direkt bereit, anstatt die Anfrage an Ihre Anwendung weiterzuleiten.

Weitere Informationen zum Konfigurieren statischer Dateien mit der Elastic Beanstalk-Konsole finden Sie unter [Bereitstellen von statischen Dateien](environment-cfg-staticfiles.md).

### Umgebungseigenschaften
<a name="java-se-options-properties"></a>

Im Abschnitt **Umgebungseigenschaften** können Sie die Umgebungskonfigurationseinstellungen für die EC2 Amazon-Instances angeben, auf denen Ihre Anwendung ausgeführt wird. Umgebungseigenschaften werden als Schlüssel-Wert-Paare an die Anwendung weitergeleitet.

In der Java SE-Umgebung mit Elastic Beanstalk-Ausführung kann über auf die Umgebungsvariablen zugegriffen werde `System.getenv()`. Beispielsweise können Sie mit folgendem Code eine Eigenschaft mit dem Namen `API_ENDPOINT` als Variable lesen:

```
String endpoint = System.getenv("API_ENDPOINT");
```

Weitere Informationen finden Sie unter [Umgebungsvariablen und andere Softwareeinstellungen](environments-cfg-softwaresettings.md).

## Java SE-Konfigurations-Namespace
<a name="java-se-namespaces"></a>

Mithilfe einer [Konfigurationsdatei](ebextensions.md) können Sie im Rahmen der Bereitstellung Konfigurationsoptionen festlegen und andere Instance-Konfigurationsaufgaben ausführen. Die Konfigurationsoptionen können [plattformspezifisch](command-options-specific.md) sein oder für [alle Plattformen](command-options-general.md) im Elastic Beanstalk-Service als Ganzes gelten. *Die Konfigurationsoptionen sind in Namespaces organisiert.*

Die Java SE-Plattform definiert keine plattformspezifischen Namespaces. Sie können den Proxy so konfigurieren, dass statische Dateien mittels des Namespace `aws:elasticbeanstalk:environment:proxy:staticfiles` bereitgestellt werden. Einzelheiten und ein Beispiel finden Sie unter [Bereitstellen von statischen Dateien](environment-cfg-staticfiles.md).

Elastic Beanstalk bietet zahlreiche Konfigurationsoptionen für die Anpassung Ihrer Umgebung. Neben den Konfigurationsdateien können Sie die Konfigurationsoptionen auch unter Verwendung der Konsole, gespeicherter Konfigurationen, der EB CLI oder der AWS CLI einrichten. Weitere Informationen finden Sie unter [Konfigurationsoptionen](command-options.md).

## Die Java SE-Plattform im Amazon Linux-AMI (vor Amazon Linux 2)
<a name="java-se.alami"></a>

Falls Ihre Elastic Beanstalk Java SE-Umgebung eine Amazon Linux AMI-Plattformversion (vor Amazon Linux 2) verwendet, lesen Sie die zusätzlichen Informationen in diesem Abschnitt.

**Hinweise**  
Die Informationen in diesem Thema gelten nur für Plattformbranches, die auf Amazon Linux AMI (AL1) basieren. AL2023/ AL2 Plattformbranches sind nicht mit früheren Amazon Linux AMI (AL1) -Plattformversionen kompatibel und *erfordern andere Konfigurationseinstellungen*.
 [Am 18. Juli 2022](https://docs.aws.amazon.com/elasticbeanstalk/latest/relnotes/release-2022-07-18-linux-al1-retire.html) **hat Elastic Beanstalk den Status aller Plattformbranches, die auf Amazon Linux AMI (AL1) basieren, auf eingestellt gesetzt.** Weitere Informationen zur Migration zu einem aktuellen und vollständig unterstützten Plattformzweig für Amazon Linux 2023 finden Sie unter [Migrieren der Elastic-Beanstalk-Linux-Anwendung zu Amazon Linux 2023 oder Amazon Linux 2](using-features.migration-al.md).

### Namespaces für die Java SE-Konfiguration — Amazon Linux AMI () AL1
<a name="java-se.alami.namespaces"></a>

Mithilfe einer [Konfigurationsdatei](ebextensions.md) können Sie im Rahmen der Bereitstellung Konfigurationsoptionen festlegen und andere Instance-Konfigurationsaufgaben durchführen. Die Konfigurationsoptionen können [plattformspezifisch](command-options-specific.md) sein oder für [alle Plattformen](command-options-general.md) im Elastic Beanstalk-Service als Ganzes gelten. *Die Konfigurationsoptionen sind in Namespaces organisiert.*

Die Java SE-Plattform unterstützt zusätzlich zu den [von allen Plattformen unterstützten Namespaces](command-options-general.md) eine weitere Konfigurationsoption für einen plattformspezifischen Namespace. Mit dem Namespace `aws:elasticbeanstalk:container:java:staticfiles` können Sie Optionen definieren, um für die Webanwendung Pfade zu Ordnern im Quell-Bundle der Anwendung zuzuweisen, die statische Inhalte enthalten.

Zum Beispiel werden mit diesem [option\$1settings](ebextensions-optionsettings.md)-Snippet zwei Optionen im Namespace der statischen Dateien definiert. Die erste ordnet den Pfad `/public` dem Ordner `public` zu, die zweite ordnet den Pfad `/images` dem Ordner `img` zu:

```
option_settings:
  aws:elasticbeanstalk:container:java:staticfiles:
    /html: statichtml
    /images: staticimages
```

Die über diesen Namespace zugewiesenen Ordner müssen sich tatsächlich im Stamm des Quell-Bundles befinden. Sie können keinen Pfad zu einem Ordner in einer JAR-Datei zuweisen.

Elastic Beanstalk bietet zahlreiche Konfigurationsoptionen für die Anpassung Ihrer Umgebung. Neben den Konfigurationsdateien können Sie die Konfigurationsoptionen auch unter Verwendung der Konsole, gespeicherter Konfigurationen, der EB CLI oder der AWS CLI einrichten. Weitere Informationen finden Sie unter [Konfigurationsoptionen](command-options.md).

# Auf dem JARs Server mit einer Builddatei bauen
<a name="java-se-buildfile"></a>

Sie können die Klassendateien und JAR-Dateien Ihrer Anwendung auf den EC2 Instanzen in Ihrer Umgebung erstellen, indem Sie einen Build-Befehl aus einer `Buildfile` Datei in Ihrem Quellpaket aufrufen.

Befehle in einer `Buildfile`-Datei werden nur einmal ausgeführt und müssen anschließend beendet werden, wohingegen die Befehle in einer [Procfile](java-se-procfile.md) normalerweise für die Lebensdauer der Anwendung ausgeführt und im Falle einer Beendigung neu gestartet werden. Um den JARs in Ihrer Anwendung auszuführen, verwenden Sie a. `Procfile`

Einzelheiten zur Platzierung und Syntax von a `Buildfile` finden Sie unter[Buildfile und Procfile](platforms-linux-extend.build-proc.md).

In obigem `Buildfile`-Beispiel wird Apache Maven ausgeführt, um eine Webanwendung aus Quellcode zu erstellen. Eine Beispielanwendung mit dieser Funktion mit dieser Funktion finden Sie unter [Java-Webanwendungsbeispiele](java-getstarted.md#java-getstarted-samples).

**Example Buildfile**  

```
build: mvn assembly:assembly -DdescriptorId=jar-with-dependencies
```

Die Java SE-Plattform enthält die folgenden Build-Tools, die Sie über das Build-Skript aufrufen können:
+ `javac` – Java-Compiler
+ `ant` – Apache Ant
+ `mvn` – Apache Maven
+ `gradle` – Gradle

# Konfigurieren der Anwendung mit einer Procfile-Datei
<a name="java-se-procfile"></a>

Sofern im Stamm des Quell-Bundles der Anwendung mehr als eine JAR-Datei vorhanden ist, müssen Sie eine `Procfile`-Datei einbinden, anhand derer Elastic Beanstalk erkennt, welche JAR-Dateien(en) ausgeführt werden sollen. Bei einer einzelnen JAR-Anwendung können Sie auch eine `Procfile`-Datei einbinden. Damit wird die JVM (Java Virtual Machine) konfiguriert, auf der die Anwendung ausgeführt wird.

Wir empfehlen, immer eine `Procfile` im Quellpaket mit Ihrer Anwendung bereitzustellen. Auf diese Weise können Sie genau steuern, welche Prozesse Elastic Beanstalk für Ihre Anwendung ausführt und welche Argumente diese Prozesse erhalten.

Einzelheiten zum Schreiben und Verwenden eines `Procfile` finden Sie unter[Buildfile und Procfile](platforms-linux-extend.build-proc.md).

**Example Procfile**  

```
web: java -Xms256m -jar server.jar 
cache: java -jar mycache.jar
web_foo: java -jar other.jar
```

Der Befehl für die Ausführung der wichtigsten JAR-Datei in der Anwendung muss den Namen `web` tragen und der erste Befehl in der `Procfile`-Datei sein. Der nginx-Server leitet alle HTTP-Anforderungen, die er vom Load Balancer der Umgebung erhält, an diese Anwendung weiter.

Elastic Beanstalk geht davon aus, dass alle Einträge in der Procfile-Datei stets ausgeführt werden sollen. Daher wird automatisch jede Anwendung, die in der Procfile-Datei definiert ist und beendet wird, neu gestartet. Wenn die Anwendung mit einem Befehl beendet, aber nicht wieder neu gestartet werden soll, verwenden Sie eine -Datei [`Buildfile`](java-se-buildfile.md).

## Procfile auf Amazon Linux-AMI (vor Amazon Linux 2) verwenden
<a name="java-se-procfile.alami"></a>

Falls Ihre Elastic Beanstalk Java SE-Umgebung eine Amazon Linux AMI-Plattformversion (vor Amazon Linux 2) verwendet, lesen Sie die zusätzlichen Informationen in diesem Abschnitt.

**Hinweise**  
Die Informationen in diesem Thema gelten nur für Plattformbranches, die auf Amazon Linux AMI (AL1) basieren. AL2023/ AL2 Plattformbranches sind nicht mit früheren Amazon Linux AMI (AL1) -Plattformversionen kompatibel und *erfordern andere Konfigurationseinstellungen*.
 [Am 18. Juli 2022](https://docs.aws.amazon.com/elasticbeanstalk/latest/relnotes/release-2022-07-18-linux-al1-retire.html) **hat Elastic Beanstalk den Status aller Plattformbranches, die auf Amazon Linux AMI (AL1) basieren, auf eingestellt gesetzt.** Weitere Informationen zur Migration zu einem aktuellen und vollständig unterstützten Plattformzweig für Amazon Linux 2023 finden Sie unter [Migrieren der Elastic-Beanstalk-Linux-Anwendung zu Amazon Linux 2023 oder Amazon Linux 2](using-features.migration-al.md).

### Port-Weitergabe — Amazon Linux AMI (AL1)
<a name="java-se-procfile.alami.ports"></a>

Standardmäßig wird der nginx-Proxy von Elastic Beanstalk so konfiguriert, dass alle Anforderungen an die Anwendung über Port 5000 weitergeleitet werden. Diese Port-Standardeinstellung können Sie überschreiben. Legen Sie dazu die `PORT`-[Umgebungseigenschaft](java-se-platform.md#java-se-options) auf den Überwachungsport der Hauptanwendung fest.

Wenn Sie einen `Procfile` verwenden, um mehrere Anwendungen auszuführen, erwartet Elastic Beanstalk auf den AMI-Plattformversionen von Amazon Linux, dass jede zusätzliche Anwendung auf einem Port lauscht, der 100 höher ist als der vorherige. Elastic Beanstalk legt die PORT-Variable, auf die von jeder Anwendung zugegriffen werden kann, auf den Port fest, auf den die Anwendung erwartungsgemäß zugreift. Sie können auf diese Variable im Anwendungscode zugreifen, indem Sie aufrufe `System.getenv("PORT")`.

Im vorherigen Beispiel für `Procfile` wurden für die `web`-Anwendung der Überwachungsport 5000, für `cache` der Überwachungsport 5100 und für `web_foo` der Überwachungsport 5200 konfiguriert. Für `web` wird der Überwachungsport durch Auslesen der `PORT`-Variable und Addieren der Zahl 100 konfiguriert. Damit wird der Überwachungsport von `cache` für die Anforderungsübermittlung bestimmt.

# Konfigurieren des Proxy-Server
<a name="java-se-nginx"></a>

Elastic Beanstalk verwendet [nginx](https://www.nginx.com/) als Reverse-Proxy, um Ihre Anwendung Ihrem Elastic-Load-Balancing-Load-Balancer auf Port 80 zuzuordnen. Elastic Beanstalk bietet eine nginx-Standardkonfiguration, die Sie entweder erweitern oder gänzlich mit einer eigenen Konfiguration überschreiben können.

Standardmäßig wird der nginx-Proxy von Elastic Beanstalk so konfiguriert, dass alle Anforderungen an die Anwendung über Port 5000 weitergeleitet werden. Diese Port-Standardeinstellung können Sie überschreiben. Legen Sie dazu die `PORT`-[Umgebungseigenschaft](java-se-platform.md#java-se-options) auf den Überwachungsport der Hauptanwendung fest.

**Anmerkung**  
Der Überwachungsport der Anwendung kollidiert nicht mit dem Überwachungsport des nginx-Servers, von dem dieser die Anforderungen des Load Balancers empfängt.

**Konfigurieren des Proxy-Servers auf Ihrer Plattformversion**  
Alle AL2 023/ AL2 -Plattformen unterstützen eine einheitliche Proxykonfigurationsfunktion. Weitere Informationen zur Konfiguration des Proxyservers auf Ihren Plattformversionen, auf denen AL2 AL2 023/ ausgeführt wird, finden Sie unter. [Reverse-Proxy-Konfiguration](platforms-linux-extend.proxy.md) 

## Konfigurieren des Proxys auf Amazon Linux AMI (Vorgängerversion von Amazon Linux 2)
<a name="java-se-nginx.alami"></a>

Falls Ihre Elastic Beanstalk Java SE-Umgebung eine Amazon Linux AMI-Plattformversion (vor Amazon Linux 2) verwendet, lesen Sie die zusätzlichen Informationen in diesem Abschnitt.

**Hinweise**  
Die Informationen in diesem Thema gelten nur für Plattformbranches, die auf Amazon Linux AMI (AL1) basieren. AL2023/ AL2 Plattformbranches sind nicht mit früheren Amazon Linux AMI (AL1) -Plattformversionen kompatibel und *erfordern andere Konfigurationseinstellungen*.
 [Am 18. Juli 2022](https://docs.aws.amazon.com/elasticbeanstalk/latest/relnotes/release-2022-07-18-linux-al1-retire.html) **hat Elastic Beanstalk den Status aller Plattformbranches, die auf Amazon Linux AMI (AL1) basieren, auf eingestellt gesetzt.** Weitere Informationen zur Migration zu einem aktuellen und vollständig unterstützten Plattformzweig für Amazon Linux 2023 finden Sie unter [Migrieren der Elastic-Beanstalk-Linux-Anwendung zu Amazon Linux 2023 oder Amazon Linux 2](using-features.migration-al.md).

### Erweiterung und Außerkraftsetzung der Standard-Proxykonfiguration — Amazon Linux AMI () AL1
<a name="java-se-nginx.alami.extending"></a>

Um die nginx-Standardkonfiguration von Elastic Beanstalk zu überschreiben, fügen Sie `.conf`-Konfigurationsdateien zum Ordner `.ebextensions/nginx/conf.d/` im Quell-Bundle der Anwendung hinzu. Die nginx-Konfiguration von Elastic Beanstalk enthält standardmäßig `.conf`-Dateien in diesem Ordner.

```
~/workspace/my-app/
|-- .ebextensions
|   `-- nginx
|       `-- conf.d
|           `-- myconf.conf
`-- web.jar
```

Um die nginx-Standardkonfiguration von Elastic Beanstalk vollständig zu überschreiben, binden Sie bei eine Konfiguration in Ihr Quell-Bundle ei `.ebextensions/nginx/nginx.conf`:

```
~/workspace/my-app/
|-- .ebextensions
|   `-- nginx
|       `-- nginx.conf
`-- web.jar
```

Wenn Sie die nginx-Konfiguration von Elastic Beanstalk überschreiben, fügen Sie folgende Zeile zu `nginx.conf` hinzu, damit die Konfigurationen von Elastic Beanstalk für [Verbesserte Gesundheitsberichterstattung und Überwachung in Elastic Beanstalk](health-enhanced.md), automatische Anwendungszuordnungen und statische Dateien einbezogen werden.

```
 include conf.d/elasticbeanstalk/*.conf;
```

Die folgende Beispielkonfiguration aus der [Beispielanwendung Scorekeep](https://github.com/aws-samples/eb-java-scorekeep/) überschreibt die Standardkonfiguration von Elastic Beanstalk, um eine statische Webanwendung aus dem `public`-Unterverzeichnis von `/var/app/current` zu bedienen, wohin die Java SE-Plattform den Anwendungsquellcode kopiert. Der `/api`-Standort leitet den Datenverkehr zu Routen unter `/api/` an die Spring-Anwendung weiter, die den Port 5000 liest. Jeder andere Datenverkehr wird von der Web-Anwendung auf dem Root-Pfad bedient.

**Example**  

```
user                    nginx;
error_log               /var/log/nginx/error.log warn;
pid                     /var/run/nginx.pid;
worker_processes        auto;
worker_rlimit_nofile    33282;

events {
    worker_connections  1024;
}

http {
  include       /etc/nginx/mime.types;
  default_type  application/octet-stream;

  log_format  main  '$remote_addr - $remote_user [$time_local] "$request" '
                    '$status $body_bytes_sent "$http_referer" '
                    '"$http_user_agent" "$http_x_forwarded_for"';

  include       conf.d/*.conf;

  map $http_upgrade $connection_upgrade {
      default     "upgrade";
  }

  server {
      listen        80 default_server;
      root /var/app/current/public;

      location / {
      }git pull
      

      location /api {
          proxy_pass          http://127.0.0.1:5000;
          proxy_http_version  1.1;

          proxy_set_header    Connection          $connection_upgrade;
          proxy_set_header    Upgrade             $http_upgrade;
          proxy_set_header    Host                $host;
          proxy_set_header    X-Real-IP           $remote_addr;
          proxy_set_header    X-Forwarded-For     $proxy_add_x_forwarded_for;
      }

      access_log    /var/log/nginx/access.log main;

      client_header_timeout 60;
      client_body_timeout   60;
      keepalive_timeout     60;
      gzip                  off;
      gzip_comp_level       4;

      # Include the Elastic Beanstalk generated locations
      include conf.d/elasticbeanstalk/01_static.conf;
      include conf.d/elasticbeanstalk/healthd.conf;
  }
}
```

# Hinzufügen einer Amazon RDS-DB-Instance zu Ihrer Java Elastic Beanstalk Beanstalk-Umgebung
<a name="java-rds"></a>

Dieses Thema enthält Anweisungen zum Erstellen eines Amazon RDS mit der Elastic-Beanstalk-Konsole. Sie können eine Amazon Relational Database Service (Amazon RDS)-DB-Instance verwenden, um Daten zu speichern, die Ihre Anwendung sammelt und modifiziert. Die Datenbank kann Ihrer Umgebung angefügt und von Elastic Beanstalk verwaltet werden oder sie kann extern erstellt und verwaltet werden.

Bei der ersten Verwendung von Amazon RDS fügen Sie in der Testumgebung mithilfe der Elastic Beanstalk-Konsole eine DB-Instance hinzu und überprüfen, ob die Anwendung eine Verbindung zu dieser herstellen kann. 

**So fügen Sie eine DB-Instance zu Ihrer Umgebung hinzu**

1. Öffnen Sie die [Elastic Beanstalk Beanstalk-Konsole](https://console.aws.amazon.com/elasticbeanstalk) und wählen Sie in der Liste **Regionen** Ihre aus. AWS-Region

1. Wählen Sie im Navigationsbereich **Environments (Umgebungen)** aus und wählen Sie dann in der Liste den Namen Ihrer Umgebung aus.

1. Wählen Sie im Navigationsbereich **Configuration (Konfiguration)** aus.

1. Wählen Sie in der Konfigurationskategorie **Database (Datenbank)** die Option **Edit (Bearbeiten)**.

1. Wählen Sie eine DB-Engine aus und geben Sie Benutzernamen und Passwort ein.

1. Wählen Sie unten auf der Seite die Option **Apply** (Anwenden) aus, um die Änderungen zu speichern.

Das Hinzufügen einer DB-Instance dauert ca. 10 Minuten. Sobald die Umgebungsaktualisierung abgeschlossen ist, stehen der Hostname der DB-Instance und andere Verbindungsinformationen über die folgenden Umgebungseigenschaften zur Verfügung:


| Eigenschaftenname | Beschreibung | Eigenschaftenwert | 
| --- | --- | --- | 
|  `RDS_HOSTNAME`  |  Der Hostname der DB-Instance.  |  Auf der Registerkarte **Connectivity & security (Konnektivität und Sicherheit)** in der Amazon RDS-Konsole: **Endpoint (Endpunkt)**.  | 
|  `RDS_PORT`  |  Der Port, über den die DB-Instance Verbindungen annimmt. Die DB-Engines haben unterschiedliche Standardwerte.  |  Auf der Registerkarte **Connectivity & security (Konnektivität und Sicherheit)** auf der Amazon RDS-Konsole: **Port**.  | 
|  `RDS_DB_NAME`  |  Der Datenbanknam, **ebdb**.  |  Auf der Registerkarte **Configuration (Konfiguration)** der Amazon RDS-Konsole: **DB-Name**.  | 
|  `RDS_USERNAME`  |  Der Benutzername, der für die Datenbank konfiguriert wurde.  |  Auf der Registerkarte **Configuration (Konfiguration)** in der Amazon RDS-Konsole: **Master username (Master-Benutzername)**.  | 
|  `RDS_PASSWORD`  |  Das Passwort, das für die Datenbank konfiguriert wurde.  |  In der Amazon RDS-Konsole nicht als Referenz verfügbar.  | 

Weitere Informationen zum Konfigurieren einer internen DB-Instance finden Sie unter [Hinzufügen einer Datenbank zu Ihrer Elastic Beanstalk-Umgebung](using-features.managing.db.md). Anweisungen zum Konfigurieren einer externen Datenbank für die Verwendung mit Elastic Beanstalk finden Sie unter [Verwenden von Elastic Beanstalk mit Amazon RDS](AWSHowTo.RDS.md).

Für die Verbindungserstellung zu einer Datenbank fügen Sie die geeignete JAR-Treiberdatei zur Anwendung hinzu, laden die Klasse in den Code und erstellen ein Verbindungsobjekt mit den von Elastic Beanstalk bereitgestellten Umgebungseigenschaften.

**Topics**
+ [Herunterladen eines JDBC-Treibers](#java-rds-drivers)
+ [Verbinden mit einer Datenbank (Java SE-Plattformen)](#java-rds-javase)
+ [Verbinden mit einer Datenbank (Tomcat-Plattformen)](#java-rds-tomcat)
+ [Fehlerbehebung bei Datenbankverbindungen](#create_deploy_Java.rds.troubleshooting)

## Herunterladen eines JDBC-Treibers
<a name="java-rds-drivers"></a>

Sie benötigen die JAR-Datei des JDBC-Treibers für die DB-Engine, die Sie gewählt haben. Speichern Sie die JAR-Datei in Ihrem Quellcode und fügen Sie sie in Ihren Klassenpfad ein, wenn Sie die Klasse kompilieren, die Verbindungen mit der Datenbank herstellt.

Die neuesten Treiber für Ihre DB-Engine finden Sie an den folgenden Speicherorten:
+ **MySQL** – [MySQL Connector/J](https://dev.mysql.com/downloads/connector/j/)
+ **Oracle SE-1** – [Oracle JDBC Driver](http://www.oracle.com/technetwork/database/features/jdbc/index-091264.html)
+ **Postgres** – [PostgreSQL JDBC Driver](https://jdbc.postgresql.org/)
+ **SQL Server** – [Microsoft JDBC Driver](https://msdn.microsoft.com/en-us/sqlserver/aa937724.aspx)

Um den JDBC-Treiber zu verwenden, rufen Sie `Class.forName()` auf, um ihn zu laden, bevor Sie die Verbindung mit `DriverManager.getConnection()` in Ihrem Code herstellen.

JDBC verwendet eine Verbindungszeichenfolge mit folgendem Format:

```
jdbc:driver://hostname:port/dbName?user=userName&password=password
```

Sie können den Hostnamen, Port, Datenbanknamen, Benutzernamen und das Passwort von den Umgebungsvariablen abrufen, die Elastic Beanstalk für Ihre Anwendung bereitstellt. Der Treibername ist spezifisch für Ihren Datenbanktyp und Ihre Treiberversion. Es folgen Beispiele für Treibernamen:
+ `mysql` for MySQL
+ `postgresql` for PostgreSQL
+ `oracle:thin` for Oracle Thin
+ `oracle:oci` for Oracle OCI
+ `oracle:oci8` for Oracle OCI 8
+ `oracle:kprb` for Oracle KPRB
+ `sqlserver` for SQL Server

## Verbinden mit einer Datenbank (Java SE-Plattformen)
<a name="java-rds-javase"></a>

In einer Java SE-Umgebung verwenden Sie `System.getenv()`, um die Verbindungsvariablen aus der Umgebung zu lesen. Der folgende Beispielcode zeigt eine Klasse, die eine Verbindung zu einer PostgreSQL-Datenbank erstellt.

```
private static Connection getRemoteConnection() {
    if (System.getenv("RDS_HOSTNAME") != null) {
      try {
      Class.forName("org.postgresql.Driver");
      String dbName = System.getenv("RDS_DB_NAME");
      String userName = System.getenv("RDS_USERNAME");
      String password = System.getenv("RDS_PASSWORD");
      String hostname = System.getenv("RDS_HOSTNAME");
      String port = System.getenv("RDS_PORT");
      String jdbcUrl = "jdbc:postgresql://" + hostname + ":" + port + "/" + dbName + "?user=" + userName + "&password=" + password;
      logger.trace("Getting remote connection with connection string from environment variables.");
      Connection con = DriverManager.getConnection(jdbcUrl);
      logger.info("Remote connection successful.");
      return con;
    }
    catch (ClassNotFoundException e) { logger.warn(e.toString());}
    catch (SQLException e) { logger.warn(e.toString());}
    }
    return null;
  }
```

## Verbinden mit einer Datenbank (Tomcat-Plattformen)
<a name="java-rds-tomcat"></a>

In einer Tomcat-Umgebung werden Umgebungseigenschaften als Systemeigenschaften bereitgestellt, die mit zugreifbar sin `System.getProperty()`.

Der folgende Beispielcode zeigt eine Klasse, die eine Verbindung zu einer PostgreSQL-Datenbank erstellt.

```
private static Connection getRemoteConnection() {
    if (System.getProperty("RDS_HOSTNAME") != null) {
      try {
      Class.forName("org.postgresql.Driver");
      String dbName = System.getProperty("RDS_DB_NAME");
      String userName = System.getProperty("RDS_USERNAME");
      String password = System.getProperty("RDS_PASSWORD");
      String hostname = System.getProperty("RDS_HOSTNAME");
      String port = System.getProperty("RDS_PORT");
      String jdbcUrl = "jdbc:postgresql://" + hostname + ":" + port + "/" + dbName + "?user=" + userName + "&password=" + password;
      logger.trace("Getting remote connection with connection string from environment variables.");
      Connection con = DriverManager.getConnection(jdbcUrl);
      logger.info("Remote connection successful.");
      return con;
    }
    catch (ClassNotFoundException e) { logger.warn(e.toString());}
    catch (SQLException e) { logger.warn(e.toString());}
    }
    return null;
  }
```

Wenn Sie Probleme haben, eine Verbindung herzustellen oder SQL-Anweisungen auszuführen, versuchen Sie, den folgenden Code in einer JSP-Datei zu platzieren. Dieser Code stellt eine Verbindung zu einer DB-Instance her, erstellt eine Tabelle und schreibt in sie.

```
<%@ page import="java.sql.*" %>
<%
  // Read RDS connection information from the environment
  String dbName = System.getProperty("RDS_DB_NAME");
  String userName = System.getProperty("RDS_USERNAME");
  String password = System.getProperty("RDS_PASSWORD");
  String hostname = System.getProperty("RDS_HOSTNAME");
  String port = System.getProperty("RDS_PORT");
  String jdbcUrl = "jdbc:mysql://" + hostname + ":" +
    port + "/" + dbName + "?user=" + userName + "&password=" + password;
  
  // Load the JDBC driver
  try {
    System.out.println("Loading driver...");
    Class.forName("com.mysql.jdbc.Driver");
    System.out.println("Driver loaded!");
  } catch (ClassNotFoundException e) {
    throw new RuntimeException("Cannot find the driver in the classpath!", e);
  }

  Connection conn = null;
  Statement setupStatement = null;
  Statement readStatement = null;
  ResultSet resultSet = null;
  String results = "";
  int numresults = 0;
  String statement = null;

  try {
    // Create connection to RDS DB instance
    conn = DriverManager.getConnection(jdbcUrl);
    
    // Create a table and write two rows
    setupStatement = conn.createStatement();
    String createTable = "CREATE TABLE Beanstalk (Resource char(50));";
    String insertRow1 = "INSERT INTO Beanstalk (Resource) VALUES ('EC2 Instance');";
    String insertRow2 = "INSERT INTO Beanstalk (Resource) VALUES ('RDS Instance');";
    
    setupStatement.addBatch(createTable);
    setupStatement.addBatch(insertRow1);
    setupStatement.addBatch(insertRow2);
    setupStatement.executeBatch();
    setupStatement.close();
    
  } catch (SQLException ex) {
    // Handle any errors
    System.out.println("SQLException: " + ex.getMessage());
    System.out.println("SQLState: " + ex.getSQLState());
    System.out.println("VendorError: " + ex.getErrorCode());
  } finally {
    System.out.println("Closing the connection.");
    if (conn != null) try { conn.close(); } catch (SQLException ignore) {}
  }

  try {
    conn = DriverManager.getConnection(jdbcUrl);
    
    readStatement = conn.createStatement();
    resultSet = readStatement.executeQuery("SELECT Resource FROM Beanstalk;");

    resultSet.first();
    results = resultSet.getString("Resource");
    resultSet.next();
    results += ", " + resultSet.getString("Resource");
    
    resultSet.close();
    readStatement.close();
    conn.close();

  } catch (SQLException ex) {
    // Handle any errors
    System.out.println("SQLException: " + ex.getMessage());
    System.out.println("SQLState: " + ex.getSQLState());
    System.out.println("VendorError: " + ex.getErrorCode());
  } finally {
       System.out.println("Closing the connection.");
      if (conn != null) try { conn.close(); } catch (SQLException ignore) {}
  }
%>
```

Zum Anzeigen der Ergebnisse platzieren Sie den folgenden Code im Text des HTML-Teils der JSP-Datei.

```
<p>Established connection to RDS. Read first two rows: <%= results %></p>
```

## Fehlerbehebung bei Datenbankverbindungen
<a name="create_deploy_Java.rds.troubleshooting"></a>

**Testen Sie Amazon Q Developer CLI für KI-gestützte Problembehebung**  
 Amazon Q Developer CLI kann Ihnen helfen, Umgebungsprobleme schnell zu beheben. Die Q CLI bietet Lösungen, indem sie den Umgebungsstatus überprüft, Ereignisse überprüft, Protokolle analysiert und klärende Fragen stellt. Weitere Informationen und detaillierte Anleitungen finden Sie in den Blogs unter [Troubleshooting Elastic Beanstalk Environments with Amazon Q Developer CLI](https://aws.amazon.com/blogs/devops/troubleshooting-elastic-beanstalk-environments-with-amazon-q-developer-cli/). AWS 

Wenn Sie auf Probleme mit der Verbindung zu einer Datenbank über Ihre Anwendung stoßen, überprüfen Sie das Web-Container-Protokoll und die Datenbank.

### Überprüfen von Protokollen
<a name="create_deploy_Java.rds.troubleshooting.logs"></a>

Sie können alle Protokolle aus Ihrer Elastic Beanstalk-Umgebung in Eclipse anzeigen. **Wenn Sie die AWS Explorer-Ansicht nicht geöffnet haben, klicken Sie auf den Pfeil neben dem orangefarbenen AWS Symbol in der Werkzeugleiste und wählen Sie dann Explorer-Ansicht anzeigen. AWS ** Erweitern Sie **AWS Elastic Beanstalk** und Ihren Umgebungsnamen und öffnen Sie dann das Kontextmenü (rechte Maustaste) für den Server. Klicken Sie auf **Open in WTP Server Editor**. 

 Wählen Sie die Registerkarte **Log** der **Server**-Ansicht, um die aggregierten Protokolle aus Ihrer Umgebung zu sehen. Um die neuesten Protokolle zu öffnen, wählen Sie die Schaltfläche **Refresh** oben rechts auf der Seite. 

 Scrollen Sie nach unten, um die Tomcat-Protokolle in zu suche `/var/log/tomcat7/catalina.out`. Wenn Sie die Webseite aus unserem oben stehenden Beispiel mehrmals geladen haben, sehen Sie möglicherweise Folgendes: 

```
-------------------------------------
/var/log/tomcat7/catalina.out
-------------------------------------
INFO: Server startup in 9285 ms
Loading driver...
Driver loaded!
SQLException: Table 'Beanstalk' already exists
SQLState: 42S01
VendorError: 1050
Closing the connection.
Closing the connection.
```

Alle Informationen, die die Webanwendung an die Standardausgabe sendet, wird im Web-Container-Protokoll angezeigt. Im vorherigen Beispiel versucht die Anwendung, die Tabelle jedes Mal zu erstellen, wenn die Seite geladen wird. Dies führt zur Erfassung einer SQL-Ausnahme auf jeder Seite, die nach der ersten geladen wird. 

Beispielsweise ist die vorhergehende akzeptabel. Aber in tatsächlichen Anwendungen behalten Sie Ihre Datenbankdefinitionen in Schemaobjekten, führen Transaktionen in Modellklassen durch und koordinieren Anforderungen mit Controller-Servlets.

### Herstellen einer Verbindung mit einer RDS DB-Instance
<a name="create_deploy_Java.rds.troubleshooting.connecting"></a>

 Sie können eine direkte Verbindung zur RDS DB-Instance in Ihrer Elastic Beanstalk-Umgebung herstellen, indem Sie die MySQL-Client-Anwendung verwenden. 

 Öffnen Sie zunächst die Sicherheitsgruppe für Ihre RDS DB-Instance, um Datenverkehr von Ihrem Computer zuzulassen. 

1. Öffnen Sie die [Elastic Beanstalk Beanstalk-Konsole](https://console.aws.amazon.com/elasticbeanstalk) und wählen Sie in der Liste **Regionen** Ihre aus. AWS-Region

1. Wählen Sie im Navigationsbereich **Environments (Umgebungen)** aus und wählen Sie dann in der Liste den Namen Ihrer Umgebung aus.

1. Wählen Sie im Navigationsbereich **Configuration (Konfiguration)** aus.

1. Wählen Sie in der Konfigurationskategorie **Database (Datenbank)** die Option **Edit (Bearbeiten)**.

1. Wählen Sie neben **Endpoint (Endpunkt)** den Link zur Amazon RDS-Konsole aus.

1. Wählen Sie auf der Detailseite der **RDS Dashboard**-Instance unter **Security and Network** die Sicherheitsgruppe beginnend mit *rds-* neben **Security Groups**.
**Anmerkung**  
Die Datenbank kann über mehrere Einträge mit der Bezeichnung **Security Groups** verfügen. Wenn Sie ein älteres Konto haben, das nicht standardmäßig über [Amazon Virtual Private Cloud](https://docs.aws.amazon.com/vpc/latest/userguide/) (Amazon VPC) verfügt, verwenden Sie die erste, die mit *awseb* beginnt.

1. Rufen Sie in **Security group details** die Registerkarte **Inbound** auf und klicken Sie auf **Edit**.

1. Fügen Sie eine Regel für MySQL (Port 3306) hinzu, die Datenverkehr von Ihrer IP-Adresse erlaubt, angegeben im CIDR-Format.

1. Wählen Sie **Save** aus. Die Änderungen werden sofort wirksam.

 Kehren Sie zu den Elastic Beanstalk-Konfigurationsdetails für Ihre Umgebung zurück und beachten Sie den Endpunkt. Sie verwenden den Domänennamen für die Verbindung mit der RDS-DB-Instance. 

 Installieren Sie den MySQL-Client und initiieren Sie eine Verbindung mit der Datenbank auf Port 3306. Installieren Sie unter Windows MySQL Workbench von der MySQL-Startseite und befolgen Sie die Anweisungen. 

 Installieren Sie unter Linux den MySQL-Client mithilfe des Paket-Managers für Ihre Verteilung. Das folgende Beispiel funktioniert auf Ubuntu und anderen Debian-Derivaten. 

```
// Install MySQL client
$ sudo apt-get install mysql-client-5.5
...
// Connect to database
$ mysql -h aas839jo2vwhwb.cnubrrfwfka8.us-west-2.rds.amazonaws.com -u username -ppassword ebdb
Reading table information for completion of table and column names
You can turn off this feature to get a quicker startup with -A

Welcome to the MySQL monitor.  Commands end with ; or \g.
Your MySQL connection id is 117
Server version: 5.5.40-log Source distribution
...
```

Nachdem Sie eine Verbindung hergestellt haben, können Sie SQL-Befehle ausfehlen, um den Status der Datenbank, unabhängig davon, ob Ihre Tabellen und Zeilen erstellt wurden, und andere Informationen anzuzeigen. 

```
mysql> SELECT Resource from Beanstalk;
+--------------+
| Resource     |
+--------------+
| EC2 Instance |
| RDS Instance |
+--------------+
2 rows in set (0.01 sec)
```

# Java-Tools und -Ressourcen
<a name="create_deploy_Java.resources"></a>

Es gibt zahlreiche Möglichkeiten, um zusätzliche Unterstützung bei der Entwicklung von Java-Anwendungen zu erhalten.


****  

|  Ressource  |  Description  | 
| --- | --- | 
|  [Das AWS Java-Entwicklungsforum](https://forums.aws.amazon.com/forum.jspa?forumID=70)  | Hier können Sie Fragen stellen und Feedback erhalten.  | 
|  [Java Developer Center](https://aws.amazon.com/java/)  | Umfangreiches Kit mit Beispiel-Code, Dokumentation, Tools und zusätzlichen Ressourcen. |