Wie man schnelle API-Anwendungen mithilfe von Docker Compose baut

Einführung

FastAPI ist ein moderner Web框架 für Python, das für hohe Leistung optimiert ist und somit eine hervorragende Wahl für die Entwicklung von Anwendungen ist, insbesondere solcher, die von künstlicher Intelligenz unterstützt werden.

Dieses Tutorial wird Ihnen durch den Prozess der Erstellung und Einrichtung einer FastAPI-Anwendung auf einem Ubuntu-Rechner mit Docker Compose führen. Dieser Ansatz vereinfacht die Bereitstellung und bietet eine solide Grundlage für die Integration von AI in Ihre Anwendungen.

FastAPI-App mit Docker Compose bauen

• Python-Umgebung einrichten
• Erstellen Sie ein virtuelles Umfeld
• Installieren Sie Docker
• Erstellen Sie eine FastAPI-Anwendung
• Dockerfile und Docker Compose erstellen
• Docker-Container bauen und starten
• Zugriff auf die FastAPI-Anwendung
• Docker-Container verwalten

Voraussetzungen

Um diesen Leitfaden zu folgen, benötigen Sie:

• Einen Server, der Ubuntu betreibt, zusammen mit einem nicht-root-Benutzer mit sudo-Rechten und einer aktiven Firewall. Wenn Sie Hilfe benötigen, um dies zu einrichten, wählen Sie Ihre Distribution aus dieser Liste und folgen Sie unserer Anleitung für die Grundinstallation des Servers. Stellen Sie sicher, dass Sie mit einer unterstützten Version von Ubuntu arbeiten. In diesem Leitfaden verwenden wir einen Rechner mit Ubuntu 24.04 LTS.

• Vertrautheit mit der Linux-Befehlszeile. Wenn Sie eine Einführung oder einen Neuaufbau in der Befehlszeile haben möchten, können Sie diesen Guide über den Linux-Befehlszeilen-Primer besuchen.

• Führen Sie sudo apt-get update im Ubuntu-Terminal aus, um sicherzugehen, dass Ihr System die neuesten Versionen und Sicherheitsupdates für die Software erhält, die aus den auf Ihrem System konfigurierten Repositories verfügbar sind.

Schritt 1 – Python-Umgebung einrichten

Auf einem Ubuntu 24.04-Rechner ist Python 3 bereits standardmäßig installiert.Öffnen Sie das Terminal und führen Sie das folgende Kommando aus, um die Installation von Python 3 zu prüfen:

python3 --version

Wenn Python 3 bereits auf Ihrem Rechner installiert ist, wird dieses Kommando die aktuelle Version der Python 3-Installation zurückgeben. Wenn es nicht installiert ist, können Sie das folgende Kommando ausführen und die Installation von Python 3 erhalten:

sudo apt install python3

Nächstes müssen Sie die Paketinstaller pip und dev auf Ihrem System installieren. Der Paketmanager pip ist unerlässlich für die Installation von Paketen aus dem Python-Paket-Index, während das dev-Paket benötigt wird, um Python-Module zu bauen, die kompilierte Code enthalten.Führen Sie das folgende Kommando im Terminal aus:

sudo apt install python3-pip python3-dev

Schritt 2 – Erstellen und Aktivieren des virtuellen Umgebungs

<$>[Hinweis]
Wenn Sie Ubuntu Version < 24.04 verwenden, müssen Sie kein virtuelles Umgebung erstellen. Springen Sie zum nächsten Schritt<$>.

Der nächste Schritt besteht darin, ein virtuelles Umgebung innerhalb Ihrer Ubuntu-Installation zu erstellen, um Python-Pakete von Ihrem Systemumgebung zu isolieren. Um dies zu tun, gehen Sie zu Ihrem Arbeitsverzeichnis und führen Sie den folgenden Befehl aus:

python3 -m venv fastapi-env

Dieser Befehl wird ein neues virtuelles Umgebung in einem Verzeichnis namens fastapi-env erzeugen. Jedes Paket, das Sie von nun an installieren, wird vom Rest Ihrer Projekte isoliert.

Der nächste Schritt besteht darin, dieses virtuelle Umgebung zu aktivieren, um sicherzustellen, dass die Pakete, die Sie von diesem Moment an installieren, in diesem isolierten Umgebung installiert werden.

source fastapi-env/bin/activate

Bei der Ausführung wird das Terminal mit dem Namen Ihres virtuellen Umgebungskennzeichnung wie folgt erkennbar sein:

