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.
# Elastic Beanstalk Tomcat-Plattform verwenden
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
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
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
Ü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
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
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
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
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
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
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
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
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
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
`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`
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
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
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
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
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
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
Require all granted
ProxyPass / http://localhost:8080/ retry=0
ProxyPassReverse / http://localhost:8080/
ProxyPreserveHost on
ErrorLog /var/log/httpd/elasticbeanstalk-error_log
```
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
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.