Docker Conteneurisation

docker images                          # Lister les images locales
docker image ls                        # Équivalent moderne
docker image ls -a                     # Inclure les images intermédiaires
docker pull nginx                      # Télécharger l'image officielle nginx (tag :latest)
docker pull nginx:1.25-alpine          # Version spécifique avec tag
docker image inspect nginx             # Détails complets d'une image (JSON)
docker image history nginx             # Afficher les couches d'une image
docker image rm nginx                  # Supprimer une image
docker rmi nginx nginx:1.25-alpine     # Supprimer plusieurs images
docker image prune                     # Supprimer les images orphelines (dangling)
docker image prune -a                  # Supprimer toutes les images non utilisées

docker build .                         # Build depuis le dossier courant
docker build -t mon-app:1.0 .          # Nommer et tagger l'image
docker build -t mon-app:latest -f Dockerfile.prod .  # Dockerfile personnalisé
docker build --no-cache -t mon-app .   # Forcer la reconstruction sans cache
docker build --build-arg ENV=prod .    # Passer un argument de build

# Exemple complet : build d'une app Node.js
docker build -t mon-app-node:1.0 --build-arg NODE_ENV=production .

docker tag mon-app:1.0 monuser/mon-app:1.0     # Tagger pour Docker Hub
docker tag mon-app:1.0 mon-app:latest           # Ajouter le tag latest
docker push monuser/mon-app:1.0                 # Pousser vers Docker Hub
docker push monuser/mon-app:latest

# Avec GitHub Container Registry
docker tag mon-app:1.0 ghcr.io/monuser/mon-app:1.0
docker push ghcr.io/monuser/mon-app:1.0

docker run nginx                        # Lancer nginx (foreground, bloque le terminal)
docker run -d nginx                     # Mode détaché (arrière-plan)
docker run -d --name mon-nginx nginx    # Nommer le conteneur
docker run -d -p 8080:80 nginx         # Mapper port hôte:conteneur
docker run -d -p 8080:80 -p 443:443 nginx  # Plusieurs ports
docker run -it ubuntu bash              # Mode interactif avec terminal
docker run --rm ubuntu echo "hello"    # Supprimer le conteneur après exécution
docker run -d -e APP_ENV=prod nginx    # Définir une variable d'environnement
docker run -d --env-file .env nginx    # Charger les variables depuis un fichier
docker run -d -v /host/data:/app/data nginx  # Monter un dossier hôte (bind mount)
docker run -d -v mon-volume:/app/data nginx  # Monter un volume nommé
docker run -d --network mon-reseau nginx     # Connecter à un réseau
docker run -d --restart unless-stopped nginx # Redémarrage automatique

# Exemple complet : app Node.js
docker run -d \
  --name api-prod \
  -p 3000:3000 \
  -e NODE_ENV=production \
  -e DB_URL=mongodb://mongo:27017/mydb \
  --network app-network \
  --restart unless-stopped \
  mon-app-node:1.0

docker ps                           # Lister les conteneurs en cours d'exécution
docker ps -a                        # Tous les conteneurs (y compris arrêtés)
docker ps -q                        # Seulement les IDs
docker start mon-nginx              # Démarrer un conteneur arrêté
docker stop mon-nginx               # Arrêter proprement (SIGTERM, puis SIGKILL)
docker stop -t 5 mon-nginx          # Timeout avant SIGKILL (5 secondes)
docker kill mon-nginx               # Arrêt forcé immédiat (SIGKILL)
docker restart mon-nginx            # Redémarrer
docker pause mon-nginx              # Suspendre les processus
docker unpause mon-nginx            # Reprendre
docker rm mon-nginx                 # Supprimer un conteneur arrêté
docker rm -f mon-nginx              # Forcer la suppression (même si en cours)
docker rm $(docker ps -aq)          # Supprimer tous les conteneurs arrêtés

# Logs
docker logs mon-nginx               # Afficher les logs
docker logs -f mon-nginx            # Suivre les logs en temps réel (follow)
docker logs --tail 50 mon-nginx     # 50 dernières lignes
docker logs --since 1h mon-nginx    # Logs de la dernière heure

# Exécuter une commande dans un conteneur actif
docker exec mon-nginx ls /etc/nginx
docker exec -it mon-nginx bash      # Ouvrir un shell interactif
docker exec -it mon-nginx sh        # Si bash n'est pas disponible (alpine)
docker exec -e VAR=val mon-nginx env # Avec une variable d'environnement

# Copier des fichiers
docker cp mon-nginx:/etc/nginx/nginx.conf ./nginx.conf  # Conteneur → hôte
docker cp ./mon-fichier.conf mon-nginx:/etc/nginx/      # Hôte → conteneur

