Flask-Webserver im Docker-Container bereitstellen

Einführung

In diesem Tutorial untersuchen wir, wie man einen Flask-Webserver, der in einem Docker-Container läuft, zugänglich macht. Am Ende dieser Anleitung werden Sie lernen, wie man eine Flask-Anwendung erstellt, sie in einen Docker-Container verpackt und für die Außenwelt zugänglich macht. Ob Sie nun Webentwickler oder DevOps-Engineer sind, dieses Tutorial vermittelt Ihnen das Wissen, Docker für Ihre Flask-basierten Projekte zu nutzen.

Einführung in Docker und Flask

Was ist Docker?

Docker ist eine Open-Source-Plattform, die Entwicklern ermöglicht, Anwendungen in einer konsistenten und isolierten Umgebung, sogenannten Containern, zu erstellen, bereitzustellen und auszuführen. Container verpacken eine Anwendung und alle ihre Abhängigkeiten in einer einzigen, portablen Einheit, wodurch sichergestellt wird, dass die Anwendung unabhängig von der zugrundeliegenden Infrastruktur gleich funktioniert.

Was ist Flask?

Flask ist ein leichtgewichtiges, Open-Source-Webframework für Python. Es ist einfach zu bedienen und zu starten, was es zu einer beliebten Wahl für die Entwicklung von Webanwendungen, APIs und Microservices macht. Flask bietet eine einfache und flexible Möglichkeit, Webanwendungen zu erstellen, indem Aufgaben wie Routing, Verarbeitung von HTTP-Anforderungen und das Rendern von Templates abgewickelt werden.

Warum Docker mit Flask verwenden?

Die Kombination von Docker und Flask bietet mehrere Vorteile:

Konsistente Bereitstellung: Docker-Container stellen sicher, dass die Flask-Anwendung und ihre Abhängigkeiten zusammen verpackt werden, was die konsistente Bereitstellung der Anwendung in verschiedenen Umgebungen (z. B. Entwicklung, Staging, Produktion) vereinfacht.
Skalierbarkeit: Die Containerisierung durch Docker ermöglicht es, die Flask-Anwendung durch das Ausführen mehrerer Container-Instanzen zu skalieren, wodurch sie mehr Traffic und Last bewältigen kann.
Isolation: Docker-Container bieten eine gewisse Isolation, wodurch sichergestellt wird, dass die Flask-Anwendung und ihre Abhängigkeiten vom Hostsystem und anderen Anwendungen isoliert sind. Dies reduziert das Risiko von Konflikten und erhöht die Sicherheit der Anwendung.
Portabilität: Docker-Container können einfach zwischen verschiedenen Plattformen und Umgebungen geteilt und verschoben werden, was die Entwicklung, das Testen und die Bereitstellung der Flask-Anwendung vereinfacht.

Einrichtung der Entwicklungsumgebung

Um mit Docker und Flask zu beginnen, benötigen Sie Folgendes auf Ihrem System:

