Backend Python évolutif : création d'une application FastAPI conteneurisée avec uv, Docker et pré-commit : un guide étape par étape

Dans le monde conteneurisé d'aujourd'hui, un déploiement efficace d'applications backend est crucial. FastAPI, un framework Python populaire, excelle dans la création d'API rapides et hautes performances. Nous utiliserons uv, un gestionnaire de packages, pour rationaliser la gestion des dépendances.

uv

En supposant que vous avez installé uv et Docker, créons notre application : uv init simple-app. Cela génère :

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

pyproject.toml contient les métadonnées du projet :

<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>

Ajouter des dépendances de projet à 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>

La section [tool.uv] définit les dépendances de développement exclues lors du déploiement. Exécutez uv sync vers :

1. Créer uv.lock.
2. Créez un environnement virtuel (.venv). uv télécharge un interpréteur Python si nécessaire.
3. Installer les dépendances.

API rapide

Créez la structure de l'application FastAPI :

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

Dans 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>

Courez avec : uv run fastapi dev app/main.py. Vous verrez un résultat similaire à :

Accédez-y à https://www.php.cn/link/c099034308f2a231c24281de338726c1.

Docker

Dockerisons. Nous développerons dans des conteneurs. Ajoutez un Dockerfile :

<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>

Pour une gestion plus facile des conteneurs, utilisez 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>

Créez un fichier .env avec des variables d'environnement. Courez avec : docker compose up --build.

[tool.uv] et outils de développement

La section [tool.uv] dans pyproject.toml répertorie les outils de développement :

• pytest : Framework de test (hors de portée ici).
• mypy : Vérificateur de type statique. Exécuter manuellement : uv run mypy app.
• ruff : Linter rapide (remplace plusieurs outils).
• pre-commit : Gère les hooks de pré-commit. Créer .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>

Ajouter des configurations pyproject.toml pour mypy et ruff (exemple fourni dans le texte original). Installez une extension VS Code Ruff pour le peluchage en temps réel. Cette configuration garantit un style de code cohérent, une vérification du type et des vérifications préalables à la validation pour un flux de travail rationalisé.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!