Découverte de UV, le nouveau gestionnaire de paquets Python

UV est un gestionnaire de paquets et d'environnements Python extrêmement rapide, développé par Astral (l'équipe derrière le linter et formateur Ruff). Écrit en Rust, il a été conçu pour unifier et remplacer des outils historiques comme pip, pip-tools, virtualenv, poetry ou encore pyenv.

Par défaut, dans un projet Python traditionnel, le flux classique imposait plusieurs étapes fastidieuses :

1. Créer un environnement virtuel : python -m venv .venv
2. L'activer : source .venv/bin/activate (ou .venv\Scripts\activate sous Windows)
3. Installer les dépendances : pip install <paquet>
4. Geler les versions : pip freeze > requirements.txt

En 2026, cette époque est révolue : UV regroupe tout cela en une seule commande, avec des temps d'exécution divisés par 10 voire 100 grâce à son moteur de résolution en Rust et son système de cache global.

1. Installation

L'installation se fait en une ligne de commande via le script officiel d'Astral :

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

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

Vous pouvez également l'installer via Homebrew si vous êtes sur macOS :

brew install uv

uv self update

2. Prise en main rapide : votre projet en 30 secondes

UV modernise le workflow de développement en s'appuyant sur les standards modernes (pyproject.toml conforme à la PEP 621).

Initialiser un projet

# Crée un nouveau dossier et initialise la structure du projet
uv init mon-api
cd mon-api

Cette commande génère automatiquement :

• pyproject.toml : le fichier de configuration standardisé de votre projet.
• .python-version : fixe la version de Python ciblée.
• src/__init__.py : un fichier de départ prêt à être exécuté.

Ajouter et retirer des paquets

Lorsque vous ajoutez une dépendance, UV s'occupe de tout : création automatique du dossier .venv, résolution des dépendances, mise à jour du pyproject.toml et génération du lockfile uv.lock.

# Ajouter une dépendance principale
uv add fastapi uvicorn

# Supprimer une dépendance
uv remove uvicorn

# Mettre à jour toutes les dépendances selon les contraintes
uv lock --upgrade

Exécuter du code sans activer l'environnement

C'est l'un des plus grands atouts d'UV au quotidien : vous n'avez plus besoin d'activer manuellement votre environnement virtuel avec source .venv/bin/activate.

# Exécute directement un script dans l'environnement virtuel
uv run mon-api

# Lancer un serveur de développement
uv run uvicorn main:app --reload

3. Gestion des versions de Python à la volée

Plus besoin d'installer et configurer pyenv pour jongler entre les versions de Python : UV gère le téléchargement et l'isolation des exécutables Python de manière autonome.

# Lister les versions de Python disponibles
uv python list

# Installer une version spécifique (ex: Python 3.12 ou 3.13)
uv python install 3.12

# Épingler la version pour le projet en cours
uv python pin 3.12

4. Organisation des dépendances par groupes

Dans un projet professionnel, certaines bibliothèques ne doivent pas se retrouver en production (outils de test, linters, documentation). UV permet de classer vos paquets dans des groupes dédiés grâce au flag --group :

# Dépendances de développement et qualité de code
uv add ruff mypy --group dev

# Dépendances de tests unitaires
uv add pytest pytest-asyncio httpx --group test

Votre fichier pyproject.toml reste clair et standardisé :

[project]
name = "mon-api"
version = "0.1.0"
description = "Exemple d'API avec FastAPI et UV"
readme = "README.md"
requires-python = ">=3.12"
dependencies = [
    "fastapi>=0.115.0",
    "uvicorn>=0.30.0",
]

[dependency-groups]
dev = [
    "mypy>=1.11.0",
    "ruff>=0.6.0",
]
test = [
    "httpx>=0.27.0",
    "pytest>=8.3.0",
    "pytest-asyncio>=0.24.0",
]

Pour synchroniser un environnement en installant ou en excluant certains groupes :

# Installer uniquement la production (idéal pour Docker)
uv sync --no-dev

