Accueil / Docker

Docker

Empaqueter une application avec tout ce dont elle a besoin (code, dépendances, OS minimal) dans un conteneur qui tourne à l'identique sur n'importe quelle machine.

À quoi ça sert

Le problème classique du dev : « Ça marche sur ma machine, mais pas sur celle de mon collègue / pas en prod. » La cause ? Une version de Python différente, une lib système manquante, un OS pas tout à fait pareil…

Docker résout ça en empaquetant ton app dans une image qui contient tout ce qui est nécessaire pour la faire tourner. On lance ensuite cette image sous forme de conteneur, et le résultat est identique partout : sur ton PC, sur celui d'un collègue, sur un serveur, dans le cloud.

Trois concepts à retenir :

  • Dockerfile — la recette qui décrit comment construire l'image.
  • Image — le résultat figé de la recette (un « modèle »).
  • Conteneur — une instance en exécution d'une image.
Analogie

Le Dockerfile est la recette de cuisine, l'image est le plat préparé sous vide, le conteneur est le plat réchauffé et servi.

Un exemple d'usage

Tu as développé une petite API en Python avec FastAPI. Tu veux que ton collègue puisse la lancer sans installer Python ni les dépendances. Tu lui donnes simplement ton code avec un Dockerfile. De son côté, il fait :

bash 
docker build -t mon-api .
docker run -p 8000:8000 mon-api

Et c'est tout. L'API tourne sur http://localhost:8000, sans qu'il ait eu à installer quoi que ce soit d'autre que Docker.

How-to : installer et utiliser Docker

  1. Installer Docker Desktop

    Docker Desktop est l'application qui regroupe le moteur Docker et une interface graphique. Disponible pour Windows, macOS et Linux.

    • Télécharge depuis docker.com/products/docker-desktop
    • Sous Windows, active WSL 2 (Docker Desktop te guidera).
    • Sous Linux, tu peux aussi installer juste docker-ce via le gestionnaire de paquets.

    Vérifie l'installation :

    bash 
    docker --version
docker run hello-world

    La commande hello-world télécharge une mini image de test et la lance. Si tu vois un message « Hello from Docker! », tu es prêt.

  2. Préparer un mini projet Python

    Crée un dossier et deux fichiers :

    bash 
    mkdir hello-docker && cd hello-docker

    Fichier app.py :

    python 
    from fastapi import FastAPI

app = FastAPI()

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

    Fichier requirements.txt :

    txt 
    fastapi==0.115.0
uvicorn==0.32.0

  3. Écrire le Dockerfile

    Crée un fichier Dockerfile (sans extension) à la racine du projet :

    dockerfile 
    # Image de base : Python officiel, version slim (légère)
FROM python:3.12-slim

# Dossier de travail à l'intérieur du conteneur
WORKDIR /app

# Copier d'abord les requirements pour profiter du cache
COPY requirements.txt .
RUN pip install --no-cache-dir -r requirements.txt

# Puis copier le code
COPY . .

# Port exposé par l'application
EXPOSE 8000

# Commande lancée au démarrage du conteneur
CMD ["uvicorn", "app:app", "--host", "0.0.0.0", "--port", "8000"]
    Astuce cache

    On copie requirements.txt avant le reste du code : si seul ton code change, Docker réutilise la couche d'install des dépendances et le build est presque instantané.

  4. Construire l'image

    Le flag -t donne un nom (un « tag ») à ton image. Le . indique le contexte de build (ici le dossier courant).

    bash 
    docker build -t hello-docker .

    Vérifie qu'elle est bien là :

    bash 
    docker images

  5. Lancer le conteneur

    -p 8000:8000 publie le port 8000 du conteneur sur le port 8000 de ta machine. --rm supprime le conteneur quand il s'arrête.

    bash 
    docker run --rm -p 8000:8000 hello-docker

    Ouvre http://localhost:8000 dans ton navigateur. Tu devrais voir le JSON {"message": "Hello from Docker!"}.

  6. Configurer VS Code

    VS Code propose une extension officielle qui simplifie énormément la vie avec Docker.

    1. Installe l'extension Docker de Microsoft (ms-azuretools.vscode-docker).
    2. Une nouvelle icône Docker apparaît dans la barre latérale : tu y vois tes images et tes conteneurs.
    3. Clic-droit sur un Dockerfile → Build Image… pour builder sans passer par le terminal.
    4. Clic-droit sur un conteneur → Attach Shell pour entrer dedans.
    Bonus : Dev Containers

    Avec l'extension Dev Containers, tu peux ouvrir tout ton projet à l'intérieur d'un conteneur. VS Code, l'éditeur, l'autocomplétion et les extensions Python tournent dans l'environnement Docker — zéro install sur ta machine hôte.

  7. Bonus : Docker Compose pour plusieurs services

    Quand ton app a besoin de plusieurs conteneurs (ex. ton API + une base PostgreSQL), tu décris ça dans un fichier docker-compose.yml :

    yaml 
    services:
  api:
    build: .
    ports:
      - "8000:8000"
    depends_on:
      - db
  db:
    image: postgres:16
    environment:
      POSTGRES_PASSWORD: secret

    Et tu lances tout en une commande :

    bash 
    docker compose up

Aide-mémoire des commandes

bash 
# Images
docker build -t <nom> .       # builder une image
docker images                  # lister les images
docker rmi <image>             # supprimer une image

# Conteneurs
docker run -p 8000:8000 <img>  # lancer
docker run -d <img>            # lancer en arrière-plan
docker ps                      # conteneurs actifs
docker ps -a                   # tous les conteneurs
docker stop <id>               # arrêter
docker rm <id>                 # supprimer
docker logs <id>               # voir les logs
docker exec -it <id> bash      # ouvrir un shell dedans

# Compose
docker compose up               # démarrer la stack
docker compose down             # tout arrêter et nettoyer

# Nettoyage
docker system prune             # nettoyer ce qui ne sert plus

Pour aller plus loin