Docker pour les débutants : Le guide complet pour enfin comprendre les conteneurs

Développeur : "Ça marche sur ma machine !"
Ops : "Mais pas sur le serveur..."
Développeur : "Tu as quelle version de Python ?"
Ops : "3.8"
Développeur : "Ah, il faut 3.11... et tu as installé libpq-dev ?"
Ops : "C'est quoi ça ?"
[3 heures plus tard...]

Développeur : "Voici le conteneur"
Ops : "docker run... C'est en prod."
[30 secondes plus tard...]

┌─────────────────────────────────────┐
│           Ton Application           │
├─────────────────────────────────────┤
│         Système d'exploitation      │  ← OS complet (Windows, Linux...)
├─────────────────────────────────────┤
│            Hyperviseur              │  ← VMware, VirtualBox, etc.
├─────────────────────────────────────┤
│      Système hôte (ton PC)          │
└─────────────────────────────────────┘

┌─────────────────────────────────────┐
│           Ton Application           │
├─────────────────────────────────────┤
│     Librairies et dépendances       │  ← Seulement ce qui est nécessaire
├─────────────────────────────────────┤
│           Docker Engine             │
├─────────────────────────────────────┤
│      Système hôte (ton PC)          │
└─────────────────────────────────────┘

# Mettre à jour les paquets
sudo apt update

# Installer les prérequis
sudo apt install apt-transport-https ca-certificates curl software-properties-common

# Ajouter la clé GPG officielle de Docker
curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo gpg --dearmor -o /usr/share/keyrings/docker-archive-keyring.gpg

# Ajouter le repository Docker
echo "deb [arch=$(dpkg --print-architecture) signed-by=/usr/share/keyrings/docker-archive-keyring.gpg] https://download.docker.com/linux/ubuntu $(lsb_release -cs) stable" | sudo tee /etc/apt/sources.list.d/docker.list > /dev/null

# Installer Docker
sudo apt update
sudo apt install docker-ce docker-ce-cli containerd.io

# Vérifier l'installation
docker --version

# Installer les prérequis
sudo dnf install -y dnf-plugins-core

# Ajouter le repository Docker
sudo dnf config-manager --add-repo https://download.docker.com/linux/centos/docker-ce.repo

# Installer Docker
sudo dnf install docker-ce docker-ce-cli containerd.io

# Démarrer Docker
sudo systemctl start docker
sudo systemctl enable docker

# Vérifier
docker --version

# Ajouter ton utilisateur au groupe docker
sudo usermod -aG docker $USER

# Appliquer les changements (déconnecte-toi et reconnecte-toi, ou)
newgrp docker

# Tester sans sudo
docker run hello-world

# Le test classique
docker run hello-world

Hello from Docker!
This message shows that your installation appears to be working correctly.
...

# Lancer un conteneur Ubuntu
docker run ubuntu echo "Bonjour depuis Docker !"

# Que s'est-il passé ?
# 1. Docker a téléchargé l'image "ubuntu" (si pas en local)
# 2. Docker a créé un conteneur à partir de cette image
# 3. Docker a exécuté la commande "echo ..."
# 4. Le conteneur s'est arrêté

# Lancer Ubuntu en mode interactif
docker run -it ubuntu bash

# -i : interactif (garde STDIN ouvert)
# -t : alloue un pseudo-TTY (terminal)

# Tu es maintenant DANS le conteneur !
root@abc123:/# ls
root@abc123:/# cat /etc/os-release
root@abc123:/# exit

# Conteneurs en cours d'exécution
docker ps

# Tous les conteneurs (y compris arrêtés)
docker ps -a

# Format personnalisé
docker ps --format "table {{.ID}}\t{{.Image}}\t{{.Status}}"

# Lancer un conteneur en arrière-plan (détaché)
docker run -d --name mon-nginx nginx

# -d : détaché (en arrière-plan)
# --name : donner un nom au conteneur

# Voir les logs
docker logs mon-nginx
docker logs -f mon-nginx  # -f : suivre en temps réel

# Arrêter un conteneur
docker stop mon-nginx

# Démarrer un conteneur arrêté
docker start mon-nginx

# Redémarrer
docker restart mon-nginx

