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 Python-Anwendungen mit Elastic Beanstalk
<a name="create-deploy-python-apps"></a>

Dieses Kapitel enthält Anweisungen zur Konfiguration und Bereitstellung Ihrer Python-Webanwendung auf AWS Elastic Beanstalk. Elastic Beanstalk macht es einfach, Ihre Python-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 oder die verwenden. AWS CLI APIs

Folgen Sie den step-by-step Anweisungen unter, um eine Python *Hello World-Webanwendung* mit der EB CLI zu erstellen und bereitzustellen. [QuickStart für Python](python-quickstart.md)

**Topics**
+ [QuickStart: Stellen Sie eine Python-Anwendung auf Elastic Beanstalk bereit](python-quickstart.md)
+ [Einrichtung Ihrer Python-Entwicklungsumgebung für Elastic Beanstalk](python-development-environment.md)
+ [Verwenden der Elastic Beanstalk Python-Plattform](create-deploy-python-container.md)
+ [Bereitstellen einer Flask-Anwendung in Elastic Beanstalk](create-deploy-python-flask.md)
+ [Bereitstellen einer Django-Anwendung in Elastic Beanstalk](create-deploy-python-django.md)
+ [Hinzufügen einer Amazon RDS-DB-Instance zu Ihrer Python Elastic Beanstalk Beanstalk-Umgebung](create-deploy-python-rds.md)
+ [Python-Tools und -Ressourcen](create-deploy-python-tools-resources.md)

# QuickStart: Stellen Sie eine Python-Anwendung auf Elastic Beanstalk bereit
<a name="python-quickstart"></a>

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

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

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

## Ihr AWS Konto
<a name="python-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](#python-quickstart-prereq)

### Erstellen Sie ein AWS Konto
<a name="python-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="python-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="python-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).

### Python- und Flask-Framework
<a name="python-quickstart-prereq.runtime"></a>

Vergewissern Sie sich, dass Sie eine funktionierende Python-Version `pip` installiert haben, indem Sie die folgenden Befehle ausführen.

```
~$ python3 --version
Python 3.N.N
>~$ python3 -m pip --version
pip X.Y.Z from ... (python 3.N.N)
```

Wenn einer der vorherigen Befehle „*Python wurde nicht gefunden*“ zurückgibt, führen Sie die folgenden Befehle aus, die `python` anstelle von verwenden`python3`. Die Einrichtung von Aliasnamen und symbolischen Links kann je nach Betriebssystem und individuellen Anpassungen variieren, sodass der `python3` Befehl auf Ihrem Computer möglicherweise nicht funktioniert.

```
~$ python --version
Python 3.N.N
>~$ python -m pip --version
pip X.Y.Z from ... (python 3.N.N)
```

