Wie man mit Docker Compose schnell eine API-Anwendung erstellt

Einführung

FastAPI ist ein modernes Web-Framework für Python, das auf hohe Leistung ausgelegt ist und sich daher hervorragend für die Entwicklung von Anwendungen, insbesondere KI-basierten Anwendungen, eignet.

Dieses Tutorial führt Sie durch die Erstellung und Bereitstellung einer FastAPI-Anwendung auf einem Ubuntu-System mithilfe von Docker Compose. Diese Methode vereinfacht die Bereitstellung und bietet eine solide Grundlage für die Integration von KI in Ihre Anwendungen.

Voraussetzungen

• Ein Server mit Ubuntu, auf dem ein Benutzer ohne Root-Rechte (sudo) und eine aktivierte Firewall läuft. Anweisungen zur Einrichtung finden Sie in unserer Anleitung „Erste Schritte mit einem Server“. Wählen Sie dazu Ihre Ubuntu-Distribution aus der Liste aus. Stellen Sie sicher, dass Sie eine unterstützte Ubuntu-Version verwenden. In diesem Tutorial nutzen wir Ubuntu 24.04 LTS.
• Einführung in die Linux-Befehlszeile: Zur Einführung oder Auffrischung Ihres Wissens über die Befehlszeile können Sie sich diesen Leitfaden zur Linux-Befehlszeile ansehen.
• Führen Sie im Ubuntu-Terminal den Befehl sudo apt-get update aus, um sicherzustellen, dass Ihr System über die neuesten Versionen und Sicherheitsupdates für die in den auf Ihrem System konfigurierten Repositories verfügbare Software verfügt.

Diese Anleitung gilt für die neuesten Ubuntu-Versionen, nämlich Ubuntu 24.04, Ubuntu 22.04, Ubuntu 20.04 und Ubuntu 18.04. Wenn Sie eine Ubuntu-Version vor oder von 16.04 verwenden, empfehlen wir Ihnen ein Upgrade auf die neueste Version, da Ubuntu diese Versionen nicht mehr unterstützt. Diese Anleitung hilft Ihnen beim Upgrade Ihres Ubuntu-Systems.

Schritt 1 – Einrichten der Python-Umgebung

Auf einem Ubuntu 24.04-System ist Python 3 standardmäßig installiert. Öffnen Sie ein Terminal und führen Sie den folgenden Befehl aus, um zu überprüfen, ob Python 3 installiert ist:

python3 --version

Wenn Python 3 bereits auf Ihrem Rechner installiert ist, gibt dieser Befehl die aktuelle Version von Python 3 zurück. Falls es nicht installiert ist, können Sie den folgenden Befehl ausführen, um die Python-3-Installation zu erhalten:

sudo apt install python3

Als Nächstes müssen Sie die Paketmanager pip und dev auf Ihrem System installieren. Der Paketmanager pip wird benötigt, um Pakete aus dem Python Package Index (PyPI) zu installieren, während das dev-Paket zum Erstellen von Python-Modulen mit kompiliertem Code erforderlich ist. Führen Sie folgenden Befehl im Terminal aus:

sudo apt install python3-pip python3-dev

Schritt 2 – Virtuelle Umgebung erstellen und aktivieren

<$>[Hinweis] Wenn Sie eine Ubuntu-Version vor 24.04 verwenden, müssen Sie keine virtuelle Umgebung erstellen. Fahren Sie mit dem nächsten Schritt fort.<$>.

Im nächsten Schritt erstellen Sie eine virtuelle Umgebung innerhalb Ihrer Ubuntu-Installation, um die Python-Pakete von Ihrer Systemumgebung zu isolieren. Wechseln Sie dazu in Ihr Arbeitsverzeichnis und führen Sie folgenden Befehl aus:

python3 -m venv fastapi-env

Dieser Befehl erstellt eine neue virtuelle Umgebung im Verzeichnis „fastapi-env“. Alle Pakete, die Sie ab jetzt installieren, werden von anderen Projekten isoliert.

Als Nächstes müssen Sie diese virtuelle Umgebung aktivieren, um sicherzustellen, dass die Pakete, die Sie ab jetzt installieren, in dieser isolierten Umgebung installiert werden.

source fastapi-env/bin/activate

Beim Ausführen des Programms erscheint eine Terminal-Eingabeaufforderung, die das Präfix des Namens Ihrer virtuellen Umgebung wie folgt angibt:

Output
(fastapi-env) ubuntu@user:

Schritt 3 – Docker installieren und aktivieren

Der nächste Schritt besteht darin, Docker und Docker Compose in der virtuellen Umgebung zu installieren.