# Installer avec un groupe spécifique
uv sync --group test

5. Configuration d'entreprise : Proxy et Registries privés

En environnement d'entreprise, les flux sortants sont souvent filtrés et les dépendances proviennent de registres privés (Nexus, Artifactory, AWS CodeArtifact, Google Artifact Registry).

Configurer un Proxy HTTP/HTTPS

Plutôt que de devoir exporter manuellement des variables d'environnement globales sur chaque machine, vous pouvez déclarer le proxy directement dans la configuration d'UV via le fichier pyproject.toml ou un fichier uv.toml :

[tool.uv]
http-proxy = "http://proxy.entreprise.internal:8080"
https-proxy = "http://proxy.entreprise.internal:8080"

Utiliser un registre de paquets privé

Pour consommer des paquets internes hébergés sur AWS CodeArtifact, Google Cloud Artifact Registry ou GitLab Package Registry :

[[tool.uv.index]]
name = "private-registry"
url = "https://europe-west1-python.pkg.dev/mon-projet-gcp/pypi/simple/"
default = false

# Installer un paquet propriétaire depuis votre registre interne
uv add mon-sdk-interne --index private-registry

6. Cas d'usage avancés et exemples concrets

A. Scripts autonomes avec métadonnées intégrées (PEP 723)

Vous devez partager un script de maintenance ponctuel sans créer un projet complet ? UV permet d'exécuter des scripts avec leurs dépendances déclarées directement en en-tête du fichier :

# /// script
# requires-python = ">=3.12"
# dependencies = [
#     "requests",
#     "rich",
# ]
# ///

import requests
from rich.console import Console

console = Console()
response = requests.get("https://api.github.com/repos/astral-sh/uv")
stars = response.json().get("stargazers_count", 0)

console.print(f"[bold green]Étoiles GitHub pour UV :[/bold green] [yellow]{stars}[/yellow]")

Pour exécuter ce script :

uv run stats.py

UV installe les dépendances dans un environnement temporaire isolé, exécute le script, et nettoie sans polluer votre machine.

B. Dockerfile multi-stage ultra-rapide

Dans vos pipelines CI/CD et déploiements conteneurisés, UV accélère drastiquement le temps de construction des images grâce à sa légèreté et à l'image officielle fournie par Astral :

# Étape 1 : Construction et installation des dépendances
FROM python:3.12-slim AS builder

# Récupérer le binaire UV depuis l'image officielle Astral
COPY --from=ghcr.io/astral-sh/uv:latest /uv /bin/uv

WORKDIR /app

# Optimisation du cache Docker : copier uniquement les fichiers de définition
COPY pyproject.toml uv.lock ./

# Synchroniser l'environnement virtuel sans les dépendances de dev
RUN uv sync --frozen --no-dev --no-install-project

# Étape 2 : Image d'exécution minimale
FROM python:3.12-slim AS runner

WORKDIR /app

# Copier l'environnement virtuel pré-compilé
COPY --from=builder /app/.venv /app/.venv
COPY . .

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

EXPOSE 8000
CMD ["python", "-m", "uvicorn", "main:app", "--host", "0.0.0.0", "--port", "8000"]

C. Déploiement Serverless (AWS Lambda / Cloud Functions)

Pour déployer une API FastAPI sur AWS Lambda avec un adaptateur ASGI comme Mangum, la combinaison avec UV simplifie considérablement le packaging :

uv add fastapi mangum

# app.py
from fastapi import FastAPI
from mangum import Mangum

app = FastAPI(title="Lambda API avec UV")

@app.get("/")
def home():
    return {"status": "running", "runtime": "AWS Lambda"}

# Handler pour AWS Lambda
handler = Mangum(app)

Grâce à uv export --format requirements-txt > requirements.txt, vous exportez en une fraction de seconde la liste exacte et verrouillée de vos paquets pour la couche Lambda ou le conteneur serverless.

Résumé des commandes indispensables