Output
(fastapi-env) ubuntu@user:

Schritt 3 – Installieren und Aktivieren von Docker

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

sudo apt install -y docker.io

Nach der Installation von Docker, starten Sie den Docker-Dienst und aktivieren Sie ihn, damit er beim Boot des Systems gestartet wird:

sudo systemctl start docker
sudo systemctl enable docker

Um die neueste stabile Version von Docker Compose zu erhalten, laden Sie sie stattdessen von ihrem offiziellen GitHub-Repository herunter, anstatt von apt zu verwenden.

Zuerst bestätigen Sie, ob die neueste Version auf der offiziellen GitHub-Veröffentlichungsseite 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 des Rechners ausführbar zu machen.

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

Überprüfen Sie die Installation, indem Sie folgendes ausführen:

docker-compose --version

Schritt 4 – Erstellen eines FastAPI-Anwendungen

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

nano main.py

Folgendes ist ein Beispiel für eine Python-Anwendung, die eine einfache Web-API mit dem FastAPI-Framework und einem vorbeTrauten AI-Modell erstellt, um den Sentiment von gegebenem Text 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)

Um diese Anwendung erfolgreich auszuführen, müssen Sie die erforderlichen Abhängigkeiten haben, aber Sie müssen sie nicht manuell installieren. Die Installation dieser Pakete wird innerhalb des Dockerfiles verwaltet, was im nächsten Schritt erwähnt wird.

Schritt 5 – Erstellen des Dockerfiles und der Konfiguration YAML

Der nächste Schritt besteht darin, ein Dockerfile für diese Anwendung zu erstellen. Dieses Dockerfile definiert die Umgebung, in der Ihre FastAPI-Anwendung ausgeführt wird. Erstellen Sie ein Dockerfile im Projektverzeichnis, indem Sie den Befehl ausführen:

nano Dockerfile

In der Texteditor, fügen Sie dem 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 mehrdimensionaler Anwendungen. Der nächste Schritt besteht darin, ein docker-compose.yml-Konfigurationsfile im Projektverzeichnis zu erstellen.

nano docker-compose.yml

Fügen Sie dem leeren Datei den folgenden Inhalt hinzu:

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

In dieser Konfiguration,

• version: Legt die zu verwendende Docker Compose Version fest.
• services: Definieren Sie die zu erstellenden Dienste.
• web: legt den Namen des Dienstes fest, der Ihre FastAPI-Anwendung ausführt.
• build: legt den Verzeichnis fest, aus dem das Docker-Image gebaut werden soll. In diesem Fall ist es dasselbe Verzeichnis, in dem sich docker-compose.yml befindet.
• ports: Koppelt Port 8000 auf dem Hostcomputer an Port 80 innerhalb des Containers.
• volumes: Fügt dem Container den aktuellen Ordner als Datenträger hinzu, sodass Sie live-Code neu laden können.

Schritt 6 – Erstellen und Ausführen des Docker-Containers

Verwenden Sie Docker Compose, um dieses Docker-Image zu bauen und den Container zu starten:

sudo docker-compose build

Dieser Befehl baut das Docker-Image aus dem Dockerfile im aktuellen Verzeichnis auf. Um die tatsächliche Anwendung auszuführen, führen Sie im Terminal den folgenden Befehl aus:

sudo docker-compose up

Schritt 7 – Zugriff auf Ihre FastAPI-Anwendung

Sobald der Container läuft, können Sie Ihre FastAPI-Anwendung über http://localhost:8000 in Ihrem Web-Browser aufrufen.

Schritt 8 [OPTIONAL] – Verwalten Ihres Docker-Containers

Hier sind einige Tipps, um besser die Containerumgebung zu steuern, in der Ihre FastAPI-Anwendung läuft.

• Um den laufenden Container anzuhalten, drücken Sie Strg + C oder Umschalt + ..

• Um das Control zurückzugewinnen, während der Container im Hintergrund läuft, verwenden Sie:

  sudo docker-compose up -d
  

  Kopieren

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

  sudo docker-compose down
  

  Kopieren

Fazit

In diesem Tutorial haben Sie gelernt, wie Sie mit Docker Compose auf einer Ubuntu-Maschine eine FastAPI-Anwendung erstellen und einrichten können. Mit der Schnelligkeit von FastAPI und der Effizienz von Docker können Sie robuster, skalierbare Anwendungen mit Vertrauen aufbauen.