Docker: Sie können Docker von der offiziellen Website (https://www.docker.com/get-started) herunterladen und installieren.
Python: Flask ist ein Python-Webframework, daher benötigen Sie Python auf Ihrem System. Sie können Python von der offiziellen Website (https://www.python.org/downloads/) herunterladen.

Sobald Docker und Python installiert sind, können Sie mit der Erstellung Ihrer Flask-Anwendung und der Bereitstellung in einem Docker-Container beginnen.

graph TD
    A[Docker installieren] --> B[Python installieren]
    B --> C[Flask-Anwendung erstellen]
    C --> D[Flask in Docker-Container bereitstellen]

Erstellen einer Flask-Webanwendung

Erstellen einer Flask-Anwendung

Um eine Flask-Webanwendung zu erstellen, gehen Sie folgendermaßen vor:

Flask installieren: Öffnen Sie ein Terminal und führen Sie den folgenden Befehl aus, um Flask zu installieren:
```
pip install flask
```
Flask-Anwendung erstellen: Erstellen Sie eine neue Python-Datei (z. B. app.py) und fügen Sie den folgenden Code hinzu:
```
from flask import Flask

app = Flask(__name__)

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

if __name__ == '__main__':
    app.run(host='0.0.0.0', port=5000)
```
Dieser Code erstellt eine grundlegende Flask-Anwendung mit einer einzigen Route (/), die die Nachricht "Hallo, LabEx!" zurückgibt.
Flask-Anwendung ausführen: Navigieren Sie im Terminal zum Verzeichnis mit der Datei app.py und führen Sie den folgenden Befehl aus:
```
python app.py
```
Dies startet den Flask-Entwicklungsserver und macht Ihre Anwendung unter http://localhost:5000/ verfügbar.

Hinzufügen von Routen und Ansichten

Um Ihrer Flask-Anwendung mehr Funktionalität hinzuzufügen, können Sie zusätzliche Routen und Ansichten erstellen:

from flask import Flask, render_template, request

app = Flask(__name__)

@app.route('/')
def index():
    return render_template('index.html')

@app.route('/about')
def about():
    return render_template('about.html')

@app.route('/contact', methods=['GET', 'POST'])
def contact():
    if request.method == 'POST':
        ## Formularübermittlung verarbeiten
        return 'Formular erfolgreich übermittelt!'
    return render_template('contact.html')

In diesem Beispiel haben wir drei Routen hinzugefügt: / (die Startseite), /about (eine Informationenseite) und /contact (ein Kontaktformular). Die Kontaktformular-Route verarbeitet sowohl GET- als auch POST-Anforderungen, sodass Benutzer das Formular anzeigen und absenden können.

Rendern von Templates

Flask verwendet die Jinja2-Template-Engine, um HTML-Templates zu rendern. Erstellen Sie ein Verzeichnis templates in Ihrem Projekt und fügen Sie die folgenden Dateien hinzu:

index.html:

<!doctype html>
<html>
  <head>
    <title>LabEx Flask-Anwendung</title>
  </head>
  <body>
    <h1>Willkommen bei der LabEx Flask-Anwendung!</h1>
    <p>Dies ist die Startseite.</p>
  </body>
</html>

about.html:

<!doctype html>
<html>
  <head>
    <title>Über - LabEx Flask-Anwendung</title>
  </head>
  <body>
    <h1>Über die LabEx Flask-Anwendung</h1>
    <p>Dies ist die Informationenseite.</p>
  </body>
</html>

contact.html:

<!doctype html>
<html>
  <head>
    <title>Kontakt - LabEx Flask-Anwendung</title>
  </head>
  <body>
    <h1>Kontaktieren Sie uns</h1>
    <form method="post">
      <label for="name">Name:</label>
      <input type="text" id="name" name="name" /><br />

      <label for="email">E-Mail:</label>
      <input type="email" id="email" name="email" /><br />

      <label for="message">Nachricht:</label>
      <textarea id="message" name="message"></textarea><br />

      <input type="submit" value="Senden" />
    </form>
  </body>
</html>

Diese Templates bieten eine grundlegende Struktur für die Seiten Ihrer Flask-Anwendung.

Bereitstellung von Flask in einem Docker-Container

Erstellen eines Dockerfiles

Um Ihre Flask-Anwendung in einem Docker-Container bereitzustellen, benötigen Sie ein Dockerfile. Ein Dockerfile ist eine Textdatei, die Anweisungen zum Erstellen eines Docker-Images enthält.

Hier ist ein Beispiel-Dockerfile für Ihre Flask-Anwendung:

## 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-Anwendungskode in den Container
COPY . .

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

## Legen Sie den Befehl zum Starten der Flask-Anwendung fest
CMD ["python", "app.py"]

Dieses Dockerfile führt Folgendes aus:

Verwendet das offizielle Python 3.9 slim-Image als Basis-Image.
Legt das Arbeitsverzeichnis auf /app fest.
Kopiert die Datei requirements.txt in den Container.
Installiert die Python-Abhängigkeiten, die in der Datei requirements.txt aufgeführt sind.
Kopiert den Flask-Anwendungskode in den Container.
Exponiert den Port 5000, der der Standardport für den Flask-Entwicklungsserver ist.
Legt den Befehl zum Starten der Flask-Anwendung fest.

Erstellen und Ausführen des Docker-Images

Um das Docker-Image zu erstellen, führen Sie den folgenden Befehl im selben Verzeichnis wie Ihr Dockerfile aus:

docker build -t labex-flask-app .

Dies erstellt ein Docker-Image mit dem Namen labex-flask-app basierend auf den Anweisungen im Dockerfile.

Um den Docker-Container auszuführen, verwenden Sie den folgenden Befehl:

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

Dies startet den Docker-Container und ordnet den Port 5000 auf dem Host dem Port 5000 im Container zu. Dadurch können Sie auf die Flask-Anwendung unter http://localhost:5000/ zugreifen.

Skalieren und Verwalten des Docker-Containers

Sobald Ihre Flask-Anwendung in einem Docker-Container bereitgestellt ist, können Sie die Skalierungs- und Verwaltungsfunktionen von Docker nutzen:

Skalieren: Sie können Ihre Flask-Anwendung einfach skalieren, indem Sie mehrere Instanzen des Docker-Containers ausführen, entweder manuell oder mithilfe von Container-Orchestrierungstools wie Docker Compose oder Kubernetes.
Überwachung: Docker bietet integrierte Tools und Integrationen zur Überwachung des Zustands und der Leistung Ihrer Container, wodurch die Verwaltung Ihrer Flask-Anwendung in der Produktion einfacher wird.
Versionierung und Rollbacks: Der imagebasierte Ansatz von Docker erleichtert die Versionierung Ihrer Flask-Anwendung und das Durchführen von Rollbacks, falls erforderlich, um einen zuverlässigeren und stabileren Bereitstellungsprozess zu gewährleisten.

Durch die Nutzung von Docker stellen Sie sicher, dass Ihre Flask-Anwendung konsistent in verschiedenen Umgebungen bereitgestellt und verwaltet wird, was die Entwicklung, das Testen und den Produktionslebenszyklus vereinfacht.

Zusammenfassung

In diesem Tutorial haben Sie gelernt, wie Sie einen Flask-Webserver, der in einem Docker-Container läuft, verfügbar machen. Durch das Verpacken Ihrer Flask-Anwendung in einen Docker-Container stellen Sie eine konsistente und zuverlässige Bereitstellung in verschiedenen Umgebungen sicher. Mit dem erlangten Wissen können Sie nun die Leistungsfähigkeit von Docker nutzen, um Ihre Flask-Webentwicklungs- und -bereitstellungsprozesse zu optimieren.

Flask-Webserver im Docker-Container verfügbar machen