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

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

Section 1. Installation

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

1# macOS / Linux
2curl -LsSf https://astral.sh/uv/install.sh | sh
3
4# Windows (PowerShell)
5powershell -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

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

1# Ajouter une dépendance principale
2uv add fastapi uvicorn
3
4# Supprimer une dépendance
5uv remove uvicorn
6
7# Mettre à jour toutes les dépendances selon les contraintes
8uv 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.

1# Exécute directement un script dans l'environnement virtuel
2uv run mon-api
3
4# Lancer un serveur de développement
5uv run uvicorn main:app --reload

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

1# Lister les versions de Python disponibles
2uv python list
3
4# Installer une version spécifique (ex: Python 3.12 ou 3.13)
5uv python install 3.12
6
7# Épingler la version pour le projet en cours
8uv python pin 3.12

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

1# Dépendances de développement et qualité de code
2uv add ruff mypy --group dev
3
4# Dépendances de tests unitaires
5uv add pytest pytest-asyncio httpx --group test

Votre fichier pyproject.toml reste clair et standardisé :

1[project]
2name = "mon-api"
3version = "0.1.0"
4description = "Exemple d'API avec FastAPI et UV"
5readme = "README.md"
6requires-python = ">=3.12"
7dependencies = [
8    "fastapi>=0.115.0",
9    "uvicorn>=0.30.0",
10]
11
12[dependency-groups]
13dev = [
14    "mypy>=1.11.0",
15    "ruff>=0.6.0",
16]
17test = [
18    "httpx>=0.27.0",
19    "pytest>=8.3.0",
20    "pytest-asyncio>=0.24.0",
21]

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

1# Installer uniquement la production (idéal pour Docker)
2uv sync --no-dev
3
4# Installer avec un groupe spécifique
5uv sync --group test

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

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

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

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

1# /// script
2# requires-python = ">=3.12"
3# dependencies = [
4#     "requests",
5#     "rich",
6# ]
7# ///
8
9import requests
10from rich.console import Console
11
12console = Console()
13response = requests.get("https://api.github.com/repos/astral-sh/uv")
14stars = response.json().get("stargazers_count", 0)
15
16console.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 :

1# Étape 1 : Construction et installation des dépendances
2FROM python:3.12-slim AS builder
3
4# Récupérer le binaire UV depuis l'image officielle Astral
5COPY --from=ghcr.io/astral-sh/uv:latest /uv /bin/uv
6
7WORKDIR /app
8
9# Optimisation du cache Docker : copier uniquement les fichiers de définition
10COPY pyproject.toml uv.lock ./
11
12# Synchroniser l'environnement virtuel sans les dépendances de dev
13RUN uv sync --frozen --no-dev --no-install-project
14
15# Étape 2 : Image d'exécution minimale
16FROM python:3.12-slim AS runner
17
18WORKDIR /app
19
20# Copier l'environnement virtuel pré-compilé
21COPY --from=builder /app/.venv /app/.venv
22COPY . .
23
24ENV PATH="/app/.venv/bin:$PATH"
25
26EXPOSE 8000
27CMD ["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

1# app.py
2from fastapi import FastAPI
3from mangum import Mangum
4
5app = FastAPI(title="Lambda API avec UV")
6
7@app.get("/")
8def home():
9    return {"status": "running", "runtime": "AWS Lambda"}
10
11# Handler pour AWS Lambda
12handler = 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.

Section Résumé des commandes indispensables