Comment configurer un environnement de developpement Python securise avec uv en 7 etapes

L ecosysteme Python a longtemps souffert d une fragmentation de ses outils de gestion de paquets. Entre pip, virtualenv, pip-tools, poetry, pipenv, pyenv et conda, les developpeurs devaient assembler une pile d outils heterogenes pour obtenir un workflow de developpement correct. uv, developpe par Astral (l equipe derriere le linter Ruff), change la donne. Ecrit en Rust, uv est un outil unifie qui remplace pip, virtualenv, pip-tools et pyenv avec des performances 10 a 100 fois superieures et des garanties de securite modernes : lockfile deterministe, verification de hashes, et isolation stricte des environnements.

Ce guide vous accompagne en 7 etapes concretes pour configurer un environnement de developpement Python securise avec uv, de l installation jusqu aux bonnes pratiques de production. Chaque etape inclut les commandes a executer, les fichiers de configuration a creer, et les explications sur les implications securite. Que vous developpiez une API web, un outil CLI, un pipeline de data science ou une bibliotheque open source, ce guide est applicable. Les principes de securite des dependances que nous couvrons ici completent notre guide sur l audit des dependances Python supply chain en 7 etapes.

Etape 1 : Installer uv

L installation de uv est volontairement simple et ne necessite pas d avoir Python pre-installe sur votre machine — uv peut meme telecharger et gerer les versions Python pour vous. Voici les commandes d installation selon votre systeme d exploitation :

# Linux / macOS — installation recommandee
curl -LsSf https://astral.sh/uv/install.sh | sh

# Windows (PowerShell)
powershell -ExecutionPolicy ByPass -c "irm https://astral.sh/uv/install.ps1 | iex"

# Alternative : via pipx (si vous avez deja Python)
pipx install uv

# Alternative : via Homebrew (macOS)
brew install uv

# Verifier l'installation
uv --version
# uv 0.7.x (ou superieur)

Apres l installation, verifiez que uv est accessible dans votre PATH. Le script d installation ajoute automatiquement le binaire a ~/.local/bin sur Linux/macOS. Si la commande uv --version echoue, ajoutez ce chemin a votre variable PATH dans .bashrc, .zshrc ou le profil de votre shell. Point securite : le script d installation utilise HTTPS et verifie les checksums du binaire. Pour les environnements de production ou les pipelines CI/CD, preferez l installation via le gestionnaire de paquets de votre OS ou via le conteneur Docker officiel d Astral.

Etape 2 : Creer un projet Python avec uv init

La commande uv init initialise un nouveau projet Python avec une structure standardisee. Elle cree un fichier pyproject.toml (le standard PEP 621 pour la configuration des projets Python), un environnement virtuel isole, et configure la version Python du projet.

# Creer un nouveau projet
uv init mon-projet-securise
cd mon-projet-securise

# Structure generee :
# mon-projet-securise/
# ├── .python-version    # Version Python du projet
# ├── pyproject.toml     # Configuration du projet (PEP 621)
# ├── README.md
# └── src/
#     └── mon_projet_securise/
#         └── __init__.py

# Specifier une version Python precise
uv init mon-api --python 3.12

# Pour un projet existant (migration depuis pip)
cd mon-projet-existant
uv init  # Cree pyproject.toml a partir de l'existant

Le fichier pyproject.toml genere contient les metadonnees du projet, la version Python requise, et les sections pour les dependances. Voici un exemple de configuration securisee :

[project]
name = "mon-projet-securise"
version = "0.1.0"
description = "API securisee avec uv"
requires-python = ">=3.12"
dependencies = []

[project.optional-dependencies]
dev = [
    "pytest>=8.0",
    "ruff>=0.8",
    "mypy>=1.14",
    "pre-commit>=4.0",
]

[tool.uv]
# Forcer la resolution stricte des dependances
resolution = "highest"
# Exiger des hashes pour toutes les dependances
verify-hashes = true

Point securite : la directive requires-python = ">=3.12" est importante. Python 3.11 et versions anterieures ont atteint ou approchent leur fin de vie, et ne recoivent plus de correctifs de securite. Specifier une version minimale recente force tous les contributeurs du projet a utiliser une version Python supportee et patchee.

Etape 3 : Gerer les dependances avec uv add