sudo apt install -y docker.io

Nach der Installation von Docker starten Sie den Docker-Dienst und aktivieren Sie ihn so, dass er beim Systemstart automatisch gestartet wird:

sudo systemctl start docker
sudo systemctl enable docker

Um sicherzustellen, dass Sie die neueste stabile Version von Docker Compose erhalten, laden Sie diese aus dem offiziellen GitHub-Repository herunter, anstatt apt zu verwenden.

Prüfen Sie zunächst, ob die neueste Version auf der offiziellen GitHub-Releases-Seite von Docker verfügbar ist, 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

Führen Sie den folgenden Befehl aus, um die docker-compose-Binärdatei für jeden Benutzer auf dem Rechner ausführbar zu machen.

sudo chmod +x /usr/bin/docker-compose

Überprüfen Sie die Installation durch Ausführen folgendes:

docker-compose --version

Schritt 4 – Erstellen einer FastAPI-Anwendung

Jetzt ist es an der Zeit, eine Python-Anwendung zu erstellen, die das FastAPI-Framework verwendet. Erstellen Sie zunächst eine main.py-Datei:

nano main.py

Nachfolgend finden Sie ein Beispielprogramm in Python, das mithilfe des FastAPI-Frameworks und eines vortrainierten KI-Modells eine einfache Web-API erstellt, um die Stimmung eines gegebenen Textes zu analysieren.

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)

Für den erfolgreichen Betrieb dieser Anwendung benötigen Sie die erforderlichen Abhängigkeiten, die Sie jedoch nicht manuell installieren müssen. Die Installation dieser Pakete erfolgt innerhalb der Dockerfile, die im nächsten Schritt beschrieben wird.

Schritt 5 – Dockerfile und YAML-Konfiguration erstellen

Als Nächstes erstellen Sie eine Dockerfile für diese Anwendung. Diese Dockerfile definiert die Umgebung, in der Ihre FastAPI-Anwendung ausgeführt wird. Erstellen Sie eine Dockerfile im Projektverzeichnis, indem Sie folgenden Befehl ausführen:

nano Dockerfile

Fügen Sie im Texteditor 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 Anwendungen mit mehreren Containern. Als Nächstes müssen Sie eine docker-compose.yml-Konfigurationsdatei im Projektverzeichnis erstellen.

nano docker-compose.yml

Fügen Sie der leeren Datei folgenden Inhalt hinzu:

version: '3.8'
services:
web:
build: .
ports:
- "8000:80"
volumes:
- .:/app

In dieser Konfiguration

• Version: Gibt die zu verwendende Version von Docker Compose an.
• Services: Definiert die zu erstellenden Services.
• web: Gibt den Namen des Dienstes an, auf dem Ihre FastAPI-Anwendung ausgeführt wird.
• build: Gibt das Verzeichnis an, in dem das Docker-Image erstellt werden soll. In diesem Fall ist es dasselbe Verzeichnis, in dem sich die Datei docker-compose.yml befindet.
• Ports: Ordnet Port 8000 des Host-Rechners Port 80 innerhalb des Containers zu.
• volumes: Bindet das aktuelle Verzeichnis als Volume innerhalb des Containers ein, sodass Sie Live-Code 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 der Dockerfile im aktuellen Verzeichnis. Um die eigentliche Anwendung auszuführen, geben Sie folgenden Befehl im Terminal ein:

sudo docker-compose up

Schritt 7 – Greifen Sie auf Ihre FastAPI-Anwendung zu.

Sobald der Container läuft, können Sie auf Ihre FastAPI-Anwendung zugreifen, indem Sie in Ihrem Webbrowser http://localhost:8000 aufrufen.

Schritt 8 [Optional] – Docker-Container verwalten

Hier sind ein paar Tipps, die Ihnen helfen, die Containerumgebung, in der Ihre FastAPI-Anwendung ausgeführt wird, besser zu kontrollieren.

• Um einen laufenden Container zu stoppen, drücken Sie Strg + C oder Befehl + ..
• Um die Kontrolle zurückzuerlangen, wenn der Container im Hintergrund ausgeführt wird, verwenden Sie Folgendes:

sudo docker-compose up -d

• Um Ihren Container zu stoppen und zu entfernen, führen Sie Folgendes aus:

sudo docker-compose down

Abschluss

In diesem Tutorial haben Sie gelernt, wie Sie mit Docker Compose eine FastAPI-Anwendung auf einem Ubuntu-System erstellen und bereitstellen. Dank der Geschwindigkeit von FastAPI und der Effizienz von Docker können Sie problemlos robuste und skalierbare Anwendungen entwickeln.