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 BeanstalkStellen Sie Ihre Site mit dem EB bereit 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

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

Das Erstellen von Umgebungen mit dem EB CLI erfordert eine Servicerolle. Eine Servicerolle generieren Sie, indem Sie eine Umgebung in der Elastic-Beanstalk-Konsole erstellen. Wenn Sie keine Servicerolle haben, CLI versucht der EB, beim Ausführen eine zu erstelleneb 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

  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 dasC:\Users\USERNAME>, wo USERNAME ist Ihr Windows-Anmeldename.

  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 Stellen Sie Ihre Site mit dem EB bereit 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

Dieses Tutorial verwendetSQLite, eine Datenbank-Engine, die in Python enthalten ist. Die Datenbank wird mit Ihren Projektdateien bereitgestellt. Für Produktionsumgebungen empfehlen wir, Amazon Relational Database Service (AmazonRDS) zu verwenden und ihn von Ihrer Umgebung zu trennen. Weitere Informationen finden Sie unter Hinzufügen einer Amazon RDS DB-Instance zu Ihrer Python Elastic Beanstalk Beanstalk-Umgebung.

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 dasC:\Users\USERNAME>, wo USERNAME ist Ihr Windows-Anmeldename.

  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 manage.py runserver aus.

    (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 bestimmtrequirements.txt, welches Paket auf den EC2 Instances installiert werden soll, auf denen Ihre Anwendung ausgeführt wird.

  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

    Diese Einstellung gibt den Speicherort des WSGI Skripts anWSGIPath, das Elastic Beanstalk verwendet, um Ihre Anwendung zu starten.

    Anmerkung

    Wenn Sie eine Amazon AMI Linux-Python-Plattformversion (vor Amazon Linux 2) verwenden, ersetzen Sie den Wert für WSGIPath durchebdjango/wsgi.py. Der Wert im Beispiel funktioniert mit dem WSGI Gunicorn-Server, der auf Amazon AMI Linux-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.

Stellen Sie Ihre Site mit dem EB bereit 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, die HTTP Host Header-Angriffe verhindern soll. Weitere Informationen finden Sie unter Host header validation (Host-Header-Validierung).

So erstellen Sie eine Umgebung und die Django-Anwendung bereit
Anmerkung

In diesem Tutorial wird EB CLI als Bereitstellungsmechanismus verwendet. Sie können aber auch die Elastic Beanstalk Beanstalk-Konsole verwenden, um eine .zip-Datei mit den Inhalten Ihres Projekts bereitzustellen.

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

    ~/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 den eb init Vorgang erneut aus, um ein Standardschlüsselpaar zu konfigurieren, mit dem Sie eine Verbindung SSH zu der EC2 Instance herstellen können, 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.

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

    ~/ebdjango$ eb create django-env
    Anmerkung

    Wenn Sie die Fehlermeldung „Servicerolle erforderlich“ sehen, führen Sie die Ausführung eb create interaktiv aus (ohne Angabe eines Umgebungsnamens) und der EB CLI erstellt die Rolle für Sie.

    Mit diesem Befehl wird eine lastenverteilte Elastic Beanstalk-Umgebung namens django-env erstellt. Das Erstellen einer Umgebung dauert ca. 5 Minuten. Während Elastic Beanstalk die Ressourcen erstellt, die für die Ausführung Ihrer Anwendung erforderlich sind, gibt es Informationsmeldungen aus, die der EB an Ihr Terminal CLI weiterleitet.

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

  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 eb deploy ausführen . Bei der Ausführung eb deploy CLI bündelt der EB den Inhalt Ihres Projektverzeichnisses und stellt ihn in Ihrer Umgebung bereit.

    ~/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 verwendet Ihre Django-Website die Zeitzone, um die UTC Uhrzeit anzuzeigen. 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.

    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 ausmanage.py collectstatic, um das static Verzeichnis mit statischen Assets (JavaScriptCSS, und Bildern) für die Admin-Site zu fü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 Admin-Konsole auf, indem Sie die Site in Ihrem Browser öffnen und /admin/ sie an die Site anhängenURL, 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 eb deploy verwenden. 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 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. Weitere Informationen zu CLI EB-Befehlen finden Sie unterElastic 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 Bereitstellen einer Flask-Anwendung in Elastic Beanstalk steht Ihnen ein weiteres Python-Web-Framework zur Verfügung.