# Supprimer un conteneur (doit être arrêté)
docker rm mon-nginx

# Supprimer un conteneur en cours d'exécution (force)
docker rm -f mon-nginx

# Lancer un conteneur
docker run -d --name mon-ubuntu ubuntu sleep infinity

# Exécuter une commande dedans
docker exec mon-ubuntu ls /

# Entrer dans le conteneur
docker exec -it mon-ubuntu bash

# Tu es dedans !
root@xyz789:/# apt update
root@xyz789:/# exit

# Lancer Nginx et exposer le port 80
docker run -d -p 8080:80 --name web nginx

# -p 8080:80 : mappe le port 8080 de ta machine au port 80 du conteneur

# Maintenant, ouvre http://localhost:8080 dans ton navigateur !

-p [IP_HOTE:]PORT_HOTE:PORT_CONTENEUR

Exemples :
-p 8080:80          # localhost:8080 → conteneur:80
-p 127.0.0.1:8080:80  # Seulement accessible en local
-p 80:80            # Même port

# Lister les images locales
docker images

# Télécharger une image (sans lancer de conteneur)
docker pull python:3.11

# Supprimer une image
docker rmi python:3.11

# Supprimer les images non utilisées
docker image prune

# Rechercher sur Docker Hub
docker search postgres

# Supprimer tous les conteneurs arrêtés
docker container prune

# Supprimer toutes les images non utilisées
docker image prune

# Supprimer tout ce qui n'est pas utilisé (attention !)
docker system prune

# Voir l'espace utilisé
docker system df

nom:tag

Exemples :
python:3.11
python:3.11-slim
python:latest
ubuntu:22.04
nginx:alpine

# Ces deux commandes sont identiques
docker pull nginx
docker pull nginx:latest

# Image légère
docker pull python:3.11-alpine  # ~50 Mo vs ~1 Go pour la version complète

# Rechercher des images
docker search flask

# Voir les détails sur hub.docker.com
# https://hub.docker.com/_/python

# Image de base
FROM python:3.11-slim

# Métadonnées
LABEL maintainer="ton@email.com"

# Définir le répertoire de travail
WORKDIR /app

# Copier les fichiers
COPY requirements.txt .

# Exécuter des commandes
RUN pip install --no-cache-dir -r requirements.txt

# Copier le reste de l'application
COPY . .

# Exposer un port
EXPOSE 5000

# Commande par défaut
CMD ["python", "app.py"]

mon-app/
├── app.py
├── requirements.txt
└── Dockerfile

from flask import Flask

app = Flask(__name__)

@app.route("/")
def hello():
    return "Bonjour depuis Docker ! 🐳"

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

if __name__ == "__main__":
    app.run(host="0.0.0.0", port=5000)

flask==3.0.0

# Image de base Python
FROM python:3.11-slim

# Répertoire de travail
WORKDIR /app

# Copier et installer les dépendances
COPY requirements.txt .
RUN pip install --no-cache-dir -r requirements.txt

# Copier le code
COPY app.py .

# Port exposé
EXPOSE 5000

# Commande de lancement
CMD ["python", "app.py"]

# Se placer dans le dossier du projet
cd mon-app

# Construire l'image
docker build -t mon-app-flask .

# -t : tag (nom de l'image)
# . : contexte de build (dossier courant)

# Vérifier
docker images | grep mon-app

docker run -d -p 5000:5000 --name flask-app mon-app-flask

# Tester
curl http://localhost:5000
# Bonjour depuis Docker ! 🐳

FROM python:3.11-slim
FROM node:20-alpine
FROM ubuntu:22.04

WORKDIR /app
# Toutes les commandes suivantes s'exécutent dans /app

COPY fichier.txt /app/
COPY . /app/
COPY --chown=user:group fichier.txt /app/

ADD archive.tar.gz /app/          # Extrait automatiquement
ADD https://example.com/file /app/ # Télécharge depuis une URL

RUN apt-get update && apt-get install -y curl
RUN pip install flask

CMD ["python", "app.py"]
CMD ["npm", "start"]

ENTRYPOINT ["python"]
CMD ["app.py"]
# Résultat : python app.py
# docker run mon-image script.py → python script.py

ENV FLASK_ENV=production
ENV DATABASE_URL=postgres://localhost/db

