Bereitstellen einer Django-Anwendung in Elastic Beanstalk - AWS Elastic Beanstalk
VoraussetzungenEinrichten einer virtuellen Python-Umgebung und Installieren von DjangoErstellen eines Django-ProjektsKonfigurieren der Django-Anwendung für Elastic BeanstalkBereitstellen Ihrer Website mit der EB-CLIAktualisieren der AnwendungBereinigenNächste Schritte

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-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:

Voraussetzungen

Zur Nutzung eines AWS-Service, einschließlich Elastic Beanstalk, benötigen Sie ein AWS-Konto und Anmeldeinformationen. Weitere Informationen und die Kontoanmeldung finden Sie unter https://aws.amazon.com/.

Damit Sie die Schritte in diesem Tutorial durchführen können, müssen alle allgemeinen Voraussetzungen für Python einschließlich der folgenden Pakete installiert sein:

  • Python 3.7 oder höher

  • pip

  • virtualenv

  • awsebcli

Das Django-Framework wird im Rahmen des Tutorials installiert.

Anmerkung

Zum Erstellen von Umgebungen mit der EB CLI ist eine Servicerolle 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 wissen Sie genau, welche Pakete Ihre Anwendung benötigt, sodass die erforderlichen Pakete auf den Amazon EC2-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

  2. 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>, wobei USERNAME für Ihren Windows-Anmeldenamen steht.

  3. 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 in diesem Thema.

    Weitere Informationen zu aktuellen Python-Plattformversionen finden Sie unter 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?

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

In diesem Tutorial wird SQLite verwendet, 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 zur Python-Anwendungsumgebung.

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 ist das C:\Users\USERNAME>, wobei USERNAME für Ihren Windows-Anmeldenamen steht.

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

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

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

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

  5. 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+C.

    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

  2. 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 ermittelt anhand der Datei requirements.txt, welches Paket auf den EC2-Instances, die zur Anwendungsausführung verwendet werden, installiert werden muss.

  3. Erstellen Sie ein Verzeichnis mit dem Namen .ebextensions.

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

  4. Fügen Sie im Verzeichnis .ebextensions eine Konfigurationsdatei mit dem Namen django.config und folgendem Text hinzu.

    Beispiel ~/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.

  5. 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- den Domänennamen hinzu, den Elastic Beanstalk der Anwendung zugewiesen hat ALLOWED_HOSTS. 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).

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.

  2. (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.

    ~/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 aus eb init -i.

  3. Verwenden Sie , um eine Umgebung zu erstellen und die Anwendung darin bereitzustellen eb create.

    ~/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 erstellt django-env. 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.

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

    ~/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.

  5. Ö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']

  6. Speichern Sie die Datei und stellen Sie die Anwendung dann bereit, indem Sie ausführen eb deploy. 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.

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

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 angeben settings.py.

So ändern Sie die Zeitzone der Website

  1. Ändern Sie die TIME_ZONE-Einstellung in settings.py.

    Beispiel ~/ebdjango/ebdjango/settings.py
    ...
# 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.

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

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

  3. Um Django einen Speicherort für statische Dateien zuzuweisen, definieren Sie STATIC_ROOT in settings.py.

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

  4. Führen Sie manage.py collectstatic aus, um das Verzeichnis static mit statischen Komponenten (JavaScript, CSS und Images) für die Administrationswebsite aufzufüllen.

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

  5. Stellen Sie die Anwendung bereit.

    ~/ebdjango$ eb deploy

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

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

Sie können ein ähnliches Verfahren der lokalen Aktualisierung/Tests gefolgt von verwenden 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 namens db-migrate.config mit dem folgenden Inhalt.

    Beispiel ~/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.

  2. Stellen Sie die Anwendung bereit.

    ~/ebdjango$ eb deploy

Bereinigen

Um Instance-Stunden und weitere AWS-Ressourcen zwischen den Bereitstellungssitzungen einzusparen, beenden Sie die Elastic-Beanstalk-Umgebung mit eb terminate.

~/ebdjango$ eb terminate django-env

Mit diesem Befehl werden die Umgebung und alle zugehörigen AWS-Ressourcen beendet. 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. Weitere Informationen zu EB CLI-Befehlen finden Sie unter Elastic Beanstalk-Umgebungen mit der EB CLI verwalten.

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.

Unter steht Ihnen ein weiteres Python-Web-Framework zur Verfügung Bereitstellen einer Flask-Anwendung in Elastic Beanstalk.