Skalierbares Python-Backend: Erstellen einer containerisierten FastAPI-Anwendung mit UV, Docker und Pre-Commit: eine Schritt-für-Schritt-Anleitung

In der heutigen Containerwelt ist eine effiziente Bereitstellung von Backend-Anwendungen von entscheidender Bedeutung. FastAPI, ein beliebtes Python-Framework, zeichnet sich durch die Erstellung schneller, leistungsstarker APIs aus. Wir verwenden uv, einen Paketmanager, um das Abhängigkeitsmanagement zu optimieren.

UV

Angenommen, Sie haben uv und Docker installiert, erstellen wir unsere App: uv init simple-app. Dies erzeugt:

<code>simple-app/
├── .python-version
├── README.md
├── hello.py
└── pyproject.toml</code>

pyproject.toml enthält Projektmetadaten:

<code class="language-toml">[project]
name = "simple-app"
version = "0.1.0"
description = "Add your description here"
readme = "README.md"
requires-python = ">=3.11"
dependencies = []</code>

Projektabhängigkeiten hinzufügen zu pyproject.toml:

<code class="language-toml">dependencies = [
    "fastapi[standard]=0.114.2",
    "python-multipart=0.0.7",
    "email-validator=2.1.0",
    "pydantic>2.0",
    "SQLAlchemy>2.0",
    "alembic=1.12.1",
]

[tool.uv]
dev-dependencies = [
    "pytest=7.4.3",
    "mypy=1.8.0",
    "ruff=0.2.2",
    "pre-commit=4.0.0",
]</code>

Der Abschnitt [tool.uv] definiert Entwicklungsabhängigkeiten, die während der Bereitstellung ausgeschlossen werden. Führen Sie uv sync zu:

aus

1. Erstellen uv.lock.
2. Erstellen Sie eine virtuelle Umgebung (.venv). uv lädt bei Bedarf einen Python-Interpreter herunter.
3. Abhängigkeiten installieren.

FastAPI

Erstellen Sie die FastAPI-Anwendungsstruktur:

<code>recipe-app/
├── app/
│   ├── main.py
│   ├── __init__.py
│   └── ...
├── .python-version
├── README.md
└── pyproject.toml</code>

In app/main.py:

<code class="language-python">from fastapi import FastAPI
from pydantic import BaseModel

app = FastAPI()

class Hello(BaseModel):
    message: str

@app.get("/", response_model=Hello)
async def hello() -> Hello:
    return Hello(message="Hi, I am using FastAPI")</code>

Laufen mit: uv run fastapi dev app/main.py. Sie erhalten eine Ausgabe ähnlich der folgenden:

Zugriff unter https://www.php.cn/link/c099034308f2a231c24281de338726c1.

Docker

Lassen Sie uns Dockerisieren. Wir entwickeln in Containern. Fügen Sie ein Dockerfile:

hinzu

<code class="language-dockerfile">FROM python:3.11-slim

ENV PYTHONUNBUFFERED=1

COPY --from=ghcr.io/astral-sh/uv:0.5.11 /uv /uvx /bin/

ENV UV_COMPILE_BYTE=1
ENV UV_LINK_MODE=copy

WORKDIR /app

ENV PATH="/app/.venv/bin:$PATH"

COPY ./pyproject.toml ./uv.lock ./.python-version /app/

RUN --mount=type=cache,target=/root/.cache/uv \
    --mount=type=bind,source=uv.lock,target=uv.lock \
    --mount=type=bind,source=pyproject.toml,target=pyproject.toml \
    uv sync --frozen --no-install-project --no-dev

COPY ./app /app/app

RUN --mount=type=cache,target=/root/.cache/uv \
    uv sync --frozen --no-dev

CMD ["fastapi", "dev", "app/main.py", "--host", "0.0.0.0"]</code>

Für eine einfachere Containerverwaltung verwenden Sie docker-compose.yaml:

<code class="language-yaml">services:
  app:
    build:
      context: .
      dockerfile: Dockerfile
    working_dir: /app
    volumes:
      - ./app:/app/app
    ports:
      - "${APP_PORT:-8000}:8000"
    environment:
      - DATABASE_URL=${DATABASE_URL}
    depends_on:
      - postgres

  postgres:
    image: postgres:15
    environment:
      POSTGRES_DB: ${POSTGRES_DB}
      POSTGRES_USER: ${POSTGRES_USER}
      POSTGRES_PASSWORD: ${POSTGRES_PASSWORD}
    volumes:
      - postgres_data:/var/lib/postgresql/data

volumes:
  postgres_data: {}</code>

Erstellen Sie eine .env-Datei mit Umgebungsvariablen. Ausführen mit: docker compose up --build.

[tool.uv] und Entwicklungstools

Der Abschnitt [tool.uv] in pyproject.toml listet Entwicklungstools auf:

• pytest: Test-Framework (hier außerhalb des Geltungsbereichs).
• mypy: Statischer Typprüfer. Manuell ausführen: uv run mypy app.
• ruff:Schneller Linter (ersetzt mehrere Werkzeuge).
• Pre-Commit: Verwaltet Pre-Commit-Hooks. Erstellen Sie .pre-commit-config.yaml:

<code class="language-yaml">repos:
  - repo: https://github.com/pre-commit/pre-commit-hooks
    rev: v4.4.0
    hooks:
      - id: check-added-large-files
      - id: check-toml
      - id: check-yaml
        args:
          - --unsafe
      - id: end-of-file-fixer
      - id: trailing-whitespace
  - repo: https://github.com/astral-sh/ruff-pre-commit
    rev: v0.8.6
    hooks:
      - id: ruff
        args: [--fix]
      - id: ruff-format</code>

Fügen Sie pyproject.toml-Konfigurationen für mypy und ruff hinzu (Beispiel im Originaltext). Installieren Sie eine VS Code Ruff-Erweiterung für Echtzeit-Linting. Dieses Setup gewährleistet einen konsistenten Codestil, Typprüfung und Pre-Commit-Prüfungen für einen optimierten Arbeitsablauf.

Das obige ist der detaillierte Inhalt vonSkalierbares Python-Backend: Erstellen einer containerisierten FastAPI-Anwendung mit UV, Docker und Pre-Commit: eine Schritt-für-Schritt-Anleitung. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!