ARG VERSION=1.0
RUN echo "Version: $VERSION"

# docker build --build-arg VERSION=2.0 .

EXPOSE 5000
EXPOSE 80 443

RUN useradd -m appuser
USER appuser

VOLUME /data

# Étape 1 : Build
FROM node:20 AS builder
WORKDIR /app
COPY package*.json ./
RUN npm install
COPY . .
RUN npm run build

# Étape 2 : Production
FROM nginx:alpine
COPY --from=builder /app/dist /usr/share/nginx/html
EXPOSE 80
CMD ["nginx", "-g", "daemon off;"]

# Créer un fichier dans un conteneur
docker run -it --name test ubuntu bash
root@abc:/# echo "Hello" > /data.txt
root@abc:/# exit

# Supprimer et recréer
docker rm test
docker run -it --name test ubuntu bash
root@xyz:/# cat /data.txt
# cat: /data.txt: No such file or directory

# Créer un volume
docker volume create mes-donnees

# Lister les volumes
docker volume ls

# Utiliser un volume
docker run -d -v mes-donnees:/app/data --name app ubuntu sleep infinity

# -v nom-volume:chemin-dans-conteneur

# Les données persistent même si le conteneur est supprimé !

# Monter le dossier courant
docker run -v $(pwd):/app -w /app python:3.11 python script.py

# -v chemin-hôte:chemin-conteneur
# -w : définir le répertoire de travail

# Exemple pratique : développement avec rechargement automatique
docker run -d -p 5000:5000 -v $(pwd):/app mon-app-flask

# Ton code est monté dans le conteneur
# Chaque modification est immédiatement visible
docker run -d \
  -p 5000:5000 \
  -v $(pwd):/app \
  -e FLASK_DEBUG=1 \
  mon-app-flask

# Les données survivent au redémarrage
docker run -d \
  --name postgres \
  -e POSTGRES_PASSWORD=secret \
  -v postgres-data:/var/lib/postgresql/data \
  -p 5432:5432 \
  postgres:15

# Créer un volume
docker volume create shared-data

# Conteneur 1 : écrit
docker run -v shared-data:/data alpine sh -c "echo 'Hello' > /data/message.txt"

# Conteneur 2 : lit
docker run -v shared-data:/data alpine cat /data/message.txt
# Hello

# Lister les réseaux
docker network ls

# Par défaut, tu as :
# - bridge : réseau par défaut pour les conteneurs
# - host : partage le réseau de l'hôte
# - none : pas de réseau

# Lancer deux conteneurs
docker run -d --name web nginx
docker run -d --name app python:3.11 sleep infinity

# Trouver l'IP
docker inspect web | grep IPAddress

# Depuis app, accéder à web par IP
docker exec app curl http://172.17.0.2

# Créer un réseau
docker network create mon-reseau

# Lancer les conteneurs sur ce réseau
docker run -d --name web --network mon-reseau nginx
docker run -d --name app --network mon-reseau python:3.11 sleep infinity

# Depuis app, accéder à web PAR SON NOM
docker exec app curl http://web
# Ça marche ! Docker fait la résolution DNS automatiquement

# Créer le réseau
docker network create app-network

# Lancer PostgreSQL
docker run -d \
  --name db \
  --network app-network \
  -e POSTGRES_PASSWORD=secret \
  -e POSTGRES_DB=myapp \
  postgres:15

# Lancer l'application (qui se connecte à "db")
docker run -d \
  --name web \
  --network app-network \
  -p 5000:5000 \
  -e DATABASE_URL=postgresql://postgres:secret@db:5432/myapp \
  mon-app

docker network create app-net
docker volume create db-data
docker run -d --name db --network app-net -v db-data:/var/lib/postgresql/data -e POSTGRES_PASSWORD=secret postgres:15
docker run -d --name redis --network app-net redis:alpine
docker run -d --name web --network app-net -p 5000:5000 -e DATABASE_URL=... mon-app

docker compose up -d

# Vérifier si installé
docker compose version

# Si pas installé
sudo apt install docker-compose-plugin

version: "3.8"

services:
  web:
    image: nginx
    ports:

      - "80:80"

  db:
    image: postgres:15
    environment:
      POSTGRES_PASSWORD: secret

