View a markdown version of this page

Bereitstellen einer Flask-Anwendung in Elastic Beanstalk - AWS Elastic Beanstalk
VoraussetzungenEinrichten einer virtuellen Python-Umgebung mit FlaskErstellen einer Flask-AnwendungBereitstellen Ihrer Website mit der EB-CLIBereinigenNä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 Flask-Anwendung in Elastic Beanstalk

Dieses Tutorial führt Sie durch den Prozess der Generierung einer Flask-Anwendung und ihrer 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:

Voraussetzungen

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 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 ($) 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, um eine Windows-integrated 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.

Das Flask-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 Installieren Sie EB CLI mit dem Setup-Skript (empfohlen) und Konfigurieren der EB CLI.

Einrichten einer virtuellen Python-Umgebung mit Flask

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

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

  3. Installieren Sie Flask mit pip install:

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

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

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

Erstellen einer Flask-Anwendung

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

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

Beispiel~/eb- .py flask/application
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:

Flask-Anwendung, die lokal ausgeführt wird und die Hello World-Nachricht und einen Hinweis zum Anhängen des Benutzernamens an die URL anzeigt.

Rufen Sie die Ausgabe der Anforderung im Serverprotokoll auf. Mit Ctrl+C 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

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-Datei hinzu, die der EB CLI mitteilt, dass der Ordner virt ausgelassen werden soll.

Beispiel~/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, um Umgebungen mit der neuesten Python 3.11-Plattformversion zu erstellen.

  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:

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

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

  • Beanstalk Standard — Für eine Umgebung, die auf Amazon Elastic Compute Cloud (Amazon EC2) ausgeführt wird, stellt Elastic Beanstalk die folgenden Ressourcen bereit:

    • EC2-Instance — Eine virtuelle Amazon EC2-Maschine, die für die Ausführung von Webanwendungen 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 Reverse-Proxy, der vor der Web-App platziert ist, Anforderungen weiterleitet, statische Komponenten bedient und Zugriffs- und Fehlerprotokolle generiert.

    • Instance security group (Instance-Sicherheitsgruppe): Eine Amazon EC2-Sicherheitsgruppe, die so konfiguriert ist, dass eingehender Datenverkehr auf Port 80 erlaubt ist. Mit dieser Ressource kann HTTP-Datenverkehr vom Load Balancer die EC2-Instance mit Ihrer Web-App erreichen. Standardmäßig ist Datenverkehr auf anderen Ports nicht zulässig.

    • Load balancer security group (Load Balancer-Sicherheitsgruppe): Eine Amazon EC2-Sicherheitsgruppe, die so konfiguriert ist, dass eingehender Datenverkehr auf Port 80 erlaubt ist. 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.

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

  • Beanstalk Cluster — Für eine Umgebung, die auf Amazon EKS ausgeführt wird, stellt Elastic Beanstalk die folgenden Ressourcen bereit:

    • Amazon EKS-Cluster — Ein Amazon EKS-Cluster, den Elastic Beanstalk erstellt und betreibt. Umgebungen im selben Konto, die dieselben Subnetze verwenden, teilen sich einen Cluster.

    • Compute — Knotenkapazität, die vom Amazon EKS Auto Mode bereitgestellt wird. Dabei werden Knoten hinzugefügt und entfernt, sodass sie zu den im Cluster geplanten Anwendungsreplikaten passen.

    • IAM-Rollen — Die Cluster- und Node-Rollen, die Sie für Amazon EKS bereitstellen, und die Observability-Rolle, die Elastic Beanstalk verwendet, um die Metriken, Logs und Traces der Umgebung zu veröffentlichen.

    Weitere Informationen zu dieser Infrastruktur finden Sie unter. Beanstalk Cluster-Architektur

  • Load Balancer — Ein Load Balancer, der eingehende Anfragen auf Ihre Anwendung verteilt. Ein Load Balancer macht es auch überflüssig, Ihre Anwendung direkt dem Internet auszusetzen.

  • Amazon S3-Bucket – Ein Speicherort für Ihren Quellcode, Protokolle und andere Artefakte, die bei der Verwendung von Elastic Beanstalk erstellt werden.

  • CloudFormation Stack — Elastic Beanstalk verwendet CloudFormation es, um die Ressourcen in Ihrer Umgebung zu starten und Konfigurationsänderungen zu verbreiten. Die Ressourcen werden in einer Vorlage definiert, die Sie in der CloudFormation -Konsole anzeigen können.

  • Domainname — Ein Domainname, der im Formular zu Ihrer Web-App weitergeleitet wird. subdomain region.elasticbeanstalk.com.

    Sicherheit der Domain

    Um die Sicherheit Ihrer Elastic-Beanstalk-Anwendungen zu erhöhen, ist die Domain elasticbeanstalk.com in der Public Suffix List (PSL) registriert.

    Wenn Sie jemals vertrauliche Cookies im Standard-Domainnamen für Ihre Elastic Beanstalk-Anwendungen setzen müssen, empfehlen wir Ihnen, Cookies mit einem Präfix zu verwenden, um die Sicherheit zu erhöhen. __Host- Diese Vorgehensweise schützt Ihre Domain vor Cross-Site-Request-Forgery-Versuchen (CSRF). Weitere Informationen finden Sie auf der Set-Cookie 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.

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.

Die auf Elastic Beanstalk bereitgestellte Flask-Anwendung zeigt eine Hello World-Nachricht und einen Hinweis zum Anhängen des Benutzernamens an die URL an.

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 Flask-Anwendung mit Elastic Beanstalk bereitgestellt. Herzlichen Glückwunsch!

Bereinigen

Nachdem Sie die Arbeit mit dem Demo-Code beendet haben, können Sie Ihre Umgebung beenden. Elastic Beanstalk löscht alle zugehörigen AWS Ressourcen wie Amazon EC2-Instances, Datenbank-Instances, Load Balancer , Sicherheitsgruppen und Alarme.

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

Um Ihre Elastic Beanstalk-Umgebung von der Konsole aus zu beenden

  1. Öffnen Sie die Elastic Beanstalk-Konsole und wählen Sie in der Liste der Regionen Ihre aus. AWS-Region

  2. Wählen Sie im Navigationsbereich Environments (Umgebungen) aus und wählen Sie dann in der Liste den Namen Ihrer Umgebung aus.

  3. Klicken Sie auf Actions (Aktionen) und dann auf Terminate Environment (Umgebung beenden).

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

Weitere Informationen über Flask finden Sie unter flask.pocoo.org.

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