1. Images

Une image Docker est un modèle immuable (lecture seule) qui contient tout ce qu’il faut pour faire tourner une application : les fichiers, les fichiers compilés (bin), les librairies (bibliothèques) , les configurations etc.

• Elle est construite par couches (layers).
• On la trouve sur des registres (Docker Hub, GitHub Container Registry, etc.) ou on la construit soi-même.

docker pull nginx:latest          # Télécharger une image
docker images                     # Lister les images locales
docker rmi <image>                # Supprimer une image

2. Containers

Un container est une instance d’une image. C’est un processus isolé (namespaces + cgroups) qui partage le kernel de l’hôte. Il peut être en cours d'execution ou stoppé.

• Léger, démarrage très rapide.
• Éphémère par défaut (les modifications disparaissent à l’arrêt sauf si on utilise des volumes, voir plus bas).

docker run -d -p 8080:80 --name mon-nginx nginx   # Lancer en détaché
docker ps                                         # Containers en cours
docker ps -a                                      # Tous les containers
docker stop mon-nginx                             # Arrêter le conteneur
docker start mon-nginx                            # Démarrer le conteneur
docker restart mon-nginx                          # Redémarrer le conteneur
docker logs mon-nginx                             # Logs du conteneur
docker exec -it mon-nginx bash                    # Entrer dans le container
docker rm mon-nginx                               # Supprimer

3. Dockerfile

Fichier texte qui décrit comment construire une image.

Exemple de configuration minimale pour une application Python, un fichier Dockerfile (sans extension) :

FROM python:3.12-slim

WORKDIR /app
COPY requirements.txt .
RUN pip install --no-cache-dir -r requirements.txt

COPY . .
EXPOSE 8000
CMD ["python", "app.py"]

Pour utiliser un Dockerfile, il faut le build.

docker build -t mon-app:1.0 .
docker build -t mon-app:1.0 -f Dockerfile.prod .

Bonnes pratiques rapides :

• Utiliser des images de base légères (-slim, alpine) pour la mise en production.
• Minimiser le nombre de couches.
• Copier d’abord les fichiers qui changent le moins (cache des layers).
• Ne jamais mettre de secrets dans l’image.

4. docker-compose

Outil pour définir et lancer plusieurs containers ensemble (applications multi-services).

Fichier nommé docker-compose.yml :

services:
  web:
    build: .
    ports:
      - "8000:8000"
    volumes:
      - .:/app
    depends_on:
      - db
    environment:
      - DATABASE_URL=postgres://user:pass@db:5432/mydb

  db:
    image: postgres:16
    volumes:
      - pgdata:/var/lib/postgresql/data
    environment:
      POSTGRES_PASSWORD: pass

volumes:
  pgdata:

Utilisation du docker-compose.yml :

docker compose up -d          # Démarrer et détacher (-d)
docker compose down           # Arrêter + supprimer les containers
docker compose logs -f        # Affiche les logs en temps réel (-f)
docker compose build

5. Volumes

Permettent de persister des données hors du cycle de vie du container.

• Named volumes (recommandés) → gérés par Docker

docker volume create mon-volume
docker run -v mon-volume:/data nginx

• Bind mounts → dossier de l’hôte monté dans le container

docker run -v ./mon-app:/app nginx

• tmpfs → en mémoire (éphémère)

Dans Compose on déclare les named volumes en bas du fichier.

6. Networks de base

Docker crée automatiquement des réseaux pour permettre aux containers de communiquer.

• bridge → réseau par défaut (containers peuvent se parler via leur nom de service dans Compose)
• host → partage le réseau de l’hôte
• none → aucun réseau

Créer un réseau custom :

docker network create mon-reseau
docker run --network mon-reseau --name app1 nginx
docker run --network mon-reseau --name app2 alpine ping app1

Dans docker-compose.yml, un réseau est créé automatiquement et tous les services y sont attachés.

On peut en déclarer d’autres :

networks:
  frontend:
  backend:

Résumé ultra-rapide du workflow

1. Écrire un Dockerfile
2. docker build -t mon-image .
3. Tester avec docker run
4. Pour plusieurs services → docker-compose.yml + docker compose up
5. Données persistantes → volumes
6. Communication entre containers → réseaux (automatique avec Compose)

Prochain article : multi-stage builds, healthchecks, secrets ?