# Inspecter
docker inspect mon-nginx            # Toutes les infos (JSON)
docker inspect --format '{{.NetworkSettings.IPAddress}}' mon-nginx  # IP du conteneur
docker stats                        # CPU, mémoire, réseau en temps réel
docker stats mon-nginx              # Stats d'un seul conteneur
docker top mon-nginx                # Processus en cours dans le conteneur
docker port mon-nginx               # Mappings de ports

# Image de base légère
FROM node:20-alpine

# Métadonnées
LABEL maintainer="dev@exemple.fr"
LABEL version="1.0"

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

# Copier d'abord les fichiers de dépendances (optimise le cache)
COPY package*.json ./

# Installer les dépendances
RUN npm ci --only=production

# Copier le reste du code source
COPY . .

# Variable d'environnement
ENV NODE_ENV=production
ENV PORT=3000

# Créer un utilisateur non-root pour la sécurité
RUN addgroup -S appgroup && adduser -S appuser -G appgroup
USER appuser

# Documenter le port
EXPOSE 3000

# Vérification de santé
HEALTHCHECK --interval=30s --timeout=3s --start-period=5s \
  CMD wget -qO- http://localhost:3000/health || exit 1

# Commande de démarrage
CMD ["node", "src/index.js"]

# ===== ÉTAPE 1 : Build =====
FROM node:20-alpine AS builder

WORKDIR /app
COPY package*.json ./
RUN npm ci
COPY . .
RUN npm run build          # Génère le dossier dist/

# ===== ÉTAPE 2 : Production =====
FROM nginx:1.25-alpine AS production

# Copier uniquement le résultat du build
COPY --from=builder /app/dist /usr/share/nginx/html

# Copier la configuration nginx personnalisée
COPY nginx.conf /etc/nginx/conf.d/default.conf

EXPOSE 80
CMD ["nginx", "-g", "daemon off;"]

node_modules/
npm-debug.log
.git/
.gitignore
.env
.env.local
*.md
dist/
coverage/
.DS_Store
*.log

# Bonne pratique : ENTRYPOINT fixe l'exécutable, CMD les arguments par défaut
ENTRYPOINT ["node"]
CMD ["src/index.js"]

# docker run mon-app             → node src/index.js
# docker run mon-app src/cli.js  → node src/cli.js

docker volume ls                       # Lister les volumes
docker volume create mon-volume        # Créer un volume nommé
docker volume inspect mon-volume       # Détails d'un volume (emplacement, etc.)
docker volume rm mon-volume            # Supprimer un volume
docker volume prune                    # Supprimer les volumes non utilisés

# Utiliser un volume avec un conteneur
docker run -d \
  -v mon-volume:/var/lib/postgresql/data \
  -e POSTGRES_PASSWORD=secret \
  --name postgres-db \
  postgres:16-alpine

# Bind mount en développement (code source synchronisé)
docker run -d \
  -v $(pwd):/app \
  -v /app/node_modules \
  -p 3000:3000 \
  mon-app-node:dev

# Volume en lecture seule
docker run -d -v mon-volume:/app/data:ro nginx

docker network ls                              # Lister les réseaux
docker network create app-network              # Créer un réseau bridge
docker network create --driver bridge --subnet 172.20.0.0/16 app-network
docker network inspect app-network             # Détails du réseau
docker network rm app-network                  # Supprimer un réseau
docker network prune                           # Supprimer les réseaux inutilisés

# Connecter des conteneurs à un réseau
docker run -d --name api --network app-network mon-api
docker run -d --name db  --network app-network postgres:16-alpine

# L'API peut maintenant joindre la DB via le nom "db" :
# postgresql://db:5432/mydb

# Connecter/déconnecter un conteneur existant
docker network connect    app-network mon-nginx
docker network disconnect app-network mon-nginx

# Utiliser le réseau hôte (Linux)
docker run -d --network host nginx

services:

  # Service API Node.js
  api:
    build:
      context: .
      dockerfile: Dockerfile
      args:
        NODE_ENV: production
    image: mon-api:latest
    container_name: mon-api
    restart: unless-stopped
    ports:
      - "3000:3000"
    environment:
      - NODE_ENV=production
      - DB_URL=mongodb://mongo:27017/mydb
      - REDIS_URL=redis://redis:6379
    env_file:
      - .env
    depends_on:
      mongo:
        condition: service_healthy
      redis:
        condition: service_started
    volumes:
      - ./logs:/app/logs
    networks:
      - app-network
    healthcheck:
      test: ["CMD", "wget", "-qO-", "http://localhost:3000/health"]
      interval: 30s
      timeout: 5s
      retries: 3

  # Base de données MongoDB
  mongo:
    image: mongo:7-jammy
    container_name: mon-mongo
    restart: unless-stopped
    environment:
      MONGO_INITDB_ROOT_USERNAME: admin
      MONGO_INITDB_ROOT_PASSWORD: secret
    volumes:
      - mongo-data:/data/db
      - ./mongo-init.js:/docker-entrypoint-initdb.d/init.js:ro
    networks:
      - app-network
    healthcheck:
      test: ["CMD", "mongosh", "--eval", "db.adminCommand('ping')"]
      interval: 10s
      timeout: 5s
      retries: 5

  # Cache Redis
  redis:
    image: redis:7-alpine
    container_name: mon-redis
    restart: unless-stopped
    volumes:
      - redis-data:/data
    networks:
      - app-network