La gestion des dependances est le coeur de la securite d un projet Python. Avec uv add, chaque dependance est ajoutee au pyproject.toml et le lockfile est automatiquement mis a jour. Contrairement a pip install qui installe silencieusement sans tracer la dependance, uv add garantit que toutes les dependances sont explicitement declarees et versionnees.

# Ajouter des dependances de production
uv add fastapi uvicorn[standard] pydantic

# Ajouter des dependances de developpement
uv add --dev pytest ruff mypy pre-commit

# Ajouter avec contrainte de version
uv add "sqlalchemy>=2.0,<3.0"

# Ajouter depuis un index prive (registry entreprise)
uv add --index-url https://pypi.entreprise.fr/simple/ mon-package-interne

# Voir toutes les dependances installees
uv pip list

# Supprimer une dependance
uv remove requests

Chaque appel a uv add declenche automatiquement la resolution de l arbre de dependances complet et la mise a jour du lockfile. Si un conflit est detecte (par exemple, deux dependances qui exigent des versions incompatibles d une meme bibliotheque), uv vous alerte immediatement — contrairement a pip qui peut installer silencieusement des combinaisons incompatibles et ne produire des erreurs qu a l execution. Point securite : la separation entre dependances de production et de developpement (--dev) est cruciale. En production, vous ne devez installer que les dependances de production avec uv sync --no-dev pour minimiser la surface d attaque.

Etape 4 : Verrouiller les dependances avec uv lock

Le lockfile est la pierre angulaire de la securite et de la reproductibilite d un projet Python. Le fichier uv.lock enregistre les versions exactes de toutes les dependances (directes et transitives), leurs hashes SHA256, et les metadonnees de resolution. Cela garantit que chaque build — que ce soit sur votre machine, sur celle d un collegue, ou dans le CI/CD — installe exactement les memes versions de chaque paquet.

# Generer / mettre a jour le lockfile
uv lock

# Installer exactement les versions du lockfile
uv sync

# Installer sans les dependances de dev (production)
uv sync --no-dev

# Mettre a jour une dependance specifique
uv lock --upgrade-package fastapi

# Mettre a jour toutes les dependances
uv lock --upgrade

# Verifier que le lockfile est a jour
uv lock --check

Le fichier uv.lock doit etre commite dans votre depot Git. C est un point essentiel que beaucoup de developpeurs negligent : sans lockfile commite, chaque uv sync resout les dependances a partir de zero et peut obtenir des versions differentes a des moments differents. C est ainsi que des attaques supply chain reussissent : un attaquant publie une nouvelle version malveillante d un paquet, et les projets sans lockfile l installent automatiquement. Avec uv.lock commite, seules les versions explicitement mises a jour (via uv lock --upgrade-package) sont installees. C est une defense directe contre les attaques de type dependency confusion et typosquatting.

Etape 5 : Auditer la securite des dependances

Le verrouillage des versions est necessaire mais pas suffisant. Vous devez egalement verifier que les versions installees ne contiennent pas de vulnerabilites connues (CVE). Plusieurs outils s integrent avec uv pour realiser cet audit :

# Option 1 : pip-audit (recommande, par Google)
uv add --dev pip-audit
uv run pip-audit

# Option 2 : Safety (par SafetyCLI)
uv add --dev safety
uv run safety check

# Option 3 : Utiliser le scanner integre GitHub
# (Dependabot alertes dans votre repo)

# Automatiser l'audit dans un script pre-commit
# .pre-commit-config.yaml
# - repo: local
#   hooks:
#   - id: pip-audit
#     name: Audit dependances Python
#     entry: uv run pip-audit
#     language: system
#     pass_filenames: false

Point securite : l audit des dependances doit etre automatise et execute a chaque pull request, pas seulement manuellement. Configurez votre CI/CD pour bloquer les merges si pip-audit detecte des CVE critiques. Cela empeche l introduction de dependances vulnerables dans votre branche principale. Pour un guide complet sur l audit des dependances supply chain, consultez notre article sur l audit des dependances Python supply chain.

Etape 6 : Configurer le CI/CD avec uv

L integration de uv dans votre pipeline CI/CD est l etape qui rend toutes les precedentes enforcables. Sans CI/CD, les bonnes pratiques restent optionnelles. Avec un pipeline correctement configure, elles deviennent obligatoires. Voici une configuration complete pour GitHub Actions :

