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. # Bereitstellen einer Django-Anwendung in Elastic Beanstalk 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 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 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 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 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 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 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 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 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 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 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 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.