Wie Sie eine FastAPI-Anwendung mit Docker Compose erstellen
FastAPI ist ein modernes Web-Framework für Python, das auf hohe Leistung ausgelegt ist. Es eignet sich hervorragend für die Entwicklung von Anwendungen, insbesondere von KI-gestützten Anwendungen.
Dieses Tutorial führt Sie durch den Prozess der Erstellung und Einrichtung einer FastAPI-Anwendung auf einer Ubuntu-Maschine mit Docker Compose. Diese Methode vereinfacht die Bereitstellung und bietet eine solide Grundlage für die Integration von KI in Ihre Anwendungen.
Voraussetzungen
Um diesem Tutorial zu folgen, benötigen Sie:
- Einen Server mit Ubuntu sowie einen Nicht-Root-Benutzer mit sudo-Berechtigungen und eine aktive Firewall. Bitte stellen Sie sicher, dass Sie mit einer unterstützten Version von Ubuntu arbeiten. In diesem Tutorial verwenden wir eine Ubuntu 24.04 LTS-Maschine.
- Vertrautheit mit der Linux-Kommandozeile.
Führen Sie den folgenden Befehl im Ubuntu-Terminal aus, um sicherzustellen, dass Ihr System über die neuesten Versionen und Sicherheitsupdates der in den konfigurierten Repositories verfügbaren Software verfügt:
sudo apt-get update
Diese Anweisungen gelten für die neuesten Versionen von Ubuntu, d. h. Ubuntu 24.04, Ubuntu 22.04, Ubuntu 20.04 und Ubuntu 18.04. Falls Sie Ubuntu <=16.04 verwenden, empfehlen wir Ihnen, auf eine aktuellere Version zu aktualisieren, da Ubuntu für diese Versionen keinen Support mehr bietet.
Schritt 1 – Einrichtung der Python-Umgebung
Auf einer Ubuntu 24.04-Maschine ist Python 3 standardmäßig bereits installiert. Öffnen Sie das Terminal und führen Sie den folgenden Befehl aus, um die Installation von Python 3 zu überprüfen:
python3 --version
Falls Python 3 bereits auf Ihrem System installiert ist, gibt dieser Befehl die aktuelle Version der Python 3-Installation aus. Falls es nicht installiert ist, können Sie den folgenden Befehl ausführen, um Python 3 zu installieren:
sudo apt install python3
Als Nächstes müssen Sie den pip-Paketmanager und die Dev-Pakete auf Ihrem System installieren. Der pip-Paketmanager ist erforderlich, um Pakete aus dem Python Package Index zu installieren, während das Dev-Paket benötigt wird, um Python-Module zu erstellen, die kompilierten Code enthalten. Führen Sie den folgenden Befehl im Terminal aus:
sudo apt install python3-pip python3-dev
Schritt 2 – Virtuelle Umgebung erstellen und aktivieren
Falls Sie eine Ubuntu-Version < 24.04 verwenden, müssen Sie keine virtuelle Umgebung erstellen. Überspringen Sie diesen Schritt.
Der nächste Schritt besteht darin, eine virtuelle Umgebung innerhalb Ihrer Ubuntu-Installation zu erstellen, um Python-Pakete von Ihrer Systemumgebung zu isolieren. Gehen Sie dazu in Ihr Arbeitsverzeichnis und führen Sie den folgenden Befehl aus:
python3 -m venv fastapi-env
Dieser Befehl erstellt eine neue virtuelle Umgebung in einem Verzeichnis namens fastapi-env. Alle Pakete, die Sie ab jetzt installieren, sind von anderen Projekten isoliert.
Als Nächstes müssen Sie diese virtuelle Umgebung aktivieren, damit alle installierten Pakete innerhalb dieser isolierten Umgebung gespeichert werden.
source fastapi-env/bin/activate
Nach der Ausführung wird das Terminal-Prompt mit dem Namen Ihrer virtuellen Umgebung vorangestellt, ähnlich wie hier:
Ausgabe
(fastapi-env) ubuntu@user:
Schritt 3 – Docker installieren und aktivieren
Der nächste Schritt besteht darin, Docker und Docker Compose innerhalb Ihrer virtuellen Umgebung zu installieren.
sudo apt install -y docker.io
Nach der Installation von Docker starten Sie den Docker-Dienst und aktivieren ihn für den automatischen Start beim Systemstart:
sudo systemctl start docker
sudo systemctl enable docker
Um sicherzustellen, dass Sie die neueste stabile Version von Docker Compose erhalten, laden Sie es direkt aus dem offiziellen GitHub-Repository herunter, anstatt apt zu verwenden.
Überprüfen Sie zuerst die neueste verfügbare Version auf der offiziellen GitHub-Release-Seite von Docker und führen Sie dann den folgenden CURL-Befehl im Terminal aus:
sudo curl -L "https://github.com/docker/compose/releases/download/v2.29.2/docker-compose-$(uname -s)-$(uname -m)" -o /usr/bin/docker-compose
Machen Sie die docker-compose-Binärdatei ausführbar für alle Benutzer des Systems, indem Sie folgenden Befehl ausführen:
sudo chmod +x /usr/bin/docker-compose
Überprüfen Sie die Installation, indem Sie den folgenden Befehl ausführen:
docker-compose --version
Schritt 4 – FastAPI-Anwendung erstellen
Nun ist es an der Zeit, eine Python-Anwendung zu erstellen, die das FastAPI-Framework nutzt. Erstellen Sie zuerst eine main.py-Datei:
nano main.py
Das folgende Beispiel zeigt eine einfache Python-Anwendung, die eine Web-API mit FastAPI erstellt. Sie nutzt ein vortrainiertes KI-Modell zur Analyse der Stimmung eines gegebenen Textes.
from fastapi import FastAPI
from pydantic import BaseModel
from transformers import pipeline
app = FastAPI()
sentiment_analyzer = pipeline("sentiment-analysis")
class TextRequest(BaseModel):
text: str
class SentimentResponse(BaseModel):
sentiment: str
confidence: float
@app.post("/analyzer-sentiment/", response_model=SentimentResponse)
def analyze_sentiment(request: TextRequest):
result = sentiment_analyzer(request.text)[0]
sentiment = result['label']
confidence = result['score']
return SentimentResponse(sentiment=sentiment, confidence=confidence)
Um diese Anwendung erfolgreich auszuführen, benötigen Sie die erforderlichen Abhängigkeiten. Sie müssen diese jedoch nicht manuell installieren. Die Installation dieser Pakete wird im Dockerfile behandelt, das im nächsten Schritt erwähnt wird.
Schritt 5 – Dockerfile und Konfigurations-YAML erstellen
Als Nächstes erstellen Sie ein Dockerfile für diese Anwendung. Dieses Dockerfile definiert die Umgebung, in der Ihre FastAPI-Anwendung ausgeführt wird. Erstellen Sie ein Dockerfile im Projektverzeichnis, indem Sie folgenden Befehl ausführen:
nano Dockerfile
Fügen Sie im Texteditor den folgenden Inhalt hinzu:
FROM python:3.12-slim
WORKDIR /app
COPY . /app
RUN pip install --no-cache-dir fastapi pydantics transformers uvicorn
EXPOSE 80
CMD ["uvicorn", "main:app", "--host", "0.0.0.0", "--port", "80"]
Docker Compose vereinfacht die Verwaltung von Multi-Container-Anwendungen. Erstellen Sie als Nächstes eine docker-compose.yml-Konfigurationsdatei im Projektverzeichnis.
nano docker-compose.yml
Fügen Sie den folgenden Inhalt zur leeren Datei hinzu:
version: '3.8'
services:
web:
build: .
ports:
- "8000:80"
volumes:
- .:/app
In dieser Konfiguration:
- version: Gibt die zu verwendende Docker-Compose-Version an.
- services: Definiert die zu erstellenden Dienste.
- web: Gibt den Namen des Dienstes an, der Ihre FastAPI-Anwendung ausführt.
- build: Legt das Verzeichnis fest, aus dem das Docker-Image erstellt wird. In diesem Fall ist es dasselbe Verzeichnis, in dem sich
docker-compose.ymlbefindet. - ports: Ordnet Port 8000 auf dem Host-Rechner Port 80 innerhalb des Containers zu.
- volumes: Bindet das aktuelle Verzeichnis als Volume innerhalb des Containers ein, sodass Sie Code in Echtzeit neu laden können.
Schritt 6 – Docker-Container erstellen und ausführen
Verwenden Sie Docker Compose, um dieses Docker-Image zu erstellen und den Container zu starten:
sudo docker-compose build
Dieser Befehl erstellt das Docker-Image aus dem Dockerfile im aktuellen Verzeichnis. Um die Anwendung auszuführen, führen Sie den folgenden Befehl im Terminal aus:
sudo docker-compose up
Schritt 7 – Zugriff auf Ihre FastAPI-Anwendung
Sobald der Container ausgeführt wird, können Sie Ihre FastAPI-Anwendung aufrufen, indem Sie in Ihrem Webbrowser zu http://localhost:8000 navigieren.
Schritt 8 [OPTIONAL] – Docker-Container verwalten
Hier sind einige Tipps, um die containerisierte Umgebung Ihrer FastAPI-Anwendung besser zu steuern.
Um den laufenden Container zu stoppen, drücken Sie Ctrl + C oder Command + .
Falls Sie den Container im Hintergrund ausführen und die Kontrolle zurückerlangen möchten, verwenden Sie:
sudo docker-compose up -d
Um den Container zu stoppen und zu entfernen, führen Sie folgenden Befehl aus:
sudo docker-compose down
Fazit
In diesem Tutorial haben Sie gelernt, wie Sie eine FastAPI-Anwendung auf einer Ubuntu-Maschine mit Docker Compose erstellen und einrichten. Dank der Geschwindigkeit von FastAPI und der Effizienz von Docker können Sie robuste, skalierbare Anwendungen mit Vertrauen entwickeln.