# .github/workflows/ci.yml
name: CI Python avec uv

on:
  push:
    branches: [main]
  pull_request:
    branches: [main]

jobs:
  test:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4

      - name: Installer uv
        uses: astral-sh/setup-uv@v4
        with:
          version: "latest"

      - name: Installer dependances
        run: uv sync --frozen
        # --frozen : echoue si uv.lock n'est pas a jour

      - name: Verifier lockfile a jour
        run: uv lock --check

      - name: Linter (Ruff)
        run: uv run ruff check .

      - name: Type checking (mypy)
        run: uv run mypy src/

      - name: Tests
        run: uv run pytest --cov=src/ --cov-report=xml

      - name: Audit securite dependances
        run: uv run pip-audit --strict

L action officielle astral-sh/setup-uv installe uv avec cache integre, ce qui reduit le temps d installation a moins de 2 secondes. Le flag --frozen dans uv sync est critique pour la securite : il garantit que l installation utilise exactement les versions du lockfile commite et echoue si le lockfile n est pas a jour par rapport au pyproject.toml. Le flag --strict dans pip-audit fait echouer le pipeline si des vulnerabilites sont detectees, meme si elles ont deja un correctif disponible — ce qui force la mise a jour. Pour les principes CI/CD plus larges, consultez notre guide sur la configuration de pipelines CI/CD securises pour les projets open source.

Etape 7 : Bonnes pratiques de production et securite avancee

Les six etapes precedentes vous donnent un environnement de developpement solide. Cette derniere etape couvre les pratiques avancees qui transforment un bon setup en un setup securise de niveau production.

1. Configurer pre-commit pour appliquer les verifications localement

# Installer et configurer pre-commit
uv add --dev pre-commit
uv run pre-commit install

# .pre-commit-config.yaml
repos:
  - repo: local
    hooks:
      - id: ruff-check
        name: Ruff linter
        entry: uv run ruff check --fix
        language: system
        types: [python]
      - id: ruff-format
        name: Ruff formatter
        entry: uv run ruff format
        language: system
        types: [python]
      - id: mypy
        name: Mypy type check
        entry: uv run mypy
        language: system
        types: [python]
      - id: lockfile-check
        name: Verify lockfile
        entry: uv lock --check
        language: system
        pass_filenames: false

2. Gestion securisee des secrets et variables d environnement

# .env (NE JAMAIS COMMITER — ajouter au .gitignore)
DATABASE_URL=postgresql://user:pass@localhost/db
SECRET_KEY=votre-cle-secrete
API_KEY=sk-...

# .gitignore (extrait)
.env
.env.local
.env.production
*.pem
*.key

# Charger les variables dans votre app (pydantic-settings)
uv add pydantic-settings

# settings.py
from pydantic_settings import BaseSettings

class Settings(BaseSettings):
    database_url: str
    secret_key: str
    api_key: str
    debug: bool = False

    class Config:
        env_file = ".env"

settings = Settings()

3. Docker multi-stage avec uv pour la production

# Dockerfile — build multi-stage securise avec uv
FROM python:3.12-slim AS builder
COPY --from=ghcr.io/astral-sh/uv:latest /uv /usr/local/bin/uv
WORKDIR /app
COPY pyproject.toml uv.lock ./
RUN uv sync --frozen --no-dev --no-editable
COPY src/ ./src/

FROM python:3.12-slim AS runtime
WORKDIR /app
COPY --from=builder /app/.venv /app/.venv
COPY --from=builder /app/src /app/src
ENV PATH="/app/.venv/bin:$PATH"
# Non-root user pour la securite
RUN useradd -m appuser && chown -R appuser /app
USER appuser
CMD ["python", "-m", "mon_projet_securise"]

Le build multi-stage garantit que l image de production ne contient ni uv, ni les dependances de developpement, ni les fichiers sources intermediaires. L utilisation d un utilisateur non-root (appuser) empeche les processus de l application d avoir un acces root au conteneur, ce qui limite l impact d une compromission. Le flag --frozen dans uv sync garantit que les versions installees sont exactement celles du lockfile — aucune resolution dynamique ne se produit pendant le build Docker.

FAQ