mon-projet/
├── app/
│   ├── app.py
│   └── requirements.txt
├── Dockerfile
└── docker-compose.yml

from flask import Flask
import redis
import psycopg2
import os

app = Flask(__name__)

# Connexion Redis
cache = redis.Redis(host='redis', port=6379)

@app.route("/")
def hello():
    # Incrémenter le compteur de visites
    visits = cache.incr('visits')
    return f"Bonjour ! Cette page a été vue {visits} fois."

@app.route("/health")
def health():
    return {"status": "ok", "services": {"redis": "up", "db": "up"}}

if __name__ == "__main__":
    app.run(host="0.0.0.0", port=5000, debug=True)

flask==3.0.0
redis==5.0.0
psycopg2-binary==2.9.9

FROM python:3.11-slim

WORKDIR /app

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

COPY app/ .

EXPOSE 5000

CMD ["python", "app.py"]

version: "3.8"

services:
  web:
    build: .
    ports:

      - "5000:5000"
    environment:

      - FLASK_DEBUG=1

      - DATABASE_URL=postgresql://postgres:secret@db:5432/myapp
    volumes:

      - ./app:/app
    depends_on:

      - db

      - redis
    restart: unless-stopped

  db:
    image: postgres:15-alpine
    environment:
      POSTGRES_USER: postgres
      POSTGRES_PASSWORD: secret
      POSTGRES_DB: myapp
    volumes:

      - postgres-data:/var/lib/postgresql/data
    restart: unless-stopped

  redis:
    image: redis:alpine
    restart: unless-stopped

volumes:
  postgres-data:

# Lancer tous les services
docker compose up

# En arrière-plan
docker compose up -d

# Voir les logs
docker compose logs
docker compose logs -f web  # Suivre les logs du service "web"

# Voir le statut
docker compose ps

# Arrêter
docker compose stop

# Arrêter et supprimer
docker compose down

# Supprimer aussi les volumes (ATTENTION : perte de données)
docker compose down -v

# Reconstruire les images
docker compose build
docker compose up --build

# Exécuter une commande dans un service
docker compose exec web bash
docker compose exec db psql -U postgres

# Scaler un service (plusieurs instances)
docker compose up -d --scale web=3

services:
  web:
    build: .  # Dockerfile dans le dossier courant

    # Ou avec options
    build:
      context: ./app
      dockerfile: Dockerfile.prod
      args:
        VERSION: 1.0

services:
  db:
    image: postgres:15-alpine

services:
  web:
    ports:

      - "5000:5000"        # host:container

      - "127.0.0.1:80:80"  # Seulement en local

services:
  web:
    volumes:

      - ./code:/app              # Bind mount

      - data-volume:/app/data    # Volume nommé

volumes:
  data-volume:

services:
  web:
    environment:

      - DEBUG=1

      - DATABASE_URL=postgresql://...

    # Ou depuis un fichier
    env_file:

      - .env

services:
  web:
    depends_on:

      - db

      - redis

  db:
    image: postgres:15

  redis:
    image: redis:alpine

services:
  web:
    restart: unless-stopped  # Redémarre sauf si arrêté manuellement
    # Autres options : no, always, on-failure

services:
  web:
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:5000/health"]
      interval: 30s
      timeout: 10s
      retries: 3

services:
  web:
    networks:

      - frontend

      - backend

  db:
    networks:

      - backend

networks:
  frontend:
  backend:

services:
  db:
    image: postgres:15
    environment:
      POSTGRES_PASSWORD: ${DB_PASSWORD}

DB_PASSWORD=super_secret_password

# Docker Compose charge automatiquement .env
docker compose up -d

# MAUVAIS : Image complète (1+ Go)
FROM python:3.11

# BON : Image slim (~150 Mo)
FROM python:3.11-slim

# ENCORE MIEUX : Alpine (~50 Mo)
FROM python:3.11-alpine

# MAUVAIS : Réinstalle les dépendances à chaque changement de code
FROM python:3.11-slim
COPY . /app
RUN pip install -r /app/requirements.txt

# BON : Les dépendances sont en cache
FROM python:3.11-slim
COPY requirements.txt /app/
RUN pip install -r /app/requirements.txt
COPY . /app

