Comprendre docker compose quand on vient de docker run

Quand on commence avec Docker, on lance souvent ses conteneurs avec docker run. Cela marche bien pour un test rapide, mais la commande devient vite longue, difficile a relire, et penible a partager.

docker compose permet de decrire cette meme configuration dans un fichier compose.yaml, puis de relancer exactement le meme environnement avec une commande simple.

Pourquoi docker run devient vite limite

Prenons un exemple classique : lancer une application web avec un port, un nom de conteneur, une variable d'environnement et un volume.

docker run -d \
  --name mon-app \
  -p 8080:80 \
  -e APP_ENV=dev \
  -v "$PWD/data:/app/data" \
  nginx

Cette commande fonctionne, mais elle a plusieurs limites :

• toute la configuration est cachee dans une seule ligne ;
• il faut se souvenir de toutes les options pour relancer le conteneur ;
• partager cette configuration avec quelqu'un d'autre est peu pratique ;
• des qu'on a plusieurs services, cela devient vite confus.

L'idee de docker compose

Avec docker compose, on deplace la configuration dans un fichier declaratif.

Au lieu de dire a Docker quoi faire a chaque execution, on decrit l'etat souhaite :

• quels services existent ;
• quelle image ils utilisent ;
• quels ports sont exposes ;
• quels volumes sont montes ;
• quelles variables d'environnement sont definies.

Ensuite, Docker lit ce fichier et cree l'environnement correspondant.

Traduire un docker run en compose.yaml

La commande precedente peut devenir :

services:
  mon-app:
    image: nginx
    container_name: mon-app
    ports:
      - "8080:80"
    environment:
      APP_ENV: dev
    volumes:
      - ./data:/app/data

Puis on lance :

docker compose up -d

Et on arrete :

docker compose down

Le gros avantage est que la configuration reste dans le projet. On peut la versionner, la relire, la modifier, et la partager.

Comment lire un fichier Compose

La cle principale est services.

Chaque entree sous services correspond a un conteneur logique de ton application.

Dans l'exemple ci-dessus :

• mon-app est le nom du service ;
• image: nginx indique l'image a utiliser ;
• ports publie le port local 8080 vers le port 80 du conteneur ;
• environment definit des variables d'environnement ;
• volumes monte un dossier local dans le conteneur.

On retrouve donc les memes briques que dans docker run, mais sous une forme beaucoup plus lisible.

Le vrai interet : plusieurs services

La puissance de Compose apparait vraiment quand une application depend de plusieurs conteneurs.

Par exemple, une application web et une base PostgreSQL :

services:
  web:
    build: .
    ports:
      - "8000:8000"
    environment:
      DATABASE_URL: postgresql://demo:demo@db:5432/demo
    depends_on:
      - db

  db:
    image: postgres:16
    environment:
      POSTGRES_DB: demo
      POSTGRES_USER: demo
      POSTGRES_PASSWORD: demo
    volumes:
      - postgres_data:/var/lib/postgresql/data

volumes:
  postgres_data:

Dans ce cas, docker run devient vite penible, alors que Compose reste clair.

Autre point important : les services savent se joindre entre eux par leur nom. Ici, le service web peut parler a db directement avec le nom d'hote db.

Les commandes utiles au quotidien

Une fois le fichier en place, les commandes les plus utiles sont :

docker compose up -d
docker compose down
docker compose ps
docker compose logs -f
docker compose exec web bash

• up -d demarre les services en arriere-plan ;
• down arrete et supprime les conteneurs du projet ;
• ps affiche l'etat des services ;
• logs -f suit les logs ;
• exec permet d'entrer dans un service deja demarre.

Quand utiliser docker run et quand utiliser Compose

docker run reste tres bien pour :

• tester rapidement une image ;
• lancer un conteneur jetable ;
• faire une verification ponctuelle.

docker compose est preferable pour :

• un projet que tu relances souvent ;
• un environnement de developpement ;
• plusieurs services qui doivent fonctionner ensemble ;
• une configuration que tu veux garder dans le depot.

En resume

docker run est pratique pour lancer un conteneur.

docker compose est pratique pour decrire proprement un environnement complet et reproductible.

Si tu te surprends a copier-coller plusieurs fois la meme commande docker run, c'est souvent le bon moment pour passer a Compose.