Flask-Anwendung im Docker-Container ausführen

Einführung

In diesem Tutorial untersuchen wir den Prozess der Ausführung einer Flask-Anwendung innerhalb eines Docker-Containers. Wir behandeln die Grundlagen von Docker, erstellen eine Flask-Anwendung und verpacken anschließend die Flask-App in einen Container, um die Vorteile von Docker zu nutzen.

Docker verstehen

Docker ist eine beliebte Open-Source-Plattform, die Entwicklern ermöglicht, Anwendungen in einer containerisierten Umgebung zu erstellen, bereitzustellen und auszuführen. Container sind leichte, eigenständige und ausführbare Softwarepakete, die alles enthalten, was zum Ausführen einer Anwendung benötigt wird, einschließlich Code, Laufzeitumgebung, Systemtools und Bibliotheken.

Was ist Docker?

Docker ist ein Werkzeug, das die Erstellung, Bereitstellung und Ausführung von Anwendungen mithilfe von Containern vereinfacht. Container ermöglichen es einem Entwickler, eine Anwendung mit allen benötigten Komponenten wie Bibliotheken und anderen Abhängigkeiten zu verpacken und als ein Paket auszuliefern.

Docker-Architektur

Die Docker-Architektur besteht aus folgenden Komponenten:

• Docker Client: Die Benutzeroberfläche zur Interaktion mit dem Docker-System.
• Docker Daemon: Der Hintergrundprozess, der Docker-Objekte wie Images, Container, Netzwerke und Volumes verwaltet.
• Docker Images: Blaupausen zur Erstellung von Docker-Containern.
• Docker Containers: Ausführbare Instanzen von Docker-Images.
• Docker Registries: Repositories zum Speichern und Verteilen von Docker-Images.

Vorteile der Verwendung von Docker

1. Konsistente Umgebungen: Docker stellt sicher, dass Anwendungen unabhängig von der zugrunde liegenden Infrastruktur auf dieselbe Weise ausgeführt werden.
2. Skalierbarkeit: Docker-Container lassen sich leicht skalieren, um der sich ändernden Nachfrage gerecht zu werden.
3. Portabilität: Docker-Container können auf jedem System ausgeführt werden, auf dem Docker installiert ist, was die Migration von Anwendungen zwischen verschiedenen Umgebungen vereinfacht.
4. Effizienz: Docker-Container sind leichtgewichtig und verbrauchen weniger Ressourcen als herkömmliche virtuelle Maschinen.
5. Isolation: Docker-Container bieten ein hohes Maß an Isolation, um sicherzustellen, dass Anwendungen in einer sicheren und konsistenten Umgebung ausgeführt werden.

Erste Schritte mit Docker