# MAUVAIS : Tout dans un conteneur
services:
  monolithe:
    # web + db + cache + queue...

# BON : Un service par conteneur
services:
  web:
    image: mon-app
  db:
    image: postgres
  redis:
    image: redis
  worker:
    image: mon-worker

# Créer un utilisateur non-root
FROM python:3.11-slim

RUN useradd -m -r appuser && \
    mkdir /app && \
    chown appuser:appuser /app

WORKDIR /app
USER appuser

COPY --chown=appuser:appuser . .

.git
.gitignore
__pycache__
*.pyc
.env
.env.local
venv/
node_modules/
.pytest_cache/
*.md
docker-compose*.yml
Dockerfile*

# MAUVAIS : Quelle version ?
FROM python:latest

# BON : Version précise
FROM python:3.11.6-slim-bookworm

# Permettre la configuration sans reconstruire
ENV FLASK_ENV=production
ENV PORT=5000

CMD ["python", "app.py"]

# Overrider au lancement
docker run -e FLASK_ENV=development -e PORT=8080 mon-app

HEALTHCHECK --interval=30s --timeout=10s --start-period=5s --retries=3 \
  CMD curl -f http://localhost:5000/health || exit 1

# Build
FROM node:20 AS builder
WORKDIR /app
COPY package*.json ./
RUN npm ci
COPY . .
RUN npm run build

# Production
FROM node:20-alpine
WORKDIR /app
COPY --from=builder /app/dist ./dist
COPY --from=builder /app/node_modules ./node_modules
USER node
CMD ["node", "dist/index.js"]

# Les logs doivent aller sur stdout, pas dans des fichiers
import logging
import sys

logging.basicConfig(
    stream=sys.stdout,
    level=logging.INFO
)

# Logs d'un conteneur
docker logs mon-conteneur
docker logs -f mon-conteneur  # Suivre en temps réel
docker logs --tail 100 mon-conteneur  # 100 dernières lignes

# Statistiques en temps réel
docker stats

# Inspecter un conteneur
docker inspect mon-conteneur

# Voir les processus dans un conteneur
docker top mon-conteneur

# Conteneur en cours d'exécution
docker exec -it mon-conteneur bash
docker exec -it mon-conteneur sh  # Si pas de bash

# Démarrer un conteneur arrêté en mode debug
docker run -it --entrypoint bash mon-image

# Trouver ce qui utilise le port
sudo lsof -i :5000
# ou
docker ps  # Un autre conteneur ?

# Solution : utiliser un autre port
docker run -p 5001:5000 mon-app

# Voir l'espace utilisé
docker system df

# Nettoyer
docker system prune -a

# Supprimer les volumes orphelins
docker volume prune

# Voir les logs
docker logs mon-conteneur

# Le conteneur a besoin d'un processus qui tourne
# MAUVAIS :
CMD ["echo", "hello"]  # Se termine immédiatement

# BON :
CMD ["python", "app.py"]  # Processus qui reste actif

# Vérifier que les conteneurs sont sur le même réseau
docker network inspect mon-reseau

# Vérifier que le service est prêt
docker compose logs db

# Utiliser depends_on avec condition
services:
  web:
    depends_on:
      db:
        condition: service_healthy

# Voir tous les logs
docker compose logs

# Logs d'un service spécifique
docker compose logs -f web

# Reconstruire et relancer
docker compose up --build

# Voir la configuration finale (variables résolues)
docker compose config

# Dockerfile.prod
FROM python:3.11-slim

# Métadonnées
LABEL maintainer="toi@email.com"
LABEL version="1.0"

# Variables d'environnement de production
ENV PYTHONDONTWRITEBYTECODE=1
ENV PYTHONUNBUFFERED=1

# Utilisateur non-root
RUN useradd -m -r appuser

WORKDIR /app

# Dépendances
COPY requirements.txt .
RUN pip install --no-cache-dir -r requirements.txt

# Code
COPY --chown=appuser:appuser . .

USER appuser

EXPOSE 5000

# Healthcheck
HEALTHCHECK --interval=30s --timeout=10s --retries=3 \
  CMD curl -f http://localhost:5000/health || exit 1