Wenn Sie Python nicht auf Ihrem lokalen Computer installiert haben, können Sie es von der [Python-Downloadseite](https://www.python.org/downloads/) auf der Python-Website herunterladen. Eine Liste der von Elastic Beanstalk unterstützten Python-Sprachversionen finden Sie unter [Unterstützte *AWS Elastic Beanstalk Python-Plattformen* im Plattformhandbuch](https://docs.aws.amazon.com/elasticbeanstalk/latest/platforms/platforms-supported.html#platforms-supported.python). Die Python-Download-Website bietet einen Link zum *Python Developer's Guide*, in dem Sie Installations- und Einrichtungsanweisungen finden.

**Anmerkung**  
Das `pip` Python-Paket ist standardmäßig in Python 3.4 oder höher enthalten.

Wenn Ihre Ausgabe darauf hinweist, dass Sie eine unterstützte Version von Python haben, aber nicht`pip`, finden Sie weitere Informationen auf der [Installationsseite](https://pip.pypa.io/en/stable/installation/) auf der *pip.pypa.io-Website*. Es bietet Anleitungen zur Installation von Pip in einer Python-Umgebung, in der es nicht vorhanden ist.



Bestätigen Sie, ob Flask installiert ist, indem Sie den folgenden Befehl ausführen:

```
~$ pip list | grep Flask
```

Wenn Flask nicht installiert ist, können Sie es mit dem folgenden Befehl installieren:

```
~$ pip install Flask
```

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

Erstellen Sie ein Projektverzeichnis.

```
~$ mkdir eb-python
~$ cd eb-python
```

Erstellen Sie ein Beispiel für „Hello Elastic Beanstalk\$1“ Python-Anwendung, die Sie mit Elastic Beanstalk bereitstellen.

Erstellen Sie eine Textdatei mit dem Namen `application.py` in dem Verzeichnis, das Sie gerade erstellt haben, mit dem folgenden Inhalt.

**Example `~/eb-python/application.py`**  

```
from flask import Flask
application = Flask(__name__)

@application.route('/')
def hello_elastic_beanstalk():
        return 'Hello Elastic Beanstalk!'
```

Erstellen Sie eine Textdatei `requirements.txt` mit dem Namen der folgenden Zeile. Diese Datei enthält die erforderlichen `pip` Pakete, damit die Anwendung ausgeführt werden kann.

**Example `~/eb-python/requirements.txt`**  

```
Flask
```

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

Führen Sie den folgenden Befehl aus, um Ihre Anwendung lokal auszuführen.

```
~/eb-python$ export FLASK_APP=application.py && flask run --port 5000
```

Sie sollten eine Ausgabe sehen, die der folgenden ähnelt

```
Serving Flask app 'application.py'
Debug mode: off
WARNING: This is a development server. Do not use it in a production deployment. Use a production WSGI server instead.
Running on http://127.0.0.1:5000
Press CTRL+C to quit
127.0.0.1 - - [01/Jan/1970 00:00:00] "GET / HTTP/1.1" 200 -
```

Navigieren Sie `http://localhost:5000` in Ihrem Webbrowser zu. Der Webbrowser sollte „Hello Elastic Beanstalk\$1“ anzeigen.

## Schritt 3: Stellen Sie Ihre Python-Anwendung mit der EB CLI bereit
<a name="python-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 Python-Anwendung bereitzustellen**

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

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

   Dieser Befehl erstellt eine Anwendung mit dem Namen `python-tutorial` und konfiguriert Ihr lokales Repository so, dass Umgebungen mit der bereitgestellten Python-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-python$ 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-python$ eb create python-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="python-quickstart-run-eb-ap"></a>

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

```
~/eb-python$ eb open
```

Herzlichen Glückwunsch\$1 Sie haben eine Python-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="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-python$ eb terminate
```

## AWS Ressourcen für Ihre Anwendung
<a name="python-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="python-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, sehen Sie sich die folgenden Tutorials an:  
[Bereitstellen einer Flask-Anwendung in Elastic Beanstalk](create-deploy-python-flask.md)
[Bereitstellen einer Django-Anwendung in Elastic Beanstalk](create-deploy-python-django.md)

Nachdem Sie eine oder zwei Beispielanwendungen bereitgestellt haben und bereit sind, Python-Anwendungen lokal zu entwickeln und auszuführen, finden Sie weitere Informationen unter[Einrichtung Ihrer Python-Entwicklungsumgebung für Elastic Beanstalk](python-development-environment.md). 

## Bereitstellung mit der Elastic Beanstalk Beanstalk-Konsole
<a name="python-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.

# Einrichtung Ihrer Python-Entwicklungsumgebung für Elastic Beanstalk
<a name="python-development-environment"></a>

Dieses Thema enthält Anweisungen zum Einrichten einer Python-Entwicklungsumgebung, in der Sie Ihre Anwendung lokal testen können, bevor Sie sie bereitstellen AWS Elastic Beanstalk. Es verweist auch auf Websites, die Installationsanweisungen für nützliche Tools bereitstellen.

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.

**Topics**
+ [Voraussetzungen](#python-common-prereq)
+ [Verwenden einer virtuellen Umgebung](#python-common-setup-venv)
+ [Konfigurieren eines Python-Projekts für Elastic Beanstalk](#python-common-configuring)

## Voraussetzungen
<a name="python-common-prereq"></a>

Die folgende Liste enthält die allgemeinen Voraussetzungen für die Arbeit mit Elastic Beanstalk und Ihren Python-Anwendungen:
+ **Python-Sprache** — Installieren Sie die Version der Python-Sprache, die in der von Ihnen ausgewählten Version der Elastic Beanstalk-Python-Plattform enthalten ist. Eine Liste unserer unterstützten Python-Sprachversionen finden Sie unter [Unterstützte AWS Elastic Beanstalk Python-Plattformen](https://docs.aws.amazon.com/elasticbeanstalk/latest/platforms/platforms-supported.html#platforms-supported.python) *im Plattformhandbuch*. Wenn Sie Python noch nicht auf Ihrem Entwicklungscomputer eingerichtet haben, besuchen Sie die [Python-Downloadseite](https://www.python.org/downloads/) auf der Python-Website.
+ **`pip`Hilfsprogramm** — Das `pip` Hilfsprogramm ist Pythons Paket-Installer. Es installiert und listet Abhängigkeiten für Ihr Projekt auf, sodass Elastic Beanstalk weiß, wie die Umgebung Ihrer Anwendung eingerichtet wird. *Weitere Informationen `pip` dazu finden Sie auf der [Pip-Seite auf der pip.pypa.io-Website](https://pip.pypa.io/en/stable/).*
+ **(Optional) Die Elastic Beanstalk Command Line Interface (EB CLI)** — Die [EB-CLI](eb-cli3.md) kann Ihre Anwendung mit den erforderlichen Bereitstellungsdateien verpacken. Es kann auch eine Elastic Beanstalk Beanstalk-Umgebung erstellen und Ihre Anwendung darauf bereitstellen. Sie können Bereitstellungen auch über die Elastic Beanstalk Beanstalk-Konsole vornehmen, sodass die EB-CLI nicht unbedingt erforderlich ist.
+ **Eine funktionierende `SSH` Installation** — Sie können über das SSH-Protokoll eine Verbindung zu Ihren laufenden Instances herstellen, um ein Deployment zu untersuchen oder zu debuggen.
+ **`virtualenv`Paket** — Dieses `virtualenv` Tool erstellt eine Entwicklungs- und Testumgebung für Ihre Anwendung. Elastic Beanstalk kann diese Umgebung replizieren, ohne zusätzliche Pakete zu installieren, die für Ihre Anwendung nicht erforderlich sind. [Weitere Informationen finden Sie auf der virtualenv-Website.](https://virtualenv.pypa.io/en/latest/) Nach der Installation von Python können Sie das `virtualenv` Paket mit dem folgenden Befehl installieren:

  ```
  $ pip install virtualenv
  ```

## Verwenden einer virtuellen Umgebung
<a name="python-common-setup-venv"></a>

Sofern die Voraussetzungen erfüllt sind, können Sie eine virtuelle Umgebung mit `virtualenv` einrichten und die Anwendungsabhängigkeiten installieren. Mithilfe einer virtuellen Umgebung können Sie genau erkennen, welche Pakete von Ihrer Anwendung benötigt werden, sodass die erforderlichen Pakete auf den EC2 Instanzen installiert werden, auf denen Ihre Anwendung ausgeführt wird.

**So richten Sie eine virtuelle Umgebung ein**

1. Öffnen Sie ein Befehlszeilenfenster und geben Sie Folgendes ein:

   ```
   $ virtualenv /tmp/eb_python_app
   ```

   *eb\$1python\$1app*Ersetzen Sie es durch einen Namen, der für Ihre Anwendung sinnvoll ist (es ist eine gute Idee, den Namen Ihrer Anwendung zu verwenden). Der Befehl `virtualenv` erstellt für Sie eine virtuelle Umgebung im angegebenen Verzeichnis und druckt die Ergebnisse seiner Aktionen:

   ```
   Running virtualenv with interpreter /usr/bin/python
   New python executable in /tmp/eb_python_app/bin/python3.12
   Also creating executable in /tmp/eb_python_app/bin/python
   Installing setuptools, pip...done.
   ```

1. Sobald die virtuelle Umgebung bereit ist, starten Sie diese mithilfe des Skripts `activate`, das Sie im Verzeichnis `bin` der Umgebung finden. Um die im vorherigen Schritt erstellte Umgebung **eb\$1python\$1app** zu starten, geben Sie beispielsweise Folgendes ein:

   ```
   $ source /tmp/eb_python_app/bin/activate
   ```

   In der virtuellen Umgebung wird der Name (z. B. `(eb_python_app)`) am Anfang jeder Eingabeaufforderung angezeigt, damit Sie wissen, dass es sich um eine virtuelle Python-Umgebung handelt.

1. Führen Sie den Befehl `deactivate` aus, um die Verwendung Ihrer virtuellen Umgebung zu beenden und zum standardmäßigen Python-Interpreter des Systems mit allen installierten Bibliotheken zurückzukehren.

   ```
   (eb_python_app) $ deactivate
   ```

**Anmerkung**  
Wenn sie erstellt ist, können Sie die virtuelle Umgebung jederzeit starten, indem Sie das Skript `activate` erneut ausführen.

## Konfigurieren eines Python-Projekts für Elastic Beanstalk
<a name="python-common-configuring"></a>

Sie können die Elastic Beanstalk CLI verwenden, um Ihre Python-Anwendungen auf die Bereitstellung mit Elastic Beanstalk vorzubereiten.

**So konfigurieren Sie eine Python-Anwendung für die Bereitstellung mit Elastic Beanstalk**

1. Kehren Sie in der [virtuellen Umgebung](#python-common-setup-venv) nach oben zum Verzeichnisbaum des Projekts zurück (`python_eb_app`) und geben Sie Folgendes ein:

   ```
   pip freeze >requirements.txt
   ```

   Mit diesem Befehl werden die Namen und Versionen der Pakete, die in der virtuellen Umgebung installiert sind, zu `requirements.txt` kopiert. Wenn beispielsweise das Paket *PyYAML* in der Version *3.11* in der virtuellen Umgebung installiert ist, enthält die Datei die folgende Zeile:

   ```
   PyYAML==3.11
   ```

   Auf diese Weise verwendet Elastic Beanstalk dieselben Pakete und Versionen, mit denen Sie die Anwendung entwickelt und getestet haben, um die Python-Umgebung der Anwendung zu replizieren.

1. Konfigurieren Sie das Repository der EB CLI mit dem Befehl **eb init**. Folgen Sie den Anweisungen und wählen Sie die Region, die Plattform und andere Optionen aus.

Standardmäßig sucht Elastic Beanstalk nach einer Datei namens `application.py`, um die Anwendung zu starten. Falls diese im erstellten Python-Projekt nicht vorhanden ist, sind bestimmte Anpassungen an der Anwendungsumgebung erforderlich. Außerdem müssen Sie Umgebungsvariablen festlegen, damit die Anwendungsmodule geladen werden können. Weitere Informationen finden Sie unter [Verwenden der Elastic Beanstalk Python-Plattform](create-deploy-python-container.md).

# Verwenden der Elastic Beanstalk Python-Plattform
<a name="create-deploy-python-container"></a>

In diesem Thema wird beschrieben, wie Sie Ihre Python-Anwendungen auf Elastic Beanstalk konfigurieren, erstellen und ausführen.

AWS Elastic Beanstalk unterstützt eine Reihe von Plattformzweigen für verschiedene Versionen der Programmiersprache Python. Eine vollständige Liste finden Sie unter [Python](https://docs.aws.amazon.com/elasticbeanstalk/latest/platforms/platforms-supported.html#platforms-supported.python) im Dokument *AWS Elastic Beanstalk Plattformen*.

Die Python-Webanwendungen können hinter einem Proxyserver mit WSGI ausgeführt werden. Elastic Beanstalk stellt [Gunicorn](https://gunicorn.org/) als Standard-WSGI-Server bereit. 

Sie können eine `Procfile` zu Ihrem Quell-Bundle hinzufügen, um den WSGI-Server für Ihre Anwendung anzugeben und zu konfigurieren. Details hierzu finden Sie unter [Konfiguration des WSGI-Servers mit einem Profil auf Elastic Beanstalk](python-configuration-procfile.md).

Mit den von Pipenv erstellten `Pipfile`- und `Pipfile.lock`-Dateien können Sie Python-Paketabhängigkeiten und andere Anforderungen angeben. Details zur Angabe von Abhängigkeiten finden Sie unter [Angeben von Abhängigkeiten mithilfe einer Anforderungsdatei auf Elastic Beanstalk](python-configuration-requirements.md).

Elastic Beanstalk bietet [Konfigurationsoptionen](command-options.md), mit denen Sie die Software anpassen können, die auf den EC2 Instances in Ihrer Elastic Beanstalk Beanstalk-Umgebung ausgeführt wird. Sie können die für Ihre Anwendung erforderlichen Umgebungsvariablen konfigurieren, die Protokollrotation an Amazon S3 aktivieren und die Ordner in der Anwendungsquelle, die statische Dateien enthalten, den vom Proxy-Server verwendeten Pfaden zuordnen.

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

Bei Python-Paketen, die über `pip` bereitgestellt werden, können Sie eine Anforderungsdatei in den Stamm des Anwendungsquellcodes aufnehmen. Elastic Beanstalk installiert alle Abhängigkeitspakete, die während der Bereitstellung in einer Anforderungsdatei angegeben sind. Details hierzu finden Sie unter [Angeben von Abhängigkeiten mithilfe einer Anforderungsdatei auf Elastic Beanstalk](python-configuration-requirements.md).

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

## Konfigurieren Ihrer Python-Umgebung
<a name="create-deploy-python-container-console"></a>

Mit den Python-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.

Verwenden Sie die Elastic Beanstalk Beanstalk-Konsole, um Python-Prozesseinstellungen zu konfigurieren AWS X-Ray, zu aktivieren, die Protokollrotation zu Amazon S3 zu aktivieren und Variablen zu konfigurieren, die Ihre Anwendung aus der Umgebung lesen kann.

**So konfigurieren Sie Ihre Python-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.

### Python-Einstellungen
<a name="python-console-settings"></a>
+ **Proxy server (Proxy-Server)** – Der Proxyserver, der in Ihren Umgebungs-Instances verwendet werden soll. Standardmäßig wird nginx verwendet.
+ **WSGI-Pfad** – Der Name oder Pfad zu Ihrer Hauptanwendungsdatei. Beispiel: `application.py` oder `django/wsgi.py`.
+ **NumProcesses**— Die Anzahl der Prozesse, die auf jeder Anwendungsinstanz ausgeführt werden sollen.
+ **NumThreads**— Die Anzahl der Threads, die in jedem Prozess ausgeführt werden sollen.

### AWS X-Ray Einstellungen
<a name="python-console-xray"></a>
+ **X-Ray-Daemon** — Führen Sie den AWS X-Ray Daemon aus, um Trace-Daten aus dem zu verarbeiten. [AWS X-Ray-SDK für Python](https://docs.aws.amazon.com/xray/latest/devguide/xray-sdk-python.html)

### Protokolloptionen
<a name="create-deploy-python-container.console.logoptions"></a>

Im Abschnitt mit den Protokolloptionen hat zwei Einstellungen:
+ **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="python-platform-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).

Standardmäßig stellt der Proxy-Server in einer Python-Umgebung alle Dateien im Ordner `static` unter dem Pfad `/static` bereit. Wenn beispielsweise die Anwendungsquelle eine Datei mit dem Namen `logo.png` im Ordner `static` enthält, wird diese vom Proxy-Server unter `subdomain.elasticbeanstalk.com/static/logo.png` an die Benutzer weitergeleitet. Sie können zusätzliche Zuweisungen konfigurieren, wie in diesem Abschnitt erklärt.

### Umgebungseigenschaften
<a name="create-deploy-python-custom-container-envprop"></a>

Mithilfe von Umgebungseigenschaften stellen Sie Informationen für die Anwendung bereit und konfigurieren Umgebungsvariablen. Beispielsweise können Sie eine Umgebungseigenschaft mit dem Namen `CONNECTION_STRING` mit einer Verbindungszeichenfolge erstellen, über die Ihre Anwendung eine Verbindung zu einer Datenbank herstellen kann.

Innerhalb der in Elastic Beanstalk ausgeführten Python-Umgebung können Sie diese Werte im `os.environ`-Wörterbuch von Python finden. Weitere Informationen finden Sie unter [http://docs.python. org/library/os](http://docs.python.org/library/os.html).html.

Der Code für den Zugriff auf Schlüssel und Parameter sollte wie folgt aussehen:

```
import os
endpoint = os.environ['API_ENDPOINT']
```

Umgebungseigenschaften können auch Informationen für ein Framework bereitstellen. Sie können beispielsweise eine Eigenschaft mit dem Namen `DJANGO_SETTINGS_MODULE` erstellen und so Django zur Verwendung eines bestimmten Einstellungsmoduls konfigurieren. Abhängig von der Umgebung könnte der Wert z. B. `development.settings` oder `production.settings` lauten.

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

## Namespaces der Python-Konfiguration
<a name="python-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 Python-Plattform definiert Optionen in den Namespaces `aws:elasticbeanstalk:environment:proxy`, `aws:elasticbeanstalk:environment:proxy:staticfiles` und `aws:elasticbeanstalk:container:python`.

In der folgenden Beispielkonfigurationsdatei werden Einstellungen für Konfigurationsoptionen angegeben, mit denen die `DJANGO_SETTINGS_MODULE`-Umgebungseigenschaft, zwei Optionen für statische Dateien, die das Verzeichnis `statichtml` dem Pfad `/html` und das Verzeichnis `staticimages` dem Pfad `/images` zuordnen, sowie weitere Einstellungen im Namespace `[aws:elasticbeanstalk:container:python](command-options-specific.md#command-options-python)` erstellt und der Apache-Proxy-Server ausgewählt werden. Dieser Namespace enthält Optionen, mit denen Sie den Speicherort des WSGI-Skripts im Quellcode und die Anzahl der Threads und Prozesse, die in WSGI ausgeführt werden sollen, angeben können.

```
option_settings:
  aws:elasticbeanstalk:application:environment:
    DJANGO_SETTINGS_MODULE: production.settings
  aws:elasticbeanstalk:environment:proxy:
    ProxyServer: apache
  aws:elasticbeanstalk:environment:proxy:staticfiles:
    /html: statichtml
    /images: staticimages
  aws:elasticbeanstalk:container:python:
    WSGIPath: ebdjango.wsgi:application
    NumProcesses: 3
    NumThreads: 20
```

**Hinweise**  
Wenn Sie eine Amazon Linux AMI Python-Plattformversion (Vorgängerversion von Amazon Linux 2) verwenden, ersetzen Sie den Wert für `WSGIPath` durch `ebdjango/wsgi.py`. Der Wert in diesem Beispiel ist für einen Gunicorn WSGI-Server bestimmt, der von Amazon Linux AMI-Plattformversionen nicht unterstützt wird.
Darüber hinaus verwenden diese älteren Plattformversionen einen anderen Namespace für die Konfiguration statischer Dateien:.—`aws:elasticbeanstalk:container:python:staticfiles`. Er hat die gleichen Optionsnamen und die gleiche Semantik wie der standardmäßige Namespace für statische Dateien.

Konfigurationsdateien unterstützen außerdem zahlreiche Schlüssel für die weitere [Anpassung der Software auf den Umgebungs-Instances](customize-containers-ec2.md). In diesem Beispiel wird der Schlüssel [packages (Pakete)](customize-containers-ec2.md#linux-packages) für die Memcached-Installation mit `yum` und [Container-Befehlen](customize-containers-ec2.md#linux-container-commands) verwendet, um Befehle für die Konfiguration des Servers während der Bereitstellung auszuführen.

```
packages:
  yum:
    libmemcached-devel: '0.31'

container_commands:
  collectstatic:
    command: "django-admin.py collectstatic --noinput"
  01syncdb:
    command: "django-admin.py syncdb --noinput"
    leader_only: true
  02migrate:
    command: "django-admin.py migrate"
    leader_only: true
  03wsgipass:
    command: 'echo "WSGIPassAuthorization On" >> ../wsgi.conf'
  99customize:
    command: "scripts/customize.sh"
```

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

## `python3`Die ausführbare Datei
<a name="python3-executable"></a>

Die Version der `python3` ausführbaren Datei, die auf EC2 Instances in Elastic Beanstalk-Python-Umgebungen verfügbar ist, entspricht nicht immer derselben Python-Version, die von der Plattform verwendet wird. `/usr/bin/python3`Verweist beispielsweise auf der Plattform Python 3.12 AL2 023 auf Python 3.9. Dies liegt daran, dass Python 3.9 das *System Python* auf AL2 023 ist. Weitere Informationen finden Sie unter [Python in AL2 023](https://docs.aws.amazon.com/linux/al2023/ug/python.html) im *Amazon Linux 2023 User Guide*. Sie können auf eine ausführbare Datei zugreifen, die der von der Plattform verwendeten Python-Version entspricht, an einem versionierten Speicherort (z. B.`/usr/bin/python3.12`) oder im `bin` Verzeichnis der virtuellen Anwendungsumgebung (z. B.`/var/app/venv/staging-LQM1lest/bin/python3`). Die Plattform verwendet die richtige ausführbare Python-Datei, die dem Plattformzweig entspricht. 

# Konfiguration des WSGI-Servers mit einem Profil auf Elastic Beanstalk
<a name="python-configuration-procfile"></a>

Sie können eine [`Procfile`](platforms-linux-extend.build-proc.md#platforms-linux-extend.proc) zu Ihrem Quell-Bundle hinzufügen, um den WSGI-Server für Ihre Anwendung anzugeben und zu konfigurieren. Sie können benutzerdefinierte Start- und Ausführungsbefehle in der angeben. `Procfile`

Wenn Sie eine `Procfile` verwenden, überschreibt sie die `aws:elasticbeanstalk:container:python`-Namespaceoptionen, die Sie mithilfe von Konfigurationsdateien festlegen.

Im folgenden Beispiel wird eine `Procfile` verwendet, um uWSGI als Server anzugeben und ihn zu konfigurieren.

**Example Procfile**  

```
web: uwsgi --http :8000 --wsgi-file application.py --master --processes 4 --threads 2
```

Im folgenden Beispiel wird eine `Procfile` verwendet, um Gunicorn, den Standard-WSGI-Server, zu konfigurieren.

**Example Procfile**  

```
web: gunicorn --bind :8000 --workers 3 --threads 2 project.wsgi:application
```

**Hinweise**  
Wenn Sie einen anderen WSGI-Server als Gunicorn konfigurieren, müssen Sie ihn auch als Abhängigkeit Ihrer Anwendung angeben, damit er auf Ihren Umgebungs-Instances installiert wird. Weitere Informationen zur Abhängigkeitsspezifikation finden Sie unter [Angeben von Abhängigkeiten mithilfe einer Anforderungsdatei auf Elastic Beanstalk](python-configuration-requirements.md).
Der Standardport für den WSGI-Server ist 8000. Wenn Sie in Ihrem `Procfile`-Befehl eine andere Portnummer angeben, legen Sie auch die `PORT`-[Umgebungseigenschaft](environments-cfg-softwaresettings.md) auf diese Portnummer fest.

# Angeben von Abhängigkeiten mithilfe einer Anforderungsdatei auf Elastic Beanstalk
<a name="python-configuration-requirements"></a>

In diesem Thema wird beschrieben, wie Sie Ihre Anwendung für die Installation anderer Python Python-Pakete konfigurieren. Eine typische Python-Anwendung weist Abhängigkeiten zu anderen Python-Paketen von Drittanbietern auf. Mit der Python-Plattform von Elastic Beanstalk haben Sie mehrere Möglichkeiten, Python-Pakete anzugeben, von denen Ihre Anwendung abhängt.

## Verwendung von `pip` und `requirements.txt`
<a name="python-configuration-requirements.txt"></a>

Das Standardwerkzeug für die Installation von Python-Paketen ist `pip`. Es hat eine Funktion, mit der Sie alle benötigten Pakete (und deren Versionen) in einer einzelnen Anforderungsdatei spezifizieren können. Weitere Informationen zur Anforderungsdatei finden Sie unter [Format der Anforderungsdatei](https://pip.pypa.io/en/latest/reference/requirements-file-format/#requirements-file-format) in der Website zur pip-Dokumentation.

Erstellen Sie eine Datei mit dem Namen `requirements.txt`, und speichern Sie diese im höchsten Verzeichnis Ihres Quell-Bundles. Das folgende Beispiel zeigt eine `requirements.txt`-Beispieldatei für Django.

```
Django==2.2
mysqlclient==2.0.3
```

In der Entwicklungsumgebung können Sie die Anforderungsdatei mit dem Befehl `pip freeze` generieren.

```
~/my-app$ pip freeze > requirements.txt
```

Damit sichergestellt ist, dass die Anforderungsdatei nur die tatsächlich von der Anwendung genutzten Pakete enthält, sollten Sie eine [virtuelle Umgebung](python-development-environment.md#python-common-setup-venv) verwenden, in der nur diese Pakete installiert sind. Außerhalb einer virtuellen Umgebung sind in der Ausgabe von `pip freeze` alle `pip`-Pakete enthalten, die auf dem Entwicklungscomputer installiert sind, darunter auch solche, die mit dem Betriebssystem ausgeliefert wurden.

**Anmerkung**  
Bei Amazon Linux AMI Python-Plattformversionen unterstützt Elastic Beanstalk Pipenv oder Pipfiles nicht nativ. Wenn Sie mit Pipenv Abhängigkeiten Ihrer Anwendung verwalten, führen Sie den folgenden Befehl aus, um eine `requirements.txt`-Datei zu generieren.  

```
~/my-app$ pipenv lock -r > requirements.txt
```
Weitere Informationen finden Sie unter [Generating a requirements.txt (Generieren einer Anforderungen.txt)](https://pipenv.readthedocs.io/en/latest/advanced/#generating-a-requirements-txt) in der Pipenv-Dokumentation.

## Verwendung von Pipenv und `Pipfile`
<a name="python-configuration-requirements.pipenv"></a>

Pipenv ist ein moderneres Python-Verpackungs-Tool. Es kombiniert die Paketinstallation mit der Erstellung und Verwaltung einer Abhängigkeitsdatei und einem virtualenv für Ihre Anwendung. Weitere Informationen finden Sie unter [Pipenv: Python Dev Workflow for Humans (Pipenv: Python Dev Workflow für Menschen)](https://pipenv.readthedocs.io/en/latest/).

Pipenv verwaltet zwei Dateien: 
+ `Pipfile` – Diese Datei enthält verschiedene Arten von Abhängigkeiten und Anforderungen.
+ `Pipfile.lock` – Diese Datei enthält einen Versions-Snapshot, der deterministische Builds ermöglicht.

Sie können die entsprechenden Dateien in Ihrer Entwicklungsumgebung erstellen und in das oberste Verzeichnis des Quellpakets aufnehmen, das Sie in Elastic Beanstalk bereitstellen. Weitere Informationen zu diesen beiden Dateien finden Sie unter [Beispiel für Pipfile und Pipfile.lock](https://pipenv.pypa.io/en/latest/basics/#).



Im folgenden Beispiel wird Pipenv verwendet, um Django und das Django REST-Framework zu installieren. Diese Befehle erstellen die Dateien `Pipfile` und `Pipfile.lock`.

```
~/my-app$ pipenv install django
~/my-app$ pipenv install djangorestframework
```

 

## Precedence
<a name="python-configuration-requirements.precedence"></a>

Wenn Sie mehr als eine der hier beschriebenen Anforderungsdateien hinzufügen, wird Elastic Beanstalk nur eine davon verwenden. Die folgende Liste zeigt die Rangfolge in absteigender Reihenfolge.

1. `requirements.txt`

1. `Pipfile.lock`

1. `Pipfile`

**Anmerkung**  
Ab der Amazon-Linux-2-Plattformversion vom 7. März 2023 gibt Elastic Beanstalk eine Konsolenmeldung aus, die angibt, welche der Abhängigkeitsdateien während einer Bereitstellung verwendet wurde, wenn Sie mehr als eine dieser Dateien bereitstellen.

In den folgenden Schritten wird die Logik beschrieben, der Elastic Beanstalk folgt, um die Abhängigkeiten zu installieren, wenn es eine Instance bereitstellt.
+ Wenn es eine `requirements.txt`-Datei gibt, verwenden wir den Befehl `pip install -r requirements.txt`.
+ Ab der Amazon Linux 2-Plattformversion vom 7. März 2023 verwenden wir den Befehl `pipenv sync`, wenn es keine `requirements.txt`-Datei gibt, aber eine `Pipfile.lock`. Vor dieser Veröffentlichung haben wir `pipenv install --ignore-pipfile` verwendet.
+ Wenn es weder eine `requirements.txt`-Datei noch eine `Pipfile.lock` gibt, aber eine `Pipfile`, verwenden wir den Befehl `pipenv install --skip-lock`.
+ Wenn keine der drei Anforderungsdateien gefunden wird, installieren wir keine Anwendungsabhängigkeiten.

# Bereitstellen einer Flask-Anwendung in Elastic Beanstalk
<a name="create-deploy-python-flask"></a>

Dieses Tutorial führt Sie durch den Prozess der Generierung einer Flask-Anwendung und deren Bereitstellung in einer AWS Elastic Beanstalk Umgebung. Flask ist ein Open Source-Framework für Python-Webanwendungen. 

In diesem Tutorial führen Sie folgende Aufgaben durch:
+ [Einrichten einer virtuellen Python-Umgebung mit Flask](#python-flask-setup-venv)
+ [Erstellen einer Flask-Anwendung](#python-flask-create-app)
+ [Bereitstellen Ihrer Website mit der EB-CLI](#python-flask-deploy) 
+ [Bereinigen](#python-flask-tutorial-cleanup) 

## Voraussetzungen
<a name="python-flask-prereq"></a>

In diesem Tutorial wird davon ausgegangen, dass Sie die grundlegenden Elastic Beanstalk-Operationen und die Elastic Beanstalk-Konsole kennen. Sofern noch nicht geschehen, starten Sie anhand der Anleitung in [Erfahren Sie, wie Sie mit Elastic Beanstalk loslegen können](GettingStarted.md) die erste Elastic-Beanstalk-Umgebung.

Für die Verfahren in diesem Leitfaden 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 in Windows integrierte Version von Ubuntu und Bash zu erhalten.

In diesem Tutorial verwenden wir Python 3.11 und die entsprechende Elastic Beanstalk-Plattformversion. Installieren Sie Python mithilfe der Anleitung unter [Einrichtung Ihrer Python-Entwicklungsumgebung für Elastic Beanstalk](python-development-environment.md).

Das [Flask](http://flask.pocoo.org/)-Framework wird im Rahmen des Tutorials installiert.

Dieses Tutorial verwendet die Elastic Beanstalk Befehlszeilenschnittstelle (Elastic Beanstalk Command Line, 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).

## Einrichten einer virtuellen Python-Umgebung mit Flask
<a name="python-flask-setup-venv"></a>

Erstellen Sie ein Projektverzeichnis sowie eine virtuelle Umgebung für Ihre Anwendung, und installieren Sie Flask.

**So richten Sie die Projektumgebung ein**

1. Erstellen Sie ein Projektverzeichnis.

   ```
   ~$ mkdir eb-flask
   ~$ cd eb-flask
   ```

1. Erstellen und aktivieren Sie eine virtuelle Umgebung mit dem Namen `virt`:

   ```
   ~/eb-flask$ virtualenv virt
   ~$ source virt/bin/activate
   (virt) ~/eb-flask$
   ```

   In der Eingabeaufforderung wird `(virt)` vorangestellt, sodass Sie wissen, dass Sie in einer virtuellen Umgebung arbeiten. Verwenden Sie die virtuelle Umgebung für den Rest dieses Tutorials.

1. Installieren Sie Flask mit `pip install`:

   ```
   (virt)~/eb-flask$ pip install flask==3.0.3
   ```

1. Zeigen Sie die installierten Bibliotheken mit `pip freeze` an:

   ```
   (virt)~/eb-flask$ pip freeze
   blinker==1.8.2
   click==8.1.7
   Flask==3.0.3
   importlib_metadata==8.5.0
   itsdangerous==2.2.0
   Jinja2==3.1.4
   MarkupSafe==2.1.5
   Werkzeug==3.0.4
   zipp==3.20.2
   ```

   Mit diesem Befehl werden alle Pakete aufgeführt, die in der virtuellen Umgebung installiert sind. Da Sie sich in einer virtuellen Umgebung befinden, werden global installierte Pakete wie die EB CLI nicht angezeigt.

1. Speichern Sie die Ausgabe aus `pip freeze` als Datei mit dem Namen `requirements.txt`.

   ```
   (virt)~/eb-flask$ pip freeze > requirements.txt
   ```

   Diese Datei weist Elastic Beanstalk an, die Bibliotheken während der Bereitstellung zu installieren. Weitere Informationen finden Sie unter [Angeben von Abhängigkeiten mithilfe einer Anforderungsdatei auf Elastic Beanstalk](python-configuration-requirements.md).

## Erstellen einer Flask-Anwendung
<a name="python-flask-create-app"></a>

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

Erstellen Sie eine neue Textdatei in diesem Verzeichnis mit dem Namen `application.py` mit folgendem Inhalt:

**Example `~/eb-flask/application.py`**  

```
from flask import Flask

# print a nice greeting.
def say_hello(username = "World"):
    return '<p>Hello %s!</p>\n' % username

# some bits of text for the page.
header_text = '''
    <html>\n<head> <title>EB Flask Test</title> </head>\n<body>'''
instructions = '''
    <p><em>Hint</em>: This is a RESTful web service! Append a username
    to the URL (for example: <code>/Thelonious</code>) to say hello to
    someone specific.</p>\n'''
home_link = '<p><a href="/">Back</a></p>\n'
footer_text = '</body>\n</html>'

# EB looks for an 'application' callable by default.
application = Flask(__name__)

# add a rule for the index page.
application.add_url_rule('/', 'index', (lambda: header_text +
    say_hello() + instructions + footer_text))

# add a rule when the page is accessed with a name appended to the site
# URL.
application.add_url_rule('/<username>', 'hello', (lambda username:
    header_text + say_hello(username) + home_link + footer_text))

# run the app.
if __name__ == "__main__":
    # Setting debug to True enables debug output. This line should be
    # removed before deploying a production app.
    application.debug = True
    application.run()
```

In diesem Beispiel wird eine benutzerdefinierte Begrüßung gedruckt, die je nach Pfad, der für den Zugriff auf den Service verwendet wurde, variiert.

**Anmerkung**  
Indem Sie `application.debug = True` vor der Ausführung der Anwendung hinzufügen, ist das Debuggen der Ausgabe aktiviert, falls ein Problem auftritt. Es ist eine bewährte Methode für die Entwicklung, Sie sollten jedoch Debug-Anweisungen im Produktionscode entfernen, da eine Debug-Ausgabe interne Aspekte Ihrer Anwendung offenlegen kann.

Verwenden Sie `application.py` als Dateinamen und geben Sie ein aufrufbares `application`-Objekt an (in diesem Fall das Flask-Objekt), damit Elastic Beanstalk den Code Ihrer Anwendung leichter finden kann.

Führen Sie `application.py` mit Python aus:

```
(virt) ~/eb-flask$ python application.py
 * Serving Flask app "application" (lazy loading)
 * Environment: production
   WARNING: Do not use the development server in a production environment.
   Use a production WSGI server instead.
 * Debug mode: on
 * Running on http://127.0.0.1:5000/ (Press CTRL+C to quit)
 * Restarting with stat
 * Debugger is active!
 * Debugger PIN: 313-155-123
```

Öffnen Sie `http://127.0.0.1:5000/` in Ihrem Webbrowser. Sie sollten sehen, dass die Anwendung ausgeführt wird. Dabei wird folgende Indexseite angezeigt:

![\[Web browser displaying "Hello World!" message and a hint about RESTful web service usage.\]](http://docs.aws.amazon.com/de_de/elasticbeanstalk/latest/dg/images/eb_flask_test_local.png)


Rufen Sie die Ausgabe der Anforderung im Serverprotokoll auf. Mit **Ctrl\$1C** stoppen Sie den Server und kehren in die virtuelle Umgebung zurück.

Wenn Sie stattdessen eine Debug-Ausgabe erhalten, beheben Sie die Fehler und stellen Sie sicher, dass die Anwendung lokal ausgeführt wird, bevor Sie sie für Elastic Beanstalk konfigurieren.

## Bereitstellen Ihrer Website mit der EB-CLI
<a name="python-flask-deploy"></a>

Die Anwendung kann nun in Elastic Beanstalk bereitgestellt werden. Das Projektverzeichnis sollte wie folgt aussehen:

```
~/eb-flask/
|-- virt
|-- application.py
`-- requirements.txt
```

Der `virt`-Ordner ist jedoch für die Ausführung der Anwendung in Elastic Beanstalk nicht erforderlich. Bei der Bereitstellung erstellt Elastic Beanstalk eine neue virtuelle Umgebung auf den Server-Instances und installiert die in `requirements.txt` aufgeführten Bibliotheken. Um die Größe des Quell-Bundles zu minimieren, das Sie während der Bereitstellung hochladen, fügen Sie eine [.ebignore](eb-cli3-configuration.md#eb-cli3-ebignore)-Datei hinzu, die der EB CLI mitteilt, dass der Ordner `virt` ausgelassen werden soll.

**Example \$1/eb-flask/.ebignore**  

```
virt
```

Im nächsten Schritt erstellen Sie die Anwendungsumgebung und stellen die konfigurierte Anwendung in Elastic Beanstalk bereit.

**So erstellen Sie eine Umgebung und stellen die Flask-Anwendung bereit**

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

   ```
   ~/eb-flask$ eb init -p python-3.11 flask-tutorial --region us-east-2
   Application flask-tutorial has been created.
   ```

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

1. (optional) Führen Sie den Befehl **eb init** erneut aus, um ein Standardschlüsselpaar zu konfigurieren, sodass Sie sich mit SSH mit der EC2 Instanz verbinden können, auf der Ihre Anwendung ausgeführt wird:

   ```
   ~/eb-flask$ 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 vorhandenes Schlüsselpaar aus (sofern vorhanden) oder befolgen Sie die Aufforderungen, um ein neues Paar 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:

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

Das Erstellen der Umgebung benötigt etwa fünf Minuten. Dabei werden die folgenden Ressourcen erstellt:
+ **EC2 Instanz** — Eine virtuelle Maschine von Amazon Elastic Compute Cloud (Amazon EC2), die für die Ausführung von Web-Apps auf der von Ihnen ausgewählten Plattform konfiguriert ist.

  Jede Plattform führt eine spezifische Gruppe von Software, Konfigurationsdateien und Skripts zur Unterstützung einer bestimmten Sprachversion, eines Frameworks, Webcontainers oder einer Kombination daraus aus. Die meisten Plattformen verwenden entweder Apache oder NGINX als Reverseproxy, der vor der Web-App platziert ist, Anforderungen weiterleitet, statische Komponenten bedient und Zugriffs- und Fehlerprotokolle generiert.
+ **Instance-Sicherheitsgruppe** — Eine EC2 Amazon-Sicherheitsgruppe, die so konfiguriert ist, dass sie eingehenden Datenverkehr auf Port 80 zulässt. Diese Ressource ermöglicht es dem HTTP-Verkehr vom Load Balancer, die EC2 Instance zu erreichen, auf der Ihre Web-App ausgeführt wird. Standardmäßig ist Datenverkehr auf anderen Ports nicht zulässig.
+ **Load balancer (Load Balancer)**– Ein Elastic Load Balancing Load Balancer ist für die Verteilung von Anforderungen an die Instances, auf denen Ihre Anwendung ausgeführt wird, konfiguriert. Mit einem Load Balancer müssen Ihre Instances nicht mehr direkt für das Internet zugänglich gemacht werden.
+ **Load Balancer-Sicherheitsgruppe** — Eine EC2 Amazon-Sicherheitsgruppe, die so konfiguriert ist, dass sie eingehenden Verkehr auf Port 80 zulässt. Diese Ressource ermöglicht, dass HTTP-Datenverkehr aus dem Internet den Load Balancer erreicht. Standardmäßig ist Datenverkehr auf anderen Ports nicht zulässig.
+ **Auto Scaling group (Auto Scaling-Gruppe)** – Eine Auto Scaling-Gruppe, die so konfiguriert ist, dass sie eine Instance ersetzt, wenn diese beendet wird oder nicht verfügbar ist.
+ **Amazon S3-Bucket** – Ein Speicherort für Ihren Quellcode, Protokolle und andere Artefakte, die bei der Verwendung von Elastic Beanstalk erstellt werden.
+ ** CloudWatch CloudWatch Amazon-Alarme** — Zwei 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*.
**Domain-Sicherheit**  
[Um die Sicherheit Ihrer Elastic-Beanstalk-Anwendungen zu erhöhen, ist die Domain *elasticbeanstalk.com* in der Public Suffix List (PSL) registriert.](https://publicsuffix.org/)  
Wenn Sie jemals sensible Cookies im Standard-Domainnamen für Ihre Elastic Beanstalk Beanstalk-Anwendungen einrichten müssen, empfehlen wir Ihnen, Cookies mit einem `__Host-` Präfix zu verwenden, um die Sicherheit zu erhöhen. Diese Vorgehensweise schützt Ihre Domain vor Cross-Site-Request-Forgery-Versuchen (CSRF). Weitere Informationen finden Sie auf der [Set-Cookie](https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Set-Cookie#cookie_prefixes)-Seite im Mozilla Developer Network.

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

**Anmerkung**  
Der von Elastic Beanstalk erstellte Amazon S3-Bucket wird von den Umgebungen gemeinsam genutzt und beim Beenden einer Umgebung nicht gelöscht. Weitere Informationen finden Sie unter [Verwenden von Elastic Beanstalk mit Amazon S3](AWSHowTo.S3.md).

Wenn die Umgebungserstellung abgeschlossen ist, öffnen Sie die Website mit **eb open**:

```
~/eb-flask$ eb open
```

Es wird ein Browserfenster mit dem für die Anwendung erstellten Domainnamen geöffnet. Sie sollten dieselbe Flask-Website sehen, die Sie erstellt und lokal getestet haben.

![\[Browser window displaying a Flask web application with a "Hello World!" message and usage hint.\]](http://docs.aws.amazon.com/de_de/elasticbeanstalk/latest/dg/images/eb_flask_deployed.png)


Falls die Anwendung nicht ausgeführt wird oder Sie eine Fehlermeldung erhalten, finden Sie unter [Troubleshooting deployments (Behebung von Bereitstellungsfehlern)](troubleshooting.md#troubleshooting-deployments) weitere Informationen zur Ermittlung der Fehlerursache.

Wenn Sie die Anwendung *ausführen*, haben Sie Ihre erste Flask-Anwendung mit Elastic Beanstalk bereitgestellt. Herzlichen Glückwunsch\$1

## Bereinigen
<a name="python-flask-tutorial-cleanup"></a>

Nachdem Sie die Arbeit mit dem Demo-Code abgeschlossen haben, können Sie Ihre Umgebung beenden. [Elastic Beanstalk löscht alle zugehörigen AWS Ressourcen wie [ EC2 Amazon-Instances, [Datenbank-Instances](using-features.managing.db.md)](using-features.managing.ec2.md), [Load Balancer](using-features.managing.elb.md), Sicherheitsgruppen und Alarme.](using-features.alarms.md#using-features.alarms.title) 

Durch das Entfernen von Ressourcen wird die Elastic Beanstalk Beanstalk-Anwendung nicht gelöscht, sodass Sie jederzeit neue Umgebungen für Ihre Anwendung erstellen können.

**So beenden Sie Ihre Elastic Beanstalk Beanstalk-Umgebung über die 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. Klicken Sie auf **Actions** (Aktionen) und dann auf **Terminate Environment** (Umgebung beenden).

1. Verwenden Sie das Dialogfeld auf dem Bildschirm, um die Beendigung der Umgebung zu bestätigen.

Oder mit der EB CLI:

```
~/eb-flask$ eb terminate flask-env
```

## Nächste Schritte
<a name="python-flask-more-info"></a>

Weitere Informationen über Flask finden Sie unter [flask.pocoo.org](http://flask.pocoo.org/).

Unter [Bereitstellen einer Django-Anwendung in Elastic Beanstalk](create-deploy-python-django.md) steht Ihnen ein weiteres Python-Web-Framework zur Verfügung.

# Bereitstellen einer Django-Anwendung in Elastic Beanstalk
<a name="create-deploy-python-django"></a>

In diesem Tutorial erfahren Sie, wie die Bereitstellung einer standardmäßigen, automatisch generierten [Django](https://www.djangoproject.com/)-Website in einer AWS Elastic Beanstalk -Umgebung mit Python erfolgt. In diesem Tutorial erfahren Sie, wie Sie eine Python-Webanwendung in der Cloud mithilfe einer Elastic Beanstalk-Umgebung hosten. 

In diesem Tutorial führen Sie folgende Aufgaben durch:
+ [Einrichten einer virtuellen Python-Umgebung und Installieren von Django](#python-django-setup-venv)
+ [Erstellen eines Django-Projekts](#python-django-create-app)
+ [Konfigurieren der Django-Anwendung für Elastic Beanstalk](#python-django-configure-for-eb) 
+ [Bereitstellen Ihrer Website mit der EB-CLI](#python-django-deploy) 
+ [Aktualisieren der Anwendung](#python-django-update-app) 
+ [Bereinigen](#python-django-stopping)

## Voraussetzungen
<a name="python-django-prereq"></a>

Damit Sie die Schritte in diesem Tutorial durchführen können, müssen alle [allgemeinen Voraussetzungen](python-development-environment.md) für Python einschließlich der folgenden Pakete installiert sein:
+ Python 3.7 oder höher
+ `pip`
+ `virtualenv`
+ `awsebcli`

Das [Django](https://www.djangoproject.com/)-Framework wird im Rahmen des Tutorials installiert.

**Anmerkung**  
Zum Erstellen von Umgebungen mit der EB CLI ist eine [Servicerolle](concepts-roles-service.md) erforderlich. Eine Servicerolle generieren Sie, indem Sie eine Umgebung in der Elastic-Beanstalk-Konsole erstellen. Falls keine Servicerolle vorhanden ist, versucht die EB CLI eine Rolle zu erstellen, wenn Sie ausführen `eb create`.

## Einrichten einer virtuellen Python-Umgebung und Installieren von Django
<a name="python-django-setup-venv"></a>

Erstellen Sie eine virtuelle Umgebung mit `virtualenv` und verwenden Sie sie anschließend zur Installation von Django und der entsprechenden Abhängigkeiten. Durch die Verwendung einer virtuellen Umgebung können Sie genau wissen, welche Pakete Ihre Anwendung benötigt, sodass die erforderlichen Pakete auf den EC2 Amazon-Instances installiert werden, auf denen Ihre Anwendung ausgeführt wird. 

Die folgenden Schritte zeigen die Befehle, die Sie für Unix-basierte Systeme und Windows eingeben müssen. Sie werden auf separaten Registerkarten angezeigt.

**So richten Sie eine virtuelle Umgebung ein**

1. Erstellen Sie eine virtuelle Umgebung mit dem Namen `eb-virt`.

------
#### [ Unix-based systems ]

   ```
   ~$ virtualenv ~/eb-virt
   ```

------
#### [ Windows ]

   ```
   C:\> virtualenv %HOMEPATH%\eb-virt
   ```

------

1. Aktivieren Sie die virtuelle Umgebung.

------
#### [ Unix-based systems ]

   ```
   ~$ source ~/eb-virt/bin/activate
   (eb-virt) ~$
   ```

------
#### [ Windows ]

   ```
   C:\>%HOMEPATH%\eb-virt\Scripts\activate
   (eb-virt) C:\>
   ```

------

   In der Eingabeaufforderung wird `(eb-virt)` vorangestellt, sodass Sie wissen, dass Sie in einer virtuellen Umgebung arbeiten.
**Anmerkung**  
In den restlichen Anleitungsschritten wird die Linux-Eingabeaufforderung im Stammverzeichnis `~$` angezeigt. Unter Windows ist das`C:\Users\USERNAME>`, wo *USERNAME* ist Ihr Windows-Anmeldename.

1. Installieren Sie mit `pip` Django.

   ```
   (eb-virt)~$ pip install django==2.2
   ```
**Anmerkung**  
Die Django-Version, die Sie installieren, muss mit der Python-Version in der Phyton-Konfiguration von Elastic Beanstalk, die Sie für die Bereitstellung Ihrer Anwendung auswählen, kompatibel sein. Weitere Informationen zur Bereitstellung finden Sie unter [Bereitstellen Ihrer Website mit der EB-CLI](#python-django-deploy) in diesem Thema.  
Weitere Informationen zu aktuellen Python-Plattformversionen finden Sie unter [Python](https://docs.aws.amazon.com/elasticbeanstalk/latest/platforms/platforms-supported.html#platforms-supported.python) im Dokument *AWS Elastic Beanstalk -Plattformen*.  
Informationen zur Kompatibilität von Django-Versionen mit Python finden Sie unter [Welche Phyton-Version kann ich mit Django verwenden?](https://docs.djangoproject.com/en/3.1/faq/install/#what-python-version-can-i-use-with-django)

1. Zur Überprüfung, ob Django installiert ist, geben Sie Folgendes ein.

   ```
   (eb-virt)~$ pip freeze
   Django==2.2
   ...
   ```

   Mit diesem Befehl werden alle Pakete aufgeführt, die in der virtuellen Umgebung installiert sind. Später verwenden Sie die Ausgabe dieses Befehls, um Ihr Projekt zur Verwendung mit Elastic Beanstalk zu konfigurieren.

## Erstellen eines Django-Projekts
<a name="python-django-create-app"></a>

Nun können Sie in der virtuellen Umgebung ein Django-Projekt erstellen und auf dem Computer ausführen.

**Anmerkung**  
Dieses Tutorial verwendet SQLite, eine Datenbank-Engine, die in Python enthalten ist. Die Datenbank wird mit Ihren Projektdateien bereitgestellt. Für Produktionsumgebungen wird empfohlen, Amazon Relational Database Service (Amazon RDS) zu verwenden und von der Umgebung zu trennen. Weitere Informationen finden Sie unter [Hinzufügen einer Amazon RDS-DB-Instance zu Ihrer Python Elastic Beanstalk Beanstalk-Umgebung](create-deploy-python-rds.md).

**So erstellen Sie eine Django-Anwendung**

1. Aktivieren Sie die virtuelle Umgebung.

------
#### [ Unix-based systems ]

   ```
   ~$ source ~/eb-virt/bin/activate
   (eb-virt) ~$
   ```

------
#### [ Windows ]

   ```
   C:\>%HOMEPATH%\eb-virt\Scripts\activate
   (eb-virt) C:\>
   ```

------

   In der Eingabeaufforderung wird das Präfix `(eb-virt)` vorangestellt, sodass Sie wissen, dass Sie in einer virtuellen Umgebung arbeiten.
**Anmerkung**  
In den restlichen Anleitungsschritten werden die Linux-Eingabeaufforderung `~$` in Ihrem Stammverzeichnis und das Linux-Stammverzeichnis `~/` angezeigt. Unter Windows sind dies`C:\Users\USERNAME>`, wo *USERNAME* ist Ihr Windows-Anmeldename.

1. Verwenden Sie den Befehl `django-admin startproject` zum Erstellen eines Django-Projekts mit dem Namen `ebdjango`.

   ```
   (eb-virt)~$ django-admin startproject ebdjango
   ```

   Mit diesem Befehl wird eine Django-Standard-Website mit dem Namen **ebdjango** und folgender Verzeichnisstruktur erstellt.

   ```
   ~/ebdjango
     |-- ebdjango
     |   |-- __init__.py
     |   |-- settings.py
     |   |-- urls.py
     |   `-- wsgi.py
     `-- manage.py
   ```

1. Führen Sie die Django-Website lokal mit `manage.py runserver` aus.

   ```
   (eb-virt) ~$ cd ebdjango
   ```

   ```
   (eb-virt) ~/ebdjango$ python manage.py runserver
   ```

1. Öffnen Sie zum Anzeigen der Website `http://127.0.0.1:8000/` in einem Webbrowser.

1. Rufen Sie die Ausgabe der Anforderung im Serverprotokoll auf. Um den Webserver zu stoppen und zu Ihrer virtuellen Umgebung zurückzukehren, drücken Sie **Strg\$1C**.

   ```
   Django version 2.2, using settings 'ebdjango.settings'
   Starting development server at http://127.0.0.1:8000/
   Quit the server with CONTROL-C.
   [07/Sep/2018 20:14:09] "GET / HTTP/1.1" 200 16348
   Ctrl+C
   ```

## Konfigurieren der Django-Anwendung für Elastic Beanstalk
<a name="python-django-configure-for-eb"></a>

Sie verfügen nun auf Ihrem lokalen Computer über eine Website mit Django-Unterstützung und können diese für die Bereitstellung in Elastic Beanstalk konfigurieren.

Standardmäßig sucht Elastic Beanstalk nach einer Datei mit dem Namen `application.py`, um Ihre Anwendung zu starten. Da diese im Django-Projekt, das Sie erstellt haben, nicht vorhanden ist, nehmen Sie einige Anpassungen an der Anwendungsumgebung vor. Außerdem legen Sie Umgebungsvariablen fest, damit die Anwendungsmodule geladen werden können.

**So konfigurieren Sie Ihre Website für Elastic Beanstalk**

1. Aktivieren Sie die virtuelle Umgebung.

------
#### [ Unix-based systems ]

   ```
   ~/ebdjango$ source ~/eb-virt/bin/activate
   ```

------
#### [ Windows ]

   ```
   C:\Users\USERNAME\ebdjango>%HOMEPATH%\eb-virt\Scripts\activate
   ```

------

1. Führen Sie `pip freeze` aus und speichern Sie die Ausgabe in der Datei `requirements.txt`.

   ```
   (eb-virt) ~/ebdjango$ pip freeze > requirements.txt
   ```

   Elastic Beanstalk verwendet`requirements.txt`, um zu bestimmen, welches Paket auf den EC2 Instances installiert werden soll, auf denen Ihre Anwendung ausgeführt wird.

1. Erstellen Sie ein Verzeichnis mit dem Namen `.ebextensions`.

   ```
   (eb-virt) ~/ebdjango$ mkdir .ebextensions
   ```

1. Fügen Sie im Verzeichnis `.ebextensions` eine [Konfigurationsdatei](ebextensions.md) mit dem Namen `django.config` und folgendem Text hinzu.  
**Example \$1/ebdjango/.ebextensions/django.config**  

   ```
   option_settings:
     aws:elasticbeanstalk:container:python:
       WSGIPath: ebdjango.wsgi:application
   ```

   Mit der Einstellung `WSGIPath` wird der Speicherort des WSGI-Skripts angegeben, das von Elastic Beanstalk für den Start der Anwendung verwendet wird.
**Anmerkung**  
Wenn Sie eine Amazon Linux AMI Python-Plattformversion (Vorgängerversion von Amazon Linux 2) verwenden, ersetzen Sie den Wert für `WSGIPath` durch `ebdjango/wsgi.py`. Der Wert in diesem Beispiel ist für einen Gunicorn WSGI-Server bestimmt, der von Amazon Linux AMI-Plattformversionen nicht unterstützt wird.

1. Deaktivieren Sie die virtuelle Umgebung mit dem Befehl `deactivate`.

   ```
   (eb-virt) ~/ebdjango$ deactivate
   ```

   Sie können die virtuelle Umgebung jederzeit wieder aktivieren, um Pakete zur Anwendung hinzuzufügen oder diese lokal auszuführen.

## Bereitstellen Ihrer Website mit der EB-CLI
<a name="python-django-deploy"></a>

Die Anwendung kann nun in Elastic Beanstalk bereitgestellt werden. Das Projektverzeichnis sollte wie folgt aussehen.

```
~/ebdjango/
|-- .ebextensions
|   `-- django.config
|-- ebdjango
|   |-- __init__.py
|   |-- settings.py
|   |-- urls.py
|   `-- wsgi.py
|-- db.sqlite3
|-- manage.py
`-- requirements.txt
```

Im nächsten Schritt erstellen Sie die Anwendungsumgebung und stellen die konfigurierte Anwendung in Elastic Beanstalk bereit.

Unmittelbar nach der Bereitstellung bearbeiten Sie die Django-Konfiguration. Fügen Sie der Django-`ALLOWED_HOSTS` den Domänennamen hinzu, den Elastic Beanstalk der Anwendung zugewiesen hat. Anschließend stellen Sie Ihre Anwendung erneut bereit. Dies ist eine Django-Sicherheitsanforderung, um HTTP-`Host`-Header-Angriffe zu verhindern. Weitere Informationen finden Sie unter [Host header validation (Host-Header-Validierung)](https://docs.djangoproject.com/en/2.2/topics/security/#host-headers-virtual-hosting).

**So erstellen Sie eine Umgebung und die Django-Anwendung bereit**
**Anmerkung**  
Dieses Tutorial verwendet die EB-CLI als Bereitstellungsmechanismus. Sie können jedoch auch die Elastic Beanstalk-Konsole zum Bereitstellen einer ZIP-Datei mit den Inhalten des Projekts verwenden. 

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

   ```
   ~/ebdjango$ eb init -p python-3.7 django-tutorial
   Application django-tutorial has been created.
   ```

   Dieser Befehl erstellt eine Anwendung mit dem Namen `django-tutorial`. Außerdem wird Ihr lokales Repository konfiguriert, damit Sie Umgebungen mit der neuesten Python 3.7-Plattformversion erstellen können.

1. (Optional) Führen Sie den Vorgang **eb init** erneut aus, um ein Standardschlüsselpaar zu konfigurieren, sodass Sie SSH verwenden können, um eine Verbindung zu der EC2 Instance herzustellen, auf der Ihre Anwendung ausgeführt wird.

   ```
   ~/ebdjango$ 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.

   ```
   ~/ebdjango$ eb create django-env
   ```
**Anmerkung**  
Wenn eine Fehlermeldung angezeigt wird, weil eine Servicerolle erforderlich ist, führen Sie `eb create` interaktiv aus (ohne Angabe eines Umgebungsnamens). Die EB CLI erstellt die Rolle dann für Sie.

   Mit diesem Befehl wird eine lastenverteilte Elastic Beanstalk-Umgebung namens `django-env` erstellt. Das Erstellen einer Umgebung dauert ca. 5 Minuten. Bei der zur Anwendungsausführung erforderlichen Ressourcenerstellung durch Elastic Beanstalk werden die ausgegebenen Informationsmeldungen von der EB CLI an den Terminal weitergeleitet.

1. Nachdem die Umgebung erstellt wurde, können Sie den Domänennamen der neuen Umgebung ermitteln, indem Sie **eb status** ausführen.

   ```
   ~/ebdjango$ eb status
   Environment details for: django-env
     Application name: django-tutorial
     ...
     CNAME: eb-django-app-dev.elasticbeanstalk.com
     ...
   ```

   Der Domänenname der Umgebung ist der Wert der Eigenschaft `CNAME`.

1. Öffnen Sie die `settings.py`-Datei im Verzeichnis `ebdjango`. Suchen Sie die `ALLOWED_HOSTS`-Einstellung und fügen Sie dann den Domänennamen Ihrer Anwendung, den Sie im vorherigen Schritt gefunden haben, zum Wert der Einstellung hinzu. Wenn Sie diese Einstellung nicht in der Datei finden, fügen Sie sie in einer neuen Zeile hinzu.

   ```
   ...
   ALLOWED_HOSTS = ['eb-django-app-dev.elasticbeanstalk.com']
   ```

1. Speichern Sie die Datei und stellen Sie die Anwendung dann bereit, indem Sie **eb deploy** ausführen . Bei Ausführung von **eb deploy** werden die Inhalte des Projektverzeichnisses von der EB CLI gebündelt und in der Umgebung bereitgestellt.

   ```
   ~/ebdjango$ eb deploy
   ```
**Anmerkung**  
Wenn Sie bei Ihrem Projekt Git verwenden, lesen Sie [Verwenden der EB CLI mit Git](eb3-cli-git.md).

1. Wenn die Umgebungsaktualisierung abgeschlossen ist, öffnen Sie die Website mit **eb open**.

   ```
   ~/ebdjango$ eb open
   ```

   Es wird ein Browserfenster mit dem für die Anwendung erstellten Domänennamen geöffnet. Sie sollten dieselbe Django-Website sehen, die Sie erstellt und lokal getestet haben.

Falls die Anwendung nicht ausgeführt wird oder Sie eine Fehlermeldung erhalten, finden Sie unter [Troubleshooting deployments (Behebung von Bereitstellungsfehlern)](troubleshooting.md#troubleshooting-deployments) weitere Informationen zur Ermittlung der Fehlerursache.

Wenn Sie die Anwendung *ausführen*, haben Sie Ihre erste Django-Anwendung mit Elastic Beanstalk bereitgestellt. Herzlichen Glückwunsch\$1

## Aktualisieren der Anwendung
<a name="python-django-update-app"></a>

Ihre Anwendung wird nun in Elastic Beanstalk ausgeführt. Sie können die Anwendung oder deren Konfiguration aktualisieren und erneut bereitstellen. Elastic Beanstalk führt dabei die Aktualisierung der Instances aus und startet Ihre neue Anwendungsversion.

In diesem Beispiel aktivieren Sie die Django-Admin-Konsole und konfigurieren weitere Einstellungen.

### Ändern der Einstellungen der Website
<a name="python-django-modify-site"></a>

Standardmäßig erfolgt die Zeitangabe der Django-Website in koordinierter Weltzeit (UTC). Sie können diese Einstellung ändern, indem Sie eine Zeitzone in `settings.py` angeben.

**So ändern Sie die Zeitzone der Website**

1. Ändern Sie die `TIME_ZONE`-Einstellung in `settings.py`.  
**Example \$1/ .py ebdjango/ebdjango/settings**  

   ```
   ...
   # Internationalization
   LANGUAGE_CODE = 'en-us'
   TIME_ZONE = 'US/Pacific'
   USE_I18N = True
   USE_L10N = True
   USE_TZ = True
   ```

   Eine Liste der Zeitzonen finden Sie auf [dieser Seite](https://en.wikipedia.org/wiki/List_of_tz_database_time_zones).

1. Stellen Sie die Anwendung in Ihrer Elastic Beanstalk-Umgebung bereit.

   ```
   ~/ebdjango/$ eb deploy
   ```

### Erstellen eines Websiteadministrators
<a name="python-django-create-admin"></a>

Sie können einen Websiteadministrator für Ihre Django-Anwendung erstellen, um direkt von der Website auf die Administrationskonsole zuzugreifen. Die Anmeldeinformationen für den Administrator werden sicher im lokalen Datenbank-Image gespeichert, das in das von Django generierte Standardprojekt eingebunden ist.

**So erstellen Sie einen Websiteadministrator**

1. Initialisieren Sie die lokale Datenbank der Django-Anwendung.

   ```
   (eb-virt) ~/ebdjango$ python manage.py migrate
   Operations to perform:
     Apply all migrations: admin, auth, contenttypes, sessions
   Running migrations:
     Applying contenttypes.0001_initial... OK
     Applying auth.0001_initial... OK
     Applying admin.0001_initial... OK
     Applying admin.0002_logentry_remove_auto_add... OK
     Applying admin.0003_logentry_add_action_flag_choices... OK
     Applying contenttypes.0002_remove_content_type_name... OK
     Applying auth.0002_alter_permission_name_max_length... OK
     Applying auth.0003_alter_user_email_max_length... OK
     Applying auth.0004_alter_user_username_opts... OK
     Applying auth.0005_alter_user_last_login_null... OK
     Applying auth.0006_require_contenttypes_0002... OK
     Applying auth.0007_alter_validators_add_error_messages... OK
     Applying auth.0008_alter_user_username_max_length... OK
     Applying auth.0009_alter_user_last_name_max_length... OK
     Applying sessions.0001_initial... OK
   ```

1. Führen Sie zum Erstellen eines Administrators `manage.py createsuperuser` aus.

   ```
   (eb-virt) ~/ebdjango$ python manage.py createsuperuser
   Username: admin
   Email address: me@mydomain.com
   Password: ********
   Password (again): ********
   Superuser created successfully.
   ```

1. Um Django einen Speicherort für statische Dateien zuzuweisen, definieren Sie `STATIC_ROOT` in `settings.py`.  
**Example \$1/ .py ebdjango/ebdjango/settings**  

   ```
   # Static files (CSS, JavaScript, Images)
   # https://docs.djangoproject.com/en/2.2/howto/static-files/
   STATIC_URL = '/static/'
   STATIC_ROOT = 'static'
   ```

1. Führen Sie aus`manage.py collectstatic`, um das `static` Verzeichnis mit statischen Elementen (JavaScript, CSS und Bildern) für die Admin-Site zu füllen.

   ```
   (eb-virt) ~/ebdjango$ python manage.py collectstatic
   119 static files copied to ~/ebdjango/static
   ```

1. Stellen Sie die Anwendung bereit.

   ```
   ~/ebdjango$ eb deploy
   ```

1. Rufen Sie die Administrationskonsole auf, indem Sie die Website im Browser öffnen und `/admin/` an die Website-URL anfügen, z. B. im Folgenden.

   ```
   http://djang-env.p33kq46sfh.us-west-2.elasticbeanstalk.com/admin/
   ```  
![\[Geben Sie den Benutzernamen und das Kennwort ein, die Sie in Schritt 2 erstellt haben, um sich bei der Admin-Konsole anzumelden.\]](http://docs.aws.amazon.com/de_de/elasticbeanstalk/latest/dg/images/eb_django_admin_login.png)

1. Melden Sie sich mit dem in Schritt 2 konfigurierten Benutzernamen und dem zugehörigen Passwort an.  
![\[Die Django-Admin-Konsole für Ihre mit Elastic Beanstalk bereitgestellte Django-Website\]](http://docs.aws.amazon.com/de_de/elasticbeanstalk/latest/dg/images/eb_django_admin_console.png)

Sie können ein ähnliches Verfahren verwenden: local updating/testing gefolgt von**eb deploy**. Elastic Beanstalk führt die Aktualisierung der Live-Server aus, sodass Sie sich nicht um die Serveradministration kümmern müssen, sondern sich ganz auf die Anwendungsbereitstellung konzentrieren können.

### Hinzufügen einer Konfigurationsdatei für die Datenbankmigration
<a name="python-django-migrate-site"></a>

Sie können Ihrem `.ebextensions`-Skript Befehle hinzufügen, die beim Aktualisieren der Website ausgeführt werden. Auf diese Weise können Sie automatisch Datenbankmigrationen generieren.

**So fügen Sie bei der Anwendungsbereitstellung einen Migrationsschritt hinzu**

1. Erstellen Sie eine [Konfigurationsdatei](ebextensions.md) namens `db-migrate.config` mit dem folgenden Inhalt.  
**Example \$1/ebdjango/.ebextensions/db-migrate.config**  

   ```
   container_commands:
     01_migrate:
       command: "source /var/app/venv/*/bin/activate && python3 manage.py migrate"
       leader_only: true
   option_settings:
     aws:elasticbeanstalk:application:environment:
       DJANGO_SETTINGS_MODULE: ebdjango.settings
   ```

   Diese Konfigurationsdatei führt den `manage.py migrate`-Befehl während des Bereitstellungsprozesses aus, bevor Ihre Anwendung gestartet wird. Da die Befehlsausführung vor dem Start der Anwendung erfolgt, muss die Umgebungsvariable `DJANGO_SETTINGS_MODULE` explizit konfiguriert werden (in der Regel wird dies von `wsgi.py` während des Starts übernommen). Geben Sie im Befehl `leader_only: true` an, damit dieser auch bei einer Bereitstellung auf mehreren Instances nur einmal ausgeführt wird.

1. Stellen Sie die Anwendung bereit.

   ```
   ~/ebdjango$ eb deploy
   ```

## Bereinigen
<a name="python-django-stopping"></a>

Um Instance-Stunden und andere AWS Ressourcen zwischen den Entwicklungssitzungen zu sparen, beenden Sie Ihre Elastic Beanstalk Beanstalk-Umgebung mit. **eb terminate**

```
~/ebdjango$ eb terminate django-env
```

Dieser Befehl beendet die Umgebung und alle AWS Ressourcen, die in ihr ausgeführt werden. Die Anwendung wird jedoch nicht gelöscht. Sie können durch die erneute Ausführung von **eb create** jederzeit zusätzliche Umgebungen mit der gleichen Konfiguration erstellen.

Sofern Sie die Beispielanwendung nicht mehr benötigen, können Sie auch den Projektordner sowie die virtuelle Umgebung entfernen.

```
~$ rm -rf ~/eb-virt
~$ rm -rf ~/ebdjango
```

## Nächste Schritte
<a name="python-django-next-steps"></a>

Weitere Informationen zu Django und ein ausführliches Tutorial finden Sie in der [offiziellen Dokumentation](https://docs.djangoproject.com/en/2.2/).

Unter [Bereitstellen einer Flask-Anwendung in Elastic Beanstalk](create-deploy-python-flask.md) steht Ihnen ein weiteres Python-Web-Framework zur Verfügung.

# Hinzufügen einer Amazon RDS-DB-Instance zu Ihrer Python Elastic Beanstalk Beanstalk-Umgebung
<a name="create-deploy-python-rds"></a>

Dieses Thema enthält Anweisungen zum Erstellen eines Amazon RDS mit der Elastic-Beanstalk-Konsole. Sie können eine DB-Instance von Amazon Relational Database Service (Amazon RDS) verwenden, um Daten zu speichern, die von Ihrer Anwendung gesammelt und geändert wurden. Die Datenbank kann an Ihre Umgebung gekoppelt sein und von Elastic Beanstalk verwaltet werden oder sie kann als entkoppelte Datenbank erstellt und extern von einem anderen Service verwaltet werden. In dieser Anleitung wird die Datenbank an Ihre Umgebung gekoppelt und von Elastic Beanstalk verwaltet. Weitere Informationen zur Integration eines Amazon RDS mit Elastic Beanstalk finden Sie unter [Hinzufügen einer Datenbank zu Ihrer Elastic Beanstalk-Umgebung](using-features.managing.db.md).

**Topics**
+ [Hinzufügen einer DB-Instance zu Ihrer Umgebung](#python-rds-create)
+ [Herunterladen eines Treibers](#python-rds-drivers)
+ [Herstellen einer Verbindung zu einer Datenbank](#python-rds-connect)

## Hinzufügen einer DB-Instance zu Ihrer Umgebung
<a name="python-rds-create"></a>

**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.  |  Es ist in der Amazon RDS-Konsole nicht als Referenz angegeben.  | 

Weitere Informationen zur Konfiguration einer Datenbank-Instance in Verbindung mit einer Elastic-Beanstalk-Umgebung finden Sie unter [Hinzufügen einer Datenbank zu Ihrer Elastic Beanstalk-Umgebung](using-features.managing.db.md).

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

Fügen Sie den Datenbanktreiber zur [requirements-Datei (Anforderungsdatei)](python-configuration-requirements.md) des Projekts hinzu.

**Example Beispieldatei "requirements.txt" – Django mit MySQL**  

```
Django==2.2
mysqlclient==2.0.3
```

**Gängige Treiberpakete für Python**
+ **MySQL** – `mysqlclient`
+ **PostgreSQL** – `psycopg2`
+ **Oracle** – `cx_Oracle`
+ **SQL Server** – `adodbapi`

Weitere Informationen finden Sie unter [Python DatabaseInterfaces](https://wiki.python.org/moin/DatabaseInterfaces) und [Django 2.2 — unterstützte Datenbanken](https://docs.djangoproject.com/en/2.2/ref/databases).

## Herstellen einer Verbindung zu einer Datenbank
<a name="python-rds-connect"></a>

Elastic Beanstalk stellt Verbindungsinformationen für zugehörige DB-Instances in Umgebungseigenschaften bereit. Mit `os.environ['VARIABLE']` können Sie die Eigenschaften lesen und eine Datenbankverbindung konfigurieren.

**Example Django-Einstellungsdatei – DATABASES Dictionary**  

```
import os

if 'RDS_HOSTNAME' in os.environ:
    DATABASES = {
        'default': {
            'ENGINE': 'django.db.backends.mysql',
            'NAME': os.environ['RDS_DB_NAME'],
            'USER': os.environ['RDS_USERNAME'],
            'PASSWORD': os.environ['RDS_PASSWORD'],
            'HOST': os.environ['RDS_HOSTNAME'],
            'PORT': os.environ['RDS_PORT'],
        }
    }
```

# Python-Tools und -Ressourcen
<a name="create-deploy-python-tools-resources"></a>

Es gibt zahlreiche Möglichkeiten, wie Sie zusätzliche Unterstützung bei der Entwicklung von Python-Anwendungen erhalten können:


****  

| Ressource | Description | 
| --- | --- | 
| [AWS SDK für Python (Boto3) auf GitHub](https://github.com/boto/boto3) | Installieren Sie Boto3, das von bezogen wurde. GitHub | 
| [AWS SDK für Python (Boto3) Homepage](https://aws.amazon.com//sdk-for-python/) | Die AWS SDK für Python (Boto3) Homepage. | 
| [Python-Entwicklerzentrum](https://aws.amazon.com/python/) | Umfangreiches Kit mit Beispiel-Code, Dokumentation, Tools und zusätzlichen Ressourcen. |