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 Java SE-Plattform verwenden
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
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
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
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 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
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)
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
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
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
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
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)
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
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)
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
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;
}
}
```