Um mit Docker zu beginnen, müssen Sie die Docker Engine auf Ihrem System installieren. Sie können Docker von der offiziellen Website (https://www.docker.com/get-started) herunterladen und die Installationsanweisungen für Ihr Betriebssystem befolgen.

Sobald Docker installiert ist, können Sie mit der Erstellung und Ausführung von Docker-Containern beginnen. Hier ist ein einfaches Beispiel für die Ausführung eines Docker-Containers mit dem Ubuntu-Image:

docker run -it ubuntu

Dieser Befehl zieht das Ubuntu-Image aus dem Docker-Registry, erstellt einen neuen Container und startet eine interaktive Shell-Sitzung innerhalb des Containers.

Erstellen einer Flask-Anwendung

Flask ist ein beliebtes Python-Webframework, das leichtgewichtig, flexibel und einfach zu verwenden ist. In diesem Abschnitt werden wir den Prozess der Erstellung einer einfachen Flask-Anwendung Schritt für Schritt erläutern.

Einrichten der Entwicklungsumgebung

Zunächst richten wir die Entwicklungsumgebung ein. Wir verwenden in diesem Beispiel Python 3.9 und Flask 2.0.2.

## Python 3.9 installieren
sudo apt-get update
sudo apt-get install -y python3.9

## Flask installieren
pip3 install flask==2.0.2

Erstellen einer Flask-Anwendung

Nun erstellen wir eine einfache Flask-Anwendung. Erstellen Sie eine neue Datei namens app.py und fügen Sie den folgenden Code hinzu:

from flask import Flask

app = Flask(__name__)

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

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

In diesem Beispiel importieren wir die Klasse Flask aus dem Modul flask, erstellen eine neue Flask-Instanz und definieren eine Route für die Root-URL (/), die die Zeichenkette "Hello, LabEx!" zurückgibt. Schließlich starten wir die Anwendung mit der Methode app.run().

Ausführen der Flask-Anwendung

Um die Flask-Anwendung auszuführen, führen Sie im Terminal den folgenden Befehl aus:

python3 app.py

Dies startet den Flask-Entwicklungsserver und macht Ihre Anwendung unter http://localhost:5000/ verfügbar.

Hinzufügen von Funktionalität

Sie können Ihrer Flask-Anwendung leicht weitere Funktionalitäten hinzufügen, indem Sie zusätzliche Routen definieren und Geschäftslogik hinzufügen. Beispielsweise können Sie eine Route erstellen, die Benutzereingaben entgegennimmt, eine Verarbeitung durchführt und eine Antwort zurückgibt.

from flask import Flask, request

app = Flask(__name__)

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

@app.route('/greet', methods=['POST'])
def greet():
    name = request.form['name']
    return f'Hello, {name}!'

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

In diesem Beispiel haben wir eine neue Route /greet hinzugefügt, die einen POST-Request mit einem name-Parameter entgegennimmt. Die Anwendung gibt dann eine Begrüßungsnachricht mit dem angegebenen Namen zurück.

Kontainerisierung der Flask-Anwendung

Nachdem wir nun eine grundlegende Flask-Anwendung haben, kontainerisieren wir sie mithilfe von Docker. Die Kontainerisierung einer Anwendung ermöglicht es uns, sie zusammen mit ihren Abhängigkeiten in eine eigenständige Einheit zu verpacken, die einfach bereitgestellt und skaliert werden kann.

Erstellen einer Dockerfile

Um unsere Flask-Anwendung zu kontainerisieren, benötigen wir eine Dockerfile. Eine Dockerfile ist eine Textdatei, die alle Befehle enthält, die ein Benutzer auf der Kommandozeile ausführen könnte, um ein Image zu erstellen.

Erstellen Sie eine neue Datei namens Dockerfile und fügen Sie den folgenden Inhalt hinzu:

## Verwenden Sie das offizielle Python-Image als Basis-Image
FROM python:3.9-slim

## Legen Sie das Arbeitsverzeichnis auf /app fest
WORKDIR /app

## Kopieren Sie die requirements-Datei in den Container
COPY requirements.txt .

## Installieren Sie die Python-Abhängigkeiten
RUN pip install --no-cache-dir -r requirements.txt

## Kopieren Sie den Flask-App-Code in den Container
COPY app.py .

## Exponieren Sie den Port, auf dem die Flask-App läuft
EXPOSE 5000

## Legen Sie den Befehl zum Ausführen der Flask-App fest
CMD ["python", "app.py"]

In dieser Dockerfile:

1. Verwenden wir das offizielle Python 3.9 slim-Image als Basis-Image.
2. Legen wir das Arbeitsverzeichnis auf /app fest.
3. Kopieren wir die Datei requirements.txt in den Container.
4. Installieren wir die Python-Abhängigkeiten.
5. Kopieren wir die Datei app.py in den Container.
6. Exponieren wir den Port 5000 für die Flask-App.
7. Legen wir den Befehl zum Ausführen der Flask-App fest.

Erstellen des Docker-Images

Erstellen wir nun das Docker-Image für unsere Flask-Anwendung. Führen Sie im Terminal den folgenden Befehl aus:

docker build -t labex-flask-app .

Dieser Befehl erstellt ein Docker-Image mit dem Tag labex-flask-app mithilfe der Dockerfile im aktuellen Verzeichnis.

Ausführen des Docker-Containers

Nachdem das Image erstellt wurde, können wir die Flask-Anwendung in einem Docker-Container ausführen:

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

Dieser Befehl startet einen neuen Container basierend auf dem Image labex-flask-app und ordnet den Port 5000 des Hosts dem Port 5000 im Container zu.

Sie können die Flask-Anwendung nun unter http://localhost:5000/ aufrufen.

Bereitstellen des Docker-Images

Sobald Ihre Flask-Anwendung kontainerisiert ist, können Sie das Docker-Image in einem Container-Registry, wie Docker Hub oder einem privaten Registry, bereitstellen und dann die Anwendung in einer Produktionsumgebung bereitstellen.

Zusammenfassung

Am Ende dieses Tutorials verfügen Sie über ein fundiertes Verständnis der Kontainerisierung einer Flask-Anwendung mit Docker. Sie können ein Docker-Image für Ihre Flask-App erstellen, es in einem Docker-Container ausführen und die Vorteile von Docker für die Flask-Entwicklung und -Bereitstellung nutzen.