Wie man eine Flask-App im Produktionsmodus in Docker ausführt

Einführung

Docker ist eine beliebte Wahl für die Bereitstellung von Webanwendungen geworden, einschließlich Anwendungen auf Basis von Flask. In diesem Tutorial führen wir Sie durch den Prozess der Dockerisierung einer Flask-Anwendung und des Ausführens dieser in Produktionsmodus mit Docker. Am Ende dieses Artikels werden Sie einen soliden Überblick darüber haben, wie Sie Docker nutzen können, um Ihre Flask-App in einer Produktionsumgebung bereitzustellen.

Docker verstehen

Docker ist eine beliebte Open-Source-Plattform, die es Entwicklern ermöglicht, Anwendungen in einer containerisierten Umgebung zu erstellen, bereitzustellen und auszuführen. Sie bietet eine Möglichkeit, eine Anwendung und alle ihre Abhängigkeiten in einen einzigen Container zu packen, was es einfach macht, die Anwendung zwischen verschiedenen Rechenumgebungen zu verschieben.

Was ist Docker?

Docker ist eine Softwareplattform, die es Entwicklern ermöglicht, Anwendungen in Containern zu erstellen, bereitzustellen und auszuführen. Ein Container ist ein leichtgewichtiges, eigenständiges und ausführbares Paket, das alles enthält, was zur Ausführung einer Anwendung benötigt wird, einschließlich des Codes, der Laufzeitumgebung, der Systemtools und der Bibliotheken. Container sind voneinander und vom Host-Betriebssystem isoliert, was eine konsistente und zuverlässige Anwendungsbereitstellung gewährleistet.

Vorteile von Docker

Portabilität: Docker-Container können in verschiedenen Rechenumgebungen, von einem Entwicklerlaptop bis zu einem Produktionsserver, konsistent ausgeführt werden. Dies stellt sicher, dass die Anwendung unabhängig von der zugrunde liegenden Infrastruktur gleich verhält.
Skalierbarkeit: Docker erleichtert es, Anwendungen je nach Bedarf hoch- oder herunterzuskalieren, indem Container nach Bedarf hinzugefügt oder entfernt werden.
Effizienz: Docker-Container sind leichtgewichtig und verbrauchen weniger Ressourcen als traditionelle virtuelle Maschinen, was eine effizientere Nutzung der Rechenressourcen ermöglicht.
Konsistenz: Docker stellt sicher, dass die Anwendung und ihre Abhängigkeiten zusammen gepackt werden, wodurch das Problem „es funktioniert auf meinem Rechner“ beseitigt wird und eine konsistente Funktionsweise in verschiedenen Umgebungen gewährleistet ist.

Docker-Architektur

Die Docker-Architektur besteht aus den folgenden Schlüsselkomponenten:

graph TD
    A[Docker Client] --> B[Docker Daemon]
    B --> C[Docker Images]
    B --> D[Docker Containers]
    B --> E[Docker Networking]
    B --> F[Docker Storage]

Docker Client: Der Docker-Client ist die primäre Benutzeroberfläche für die Interaktion mit Docker. Er ermöglicht es Benutzern, Befehle an den Docker-Daemon zu senden, wie z. B. das Erstellen, Ausführen und Verwalten von Containern.
Docker Daemon: Der Docker-Daemon ist der Backend-Dienst, der die Erstellung, Modifikation und Entfernung von Docker-Objekten wie Images, Containern, Netzwerken und Volumes verwaltet.
Docker Images: Docker-Images sind die Baupläne für die Erstellung von Docker-Containern. Sie enthalten den Anwendungs-Code, die Bibliotheken, die Abhängigkeiten und alle anderen Dateien, die zur Ausführung der Anwendung benötigt werden.
Docker Containers: Docker-Container sind die laufenden Instanzen von Docker-Images. Sie sind isolierte, leichtgewichtige und portable Umgebungen, in denen die Anwendung ausgeführt wird.
Docker Networking: Docker bietet integrierte Netzwerkfunktionen, die es Containern ermöglichen, miteinander und mit der Außenwelt zu kommunizieren.
Docker Storage: Docker bietet verschiedene Speicheroptionen, einschließlich Volumes und Bind-Mounts, um die persistenten Daten eines Containers zu verwalten.

Das Verständnis der Docker-Architektur und ihrer Schlüsselkomponenten ist entscheidend für die effektive Nutzung und Verwaltung von Docker in Ihren Anwendungsentwicklung- und -bereitstellungsprozessen.

Dockerisierung einer Flask-Anwendung

In diesem Abschnitt erfahren wir, wie man eine Flask-Anwendung mit Docker containerisiert.

Erstellen einer Flask-Anwendung

Beginnen wir mit der Erstellung einer einfachen Flask-Anwendung. Erstellen Sie ein neues Verzeichnis und navigieren Sie in Ihrem Terminal dorthin. Erstellen Sie dann eine neue Datei namens app.py mit folgendem Inhalt:

from flask import Flask

app = Flask(__name__)

@app.route('/')
def hello():
    return 'Hello, LabEx!'

if __name__ == '__main__':
    app.run(host='0.0.0.0', port=5000)

Diese Flask-Anwendung hat eine einzige Route, die die Nachricht "Hello, LabEx!" zurückgibt.

Dockerisierung der Flask-Anwendung

Um die Flask-Anwendung zu containerisieren, müssen wir eine Dockerfile erstellen. Erstellen Sie eine neue Datei namens Dockerfile mit folgendem Inhalt:

FROM python:3.9-slim

WORKDIR /app

COPY requirements.txt.
RUN pip install --no-cache-dir -r requirements.txt

COPY..

CMD ["python", "app.py"]