volumes:
  mongo-data:
  redis-data:

networks:
  app-network:
    driver: bridge

docker compose up                      # Démarrer tous les services (foreground)
docker compose up -d                   # Mode détaché (arrière-plan)
docker compose up --build              # Rebuild les images avant de démarrer
docker compose up -d --build           # Rebuild + démarrage en arrière-plan
docker compose up api                  # Démarrer uniquement le service "api"

docker compose down                    # Arrêter et supprimer les conteneurs + réseaux
docker compose down -v                 # + supprimer les volumes
docker compose down --rmi all          # + supprimer les images buildées

docker compose stop                    # Arrêter les conteneurs (sans les supprimer)
docker compose start                   # Redémarrer les conteneurs stoppés
docker compose restart                 # Redémarrer tous les services
docker compose restart api             # Redémarrer un service spécifique

docker compose ps                      # État des services
docker compose logs                    # Logs de tous les services
docker compose logs -f api             # Suivre les logs du service "api"
docker compose logs --tail 50 api

docker compose exec api bash           # Shell dans le service "api"
docker compose exec api node --version # Exécuter une commande

docker compose build                   # Construire les images sans démarrer
docker compose pull                    # Télécharger les dernières images
docker compose config                  # Valider et afficher la config résolue
docker compose top                     # Processus dans chaque service

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

# Utiliser plusieurs fichiers (mergés dans l'ordre)
docker compose -f docker-compose.yml -f docker-compose.prod.yml up -d

# Fichiers courants
# docker-compose.yml          → config de base
# docker-compose.override.yml → dev (chargé auto)
# docker-compose.prod.yml     → production

# docker-compose.override.yml (développement)
services:
  api:
    build:
      target: development
    volumes:
      - .:/app                 # Code source synchronisé
      - /app/node_modules
    environment:
      - NODE_ENV=development
    command: npm run dev        # Remplace CMD du Dockerfile

# Authentification
docker login                           # Docker Hub (interactif)
docker login -u monuser                # Spécifier le nom d'utilisateur
docker login ghcr.io                   # GitHub Container Registry
docker logout                          # Se déconnecter

# Chercher des images sur Docker Hub
docker search nginx
docker search --filter is-official=true nginx

# Nommer et pousser une image
docker tag mon-app:1.0 monuser/mon-app:1.0
docker push monuser/mon-app:1.0
docker push monuser/mon-app:latest

# Télécharger une image spécifique
docker pull monuser/mon-app:1.0

# Sauvegarder/charger une image en fichier tar (sans registry)
docker save -o mon-app.tar mon-app:1.0
docker load -i mon-app.tar

# Exporter/importer un conteneur (système de fichiers uniquement)
docker export mon-conteneur -o snapshot.tar
docker import snapshot.tar mon-app:snapshot

# Nettoyage ciblé
docker container prune           # Supprimer tous les conteneurs arrêtés
docker image prune               # Supprimer les images dangling (sans tag)
docker image prune -a            # Supprimer toutes les images non utilisées
docker volume prune              # Supprimer les volumes non attachés
docker network prune             # Supprimer les réseaux inutilisés
docker builder prune             # Supprimer le cache de build

# Nettoyage global (tout en une commande)
docker system prune              # Conteneurs + réseaux + images dangling
docker system prune -a           # + toutes les images non utilisées
docker system prune -a --volumes # + volumes (ATTENTION : perte de données)

# Inspecter l'espace utilisé
docker system df                 # Résumé de l'espace disque Docker
docker system df -v              # Détails par objet

# === DÉVELOPPEMENT ===

# 1. Démarrer l'environnement de dev (avec hot-reload)
docker compose up -d

# 2. Voir les logs en temps réel
docker compose logs -f api

# 3. Ouvrir un shell dans le conteneur
docker compose exec api bash

# 4. Relancer uniquement un service après modification
docker compose restart api

# === MISE EN PRODUCTION ===

# 1. Build de l'image avec tag de version
docker build -t monuser/mon-app:2.1.0 -t monuser/mon-app:latest .

# 2. Tester l'image localement
docker run --rm -p 3000:3000 monuser/mon-app:2.1.0

# 3. Pousser vers le registry
docker push monuser/mon-app:2.1.0
docker push monuser/mon-app:latest

# 4. Déployer sur le serveur
docker compose -f docker-compose.yml -f docker-compose.prod.yml pull
docker compose -f docker-compose.yml -f docker-compose.prod.yml up -d

# 5. Vérifier le déploiement
docker compose ps
docker compose logs --tail 20 api

# 6. Nettoyer les anciennes images
docker image prune -f