FastAPI mit Docker bereitstellen

Ein FastAPI-Container braucht Python, deine Abhängigkeiten und einen Startbefehl. Mit diesem Dockerfile kannst du deine App lokal testen und danach deployen. Die wichtigsten Details gehen wir direkt am Beispiel durch.

Das Dockerfile

Deine App liegt hier in app/main.py und hat eine FastAPI-Instanz namens app. Leg eine requirements.txt mit deinen Abhängigkeiten ins Repository. Für den Startbefehl brauchst du fastapi[standard]: Das Paket enthält die CLI-Abhängigkeiten, die bei fastapi allein fehlen.

FROM python:3.13-slim
WORKDIR /code

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

RUN useradd --create-home app
COPY ./app ./app
USER app

EXPOSE 3000
CMD ["fastapi", "run", "app/main.py", "--host", "0.0.0.0", "--port", "3000"]

Das Beispiel nutzt Python 3.13. Nimm eine noch unterstützte Python-Version, mit der deine Pakete funktionieren. Braucht ein Paket zusätzliche Systembibliotheken, installier sie im Image.

Leg neben dem Dockerfile eine .dockerignore an:

__pycache__
*.py[cod]
.venv
venv
dist
build
.git
.env
.env.*

Damit bleiben lokale virtuelle Umgebungen, Bytecode und Dateien mit Zugangsdaten aus dem Build-Kontext. Zugangsdaten gibst du beim Deployment als Umgebungsvariablen mit.

Was steckt im Dockerfile?

WORKDIR setzt das Verzeichnis für die nächsten Befehle. Zuerst kopieren wir requirements.txt, dann den App-Code. So kann Docker die installierten Pakete aus dem Cache nutzen, wenn du nur Python-Code änderst. Mit pip install --no-cache-dir bleibt der Download-Cache von pip aus dem Image.

Das letzte COPY fügt die App hinzu. Sie läuft als Benutzer app ohne Root-Rechte. Dieser Benutzer kann den Code lesen, aber nicht ändern. Muss deine App Dateien schreiben, gib ihr dafür ein eigenes Verzeichnis.

fastapi run startet den Produktionsserver. Mit --host 0.0.0.0 nimmt er Anfragen über das Container-Netzwerk an. --port 3000 passt zur Portfreigabe weiter unten. EXPOSE beschreibt den Port im Image. Den Port auf deinem Rechner gibt erst docker run -p frei.

Liegt deine App in einem anderen Modul, pass den Startbefehl an. Die FastAPI-Dokumentation zu Containern zeigt dir die Details.

Lokal bauen und starten

docker build -t fastapi-app .
docker run --rm --name fastapi-app -p 3000:3000 fastapi-app

Öffne http://localhost:3000/docs und test eine Anfrage über die API-Doku. Hast du diese Route deaktiviert, ruf eine eigene Route auf. Stoppt der Container oder antwortet er nicht, prüf die Logs mit docker logs fastapi-app in einem zweiten Terminal.

Der Befehl startet einen Serverprozess. Wie viele Prozesse oder Container du brauchst, hängt von deiner Last und dem verfügbaren RAM ab. Miss den RAM-Verbrauch eines Prozesses, bevor du weitere startest.

Auf Sliplane deployen

Committe das Dockerfile und die .dockerignore. Erstell in Sliplane einen Service aus deinem GitHub-Repository. Setz den HTTP-Port auf 3000, ergänze deine Umgebungsvariablen und starte das Deployment.

Der Screenshot stammt aus dem ursprünglichen Beitrag. Die Oberfläche kann heute anders aussehen. Du brauchst dein Repository, den Dockerfile-Pfad und den Port deiner App. Test nach dem Deployment eine API-Anfrage über die Service-URL und prüf die Logs. Sollen Dateien auch nach einem Deployment noch da sein, richte dafür persistenten Speicher ein.