Docker pour développeurs Python : guide pratique pour containeriser tes projets

Pourquoi Docker est devenu indispensable pour les développeurs Python

Tu as déjà vécu ça : tu bosses sur un projet Python, tout roule chez toi. Tu envoies le code à ton pote (ou pire, sur le serveur de prod), et là… « ModuleNotFoundError », « version Python incorrecte », « dépendance incompatible ». Le fameux « mais ça marche chez moi ! ».

C’est exactement le problème que Docker résout. Et si tu développes en Python, c’est un outil que tu dois absolument maîtriser — pas dans 6 mois, maintenant. Dans cet article, je vais te montrer comment containeriser une application Python en 10 minutes chrono, sans jargon inutile.

Docker en une phrase

Docker, c’est un outil qui permet d’embarquer ton application avec tout son environnement (Python, bibliothèques, variables d’environnement, etc.) dans un conteneur léger et reproductible. Fini les « ça marchait tout à l’heure » — si ça tourne dans le conteneur, ça tournera partout.

Un conteneur, c’est un peu comme une machine virtuelle miniature, mais 100 fois plus léger. Pas de système d’exploitation complet à installer, pas de gigaoctets de RAM gaspillés. Juste ce qu’il faut pour faire tourner ton app.

Étape 1 : Créer ton projet Python

On va prendre un exemple concret : une API web minimaliste avec FastAPI (tu peux adapter avec Flask, Django, ou n’importe quel framework).

Structure du projet :

mon-app/
├── app/
│   ├── __init__.py
│   ├── main.py        # L'application FastAPI
│   └── routes.py      # Les endpoints
├── requirements.txt   # Les dépendances
├── Dockerfile         # La recette du conteneur
└── .dockerignore      # Les fichiers à exclure

Un petit main.py tout simple :

from fastapi import FastAPI

app = FastAPI(title="Mon API Dockerisée")

@app.get("/")
def read_root():
    return {"message": "Hello depuis Docker !"}

@app.get("/health")
def health():
    return {"status": "ok"}

Étape 2 : Écrire le Dockerfile — le cœur du sujet

Le Dockerfile, c’est la recette de ton conteneur. Voici un template prêt à l’emploi pour une app Python :

# 1. On part d'une image Python officielle (léger = bon)
FROM python:3.12-slim

# 2. On définit le répertoire de travail
WORKDIR /app

# 3. On copie d'abord les dépendances (optimisation cache Docker)
COPY requirements.txt .

# 4. On installe les dépendances
RUN pip install --no-cache-dir -r requirements.txt

# 5. On copie le reste du code
COPY . .

# 6. On expose le port
EXPOSE 8000

# 7. Commande de lancement
CMD ["uvicorn", "app.main:app", "--host", "0.0.0.0", "--port", "8000"]

⏱️ Astuce optimisation : On copie requirements.txt AVANT le reste du code. Pourquoi ? Docker met en cache chaque étape. Tant que requirements.txt ne change pas, Docker réutilise le cache pour l’installation des dépendances — gain de temps énorme quand tu modifies ton code sans ajouter de dépendances.

Étape 3 : Construire et lancer le conteneur

Place à l’action :

# Construction de l'image
docker build -t mon-api-python .

# Lancement du conteneur
docker run -d -p 8000:8000 --name mon-api mon-api-python

# Vérification
curl http://localhost:8000/
# {"message": "Hello depuis Docker !"}

Magique, non ? Ton API tourne dans un environnement propre, isolé et reproductible. Tu peux l’arrêter avec docker stop mon-api et la relancer quand tu veux.

Étape 4 : Docker Compose — le multi-conteneurs facile

Un vrai projet ne tourne jamais seul : il a une base de données, un cache Redis, un worker en arrière-plan… C’est là que Docker Compose entre en jeu. Un fichier YAML et tout ton stack démarre d’un coup :

version: '3.8'
services:
  api:
    build: .
    ports:
      - "8000:8000"
    environment:
      - DATABASE_URL=postgresql://user:pass@db:5432/mydb
    depends_on:
      - db

  db:
    image: postgres:16-alpine
    environment:
      POSTGRES_USER: user
      POSTGRES_PASSWORD: pass
      POSTGRES_DB: mydb
    volumes:
      - pgdata:/var/lib/postgresql/data

volumes:
  pgdata:

Un seul docker compose up -d et tout ton environnement est opérationnel. Base de données PostgreSQL, API Python, réseau partagé — zéro configuration manuelle.

Les bonnes pratiques à adopter dès maintenant

• Images légères : préfère python:3.12-slim à python:3.12 (300 Mo vs 900 Mo). Pour du déploiement, python:3.12-alpine est encore plus petit (~50 Mo).
• .dockerignore : exclus __pycache__/, .git/, .env, venv/ — tout ce qui ne sert à rien dans le conteneur.
• Un processus par conteneur : pas de SSH, pas de cron, pas de background jobs dans ton conteneur API. Chaque service son conteneur.
• Variables d’environnement : ne jamais hardcoder les mots de passe dans le Dockerfile. Utilise un fichier .env ou les environment de Docker Compose.
• Ne pas tourner en root : ajoute un utilisateur non-root dans ton Dockerfile pour plus de sécurité.

Docker en production — ce qui change

Pour le développement local, docker run suffit. En production, tu auras besoin d’un orchestrateur comme :

• Docker Swarm — le plus simple, intégré à Docker
• Kubernetes (K8s) — le standard industriel, plus complexe mais ultra-puissant
• Platform.sh / Railway / Render — solutions managées qui déploient direct depuis ton git

Mais avant de viser la Lune avec Kubernetes, commence par maîtriser le Dockerfile et Docker Compose. 80% des projets n’ont pas besoin de plus.

Conclusion

Docker n’est pas un outil de plus à apprendre — c’est le standard du développement moderne. Que tu travailles en solo, en startup ou dans une grosse boîte, savoir containeriser une application Python est une compétence indispensable sur un CV en 2026.

Récapitulons ce que tu as appris :

• ✅ Créer un Dockerfile optimisé pour une app Python
• ✅ Construire et lancer un conteneur
• ✅ Orchestrer plusieurs services avec Docker Compose
• ✅ Appliquer les bonnes pratiques (images légères, sécurité, cache)

Et maintenant ?

Le meilleur moyen d’apprendre, c’est de pratiquer. Prends un de tes projets Python, ajoute-lui un Dockerfile, et lance-le en conteneur. La première fois, ça te prendra 15 minutes. La dixième, tu le feras les yeux fermés en 30 secondes.

Tu veux aller plus loin ? Sur adamcours.fr, on couvre Docker, Kubernetes, le déploiement et tout l’écosystème moderne du développeur Python. Découvre nos formations pour passer au niveau supérieur.