Lassen Sie uns die Dockerfile analysieren:

FROM python:3.9-slim: Dies gibt das Basis-Image für den Docker-Container an, in diesem Fall die schlanke Version des Python 3.9-Images.
WORKDIR /app: Dies legt das Arbeitsverzeichnis innerhalb des Containers auf /app fest.
COPY requirements.txt.: Dies kopiert die Datei requirements.txt in das Arbeitsverzeichnis des Containers.
RUN pip install --no-cache-dir -r requirements.txt: Dies installiert die in der Datei requirements.txt angegebenen Python-Abhängigkeiten.
COPY..: Dies kopiert den gesamten Anwendungs-Code (einschließlich app.py) in das Arbeitsverzeichnis des Containers.
CMD ["python", "app.py"]: Dies gibt den Befehl an, der beim Starten des Containers ausgeführt werden soll, nämlich das Ausführen des Skripts app.py mit dem Python-Interpreter.

Erstellen und Ausführen des Docker-Containers

Jetzt erstellen wir das Docker-Image und führen den Container aus:

Erstellen Sie das Docker-Image:
```
docker build -t labex-flask-app.
```

Führen Sie den Docker-Container aus:

docker run -p 5000:5000 labex-flask-app

Die Option -p 5000:5000 bildet den Port 5000 des Hosts auf den Port 5000 des Containers ab, sodass Sie die Flask-Anwendung von Ihrem lokalen Rechner aus zugreifen können.

Nachdem Sie den Container gestartet haben, können Sie die Flask-Anwendung in einem Webbrowser öffnen und zu http://localhost:5000 navigieren. Sie sollten die Nachricht "Hello, LabEx!" sehen.

Herzlichen Glückwunsch! Sie haben erfolgreich eine Flask-Anwendung mit Docker containerisiert.

Ausführen einer Flask-App im Produktionsmodus

Wenn Sie eine Flask-Anwendung in einer Produktionsumgebung ausführen, ist es wichtig, einen produktionsreifen Server anstelle des integrierten Entwicklungsservers zu verwenden. In diesem Abschnitt erfahren Sie, wie Sie eine Flask-Anwendung im Produktionsmodus mit Docker ausführen.

Auswahl eines Produktionsservers

Es gibt mehrere produktionsreife Webserver, die verwendet werden können, um eine Flask-Anwendung auszuführen, wie Gunicorn, uWSGI und Waitress. In diesem Beispiel verwenden wir Gunicorn, einen beliebten und weit verbreiteten Webserver für Python-Anwendungen.

Anpassen der Dockerfile

Um die Flask-Anwendung im Produktionsmodus mit Gunicorn auszuführen, müssen wir die Dockerfile aktualisieren. Ersetzen Sie den Inhalt der Dockerfile durch Folgendes:

FROM python:3.9-slim

WORKDIR /app

COPY requirements.txt.
RUN pip install --no-cache-dir -r requirements.txt

COPY..

RUN pip install gunicorn

CMD ["gunicorn", "--bind", "0.0.0.0:5000", "app:app"]

Die Hauptänderungen sind:

Wir haben RUN pip install gunicorn hinzugefügt, um den Gunicorn-Webserver zu installieren.
Wir haben die CMD-Anweisung geändert, um Gunicorn zum Starten der Flask-Anwendung zu verwenden. Der Befehl "gunicorn", "--bind", "0.0.0.0:5000", "app:app" teilt Gunicorn mit, die Anwendung an die Adresse 0.0.0.0:5000 zu binden und das app-Objekt aus der Datei app.py als WSGI-Anwendung zu verwenden.

Erstellen und Ausführen des produktionsreifen Docker-Containers

Jetzt erstellen wir das Docker-Image und führen den Container im Produktionsmodus aus:

Erstellen Sie das Docker-Image:
```
docker build -t labex-flask-app-prod.
```

Führen Sie den Docker-Container aus:

docker run -p 5000:5000 labex-flask-app-prod

Die Anwendung sollte jetzt im Produktionsmodus mit Gunicorn ausgeführt werden.

Überprüfen der Produktionsumgebung

Um zu überprüfen, ob die Flask-Anwendung im Produktionsmodus ausgeführt wird, können Sie den folgenden Befehl verwenden, um die Protokolle zu überprüfen:

docker logs <container_id>

Sie sollten eine Ausgabe ähnlich der folgenden sehen:

[2023-04-11 12:34:56 +0000] [1] [INFO] Starting gunicorn 20.1.0
[2023-04-11 12:34:56 +0000] [1] [INFO] Listening at: http://0.0.0.0:5000 (1)
[2023-04-11 12:34:56 +0000] [1] [INFO] Using worker: sync
[2023-04-11 12:34:56 +0000] [8] [INFO] Booting worker with pid: 8

Dies bestätigt, dass die Flask-Anwendung im Produktionsmodus mit dem Gunicorn-Webserver ausgeführt wird.

Zusammenfassung

Dieses Tutorial hat die wesentlichen Schritte zur Ausführung einer Flask-Anwendung im Produktionsmodus mit Docker behandelt. Wir haben den Prozess der Dockerisierung einer Flask-App untersucht, einschließlich der Erstellung einer Dockerfile und des Erstellens des Docker-Images. Darüber hinaus haben wir besprochen, wie man die Flask-App im Produktionsmodus innerhalb des Docker-Containers ausführt, um eine zuverlässige und skalierbare Bereitstellung zu gewährleisten. Indem Sie die in dieser Anleitung beschriebenen Vorgehensweisen befolgen, können Sie Docker effektiv nutzen, um Ihre auf Flask basierenden Webanwendungen in einer Produktionsumgebung bereitzustellen.