# Gunicorn au lieu du serveur de développement Flask
CMD ["gunicorn", "--bind", "0.0.0.0:5000", "--workers", "4", "app:app"]

version: "3.8"

services:
  web:
    build:
      context: .
      dockerfile: Dockerfile.prod
    ports:

      - "5000:5000"
    environment:

      - FLASK_ENV=production

      - DATABASE_URL=${DATABASE_URL}
    restart: always
    deploy:
      replicas: 2
      resources:
        limits:
          cpus: "0.5"
          memory: 512M

  db:
    image: postgres:15-alpine
    environment:
      POSTGRES_PASSWORD: ${DB_PASSWORD}
    volumes:

      - postgres-data:/var/lib/postgresql/data
    restart: always

  nginx:
    image: nginx:alpine
    ports:

      - "80:80"

      - "443:443"
    volumes:

      - ./nginx.conf:/etc/nginx/nginx.conf:ro
    depends_on:

      - web
    restart: always

volumes:
  postgres-data:

# Se connecter à Docker Hub
docker login

# Taguer l'image
docker tag mon-app:latest ton-username/mon-app:1.0

# Pousser
docker push ton-username/mon-app:1.0

# Sur le serveur de production
docker pull ton-username/mon-app:1.0
docker run -d -p 5000:5000 ton-username/mon-app:1.0

# GitHub Container Registry
docker login ghcr.io
docker tag mon-app ghcr.io/ton-username/mon-app:1.0
docker push ghcr.io/ton-username/mon-app:1.0

# GitLab Container Registry
docker login registry.gitlab.com
docker tag mon-app registry.gitlab.com/ton-groupe/mon-projet:1.0
docker push registry.gitlab.com/ton-groupe/mon-projet:1.0

docker run IMAGE                    # Lancer un conteneur
docker run -d IMAGE                 # En arrière-plan
docker run -it IMAGE bash           # Mode interactif
docker run -p 8080:80 IMAGE         # Exposer un port
docker run -v /host:/container IMAGE # Monter un volume
docker run --name NOM IMAGE         # Nommer le conteneur
docker run -e VAR=valeur IMAGE      # Variable d'environnement
docker run --rm IMAGE               # Supprimer après arrêt

docker ps                           # Conteneurs actifs
docker ps -a                        # Tous les conteneurs
docker stop CONTENEUR               # Arrêter
docker start CONTENEUR              # Démarrer
docker restart CONTENEUR            # Redémarrer
docker rm CONTENEUR                 # Supprimer
docker rm -f CONTENEUR              # Forcer la suppression

docker logs CONTENEUR               # Voir les logs
docker logs -f CONTENEUR            # Suivre les logs
docker exec -it CONTENEUR bash      # Entrer dans le conteneur
docker inspect CONTENEUR            # Détails complets

docker images                       # Lister les images
docker pull IMAGE:TAG               # Télécharger
docker build -t NOM .               # Construire depuis Dockerfile
docker tag IMAGE NOM:TAG            # Taguer
docker push NOM:TAG                 # Pousser vers registre
docker rmi IMAGE                    # Supprimer
docker image prune                  # Nettoyer les images inutilisées

docker volume ls                    # Lister
docker volume create NOM            # Créer
docker volume rm NOM                # Supprimer
docker volume prune                 # Nettoyer

docker network ls                   # Lister
docker network create NOM           # Créer
docker network connect NET CONT     # Connecter un conteneur
docker network inspect NOM          # Détails

docker compose up                   # Lancer
docker compose up -d                # En arrière-plan
docker compose up --build           # Reconstruire et lancer
docker compose down                 # Arrêter et supprimer
docker compose down -v              # + supprimer les volumes
docker compose ps                   # Statut
docker compose logs                 # Logs
docker compose logs -f SERVICE      # Suivre les logs d'un service
docker compose exec SERVICE bash    # Entrer dans un service
docker compose build                # Construire les images
docker compose pull                 # Mettre à jour les images

docker system df                    # Espace utilisé
docker system prune                 # Nettoyer tout
docker system prune -a              # Tout, y compris images non utilisées
docker container prune              # Conteneurs arrêtés
docker image prune                  # Images orphelines
docker volume prune                 # Volumes orphelins