# Lancer un serveur web Nginx en 1 commande
docker run -d -p 8080:80 --name mon-nginx nginx

# Ouvrir http://localhost:8080 dans votre navigateur → page Nginx !

# Voir les containers en cours
docker ps

# Arrêter et supprimer
docker stop mon-nginx
docker rm mon-nginx

# Partir d'une image de base officielle
FROM node:20-alpine

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

# Copier les fichiers de dépendances
COPY package*.json ./

# Installer les dépendances
RUN npm install

# Copier le reste du code source
COPY . .

# Exposer le port sur lequel l'app tourne
EXPOSE 3000

# Commande lancée au démarrage du container
CMD ["node", "server.js"]

# Construire l'image (. = répertoire courant)
docker build -t mon-app:1.0 .

# Lancer le container depuis l'image
docker run -d -p 3000:3000 --name mon-app mon-app:1.0

# Voir les logs
docker logs -f mon-app

node_modules
.env
.env.*
.git
.gitignore
*.log
dist
coverage
README.md

# Build avec BuildKit (plus rapide, activé par défaut depuis Docker 23)
docker build -t monapp:1.0 .

# Build avec cache désactivé (forcer la reconstruction complète)
docker build --no-cache -t monapp:1.0 .

# Build depuis un Dockerfile non standard
docker build -f docker/Dockerfile.prod -t monapp:prod .

# Build avec build arguments (variables passées au build)
docker build --build-arg NODE_ENV=production -t monapp:prod .

# Build multi-platform (ex: x86 + ARM pour Apple Silicon)
docker buildx build --platform linux/amd64,linux/arm64 -t monapp:1.0 --push .

# Inspecter la taille de chaque layer
docker history --no-trunc monapp:1.0

docker run \
  -d \                          # mode détaché (background)
  --name mon-container \        # nom du container
  -p 8080:80 \                  # port hôte:port container
  -p 443:443 \                  # plusieurs ports possible
  -v mon-volume:/data \         # volume nommé
  -v $(pwd)/config:/app/config \# bind mount (chemin hôte:container)
  -e DATABASE_URL=postgres://…\ # variable d'environnement
  --env-file .env \             # charger un fichier .env
  --network mon-reseau \        # réseau Docker
  --restart unless-stopped \    # politique de redémarrage
  --memory 512m \               # limite RAM
  --cpus 1.5 \                  # limite CPU
  --rm \                        # supprimer le container à l'arrêt
  --user 1001:1001 \            # utilisateur non-root
  --read-only \                 # filesystem en lecture seule
  monimage:tag                  # image à utiliser

# Entrer dans un container en cours
docker exec -it mon-container bash
docker exec -it mon-container sh   # si bash absent (alpine)

# Container interactif jetable
docker run --rm -it ubuntu:22.04 bash

# Suivre les logs en live
docker logs -f --tail 100 mon-container

# ✅ BIEN : image légère
FROM node:20-alpine

# Créer un utilisateur non-root dès le début
RUN addgroup -S appgroup && adduser -S appuser -G appgroup

WORKDIR /app

# Copier package.json SÉPARÉMENT → meilleur cache
# Si le code change mais pas les deps, cette couche reste en cache
COPY package*.json ./
RUN npm ci --only=production && npm cache clean --force

# Copier le reste du code
COPY --chown=appuser:appgroup . .

# Passer à l'utilisateur non-root
USER appuser

EXPOSE 3000

# Healthcheck intégré
HEALTHCHECK --interval=30s --timeout=5s --start-period=10s --retries=3 \
  CMD wget -qO- http://localhost:3000/health || exit 1

# Préférer la forme exec (tableau JSON) à la forme shell
CMD ["node", "server.js"]

# ❌ Plusieurs RUN séparés = plusieurs layers inutiles
RUN apt-get update
RUN apt-get install -y curl
RUN apt-get install -y git

# ✅ Chaîner avec && et nettoyer dans le même RUN
RUN apt-get update && apt-get install -y \
    curl \
    git \
  && rm -rf /var/lib/apt/lists/*

# ❌ COPY tout en premier (invalide le cache à chaque modification de code)
COPY . .
RUN npm ci

# ✅ COPY package.json en premier, code source ensuite
COPY package*.json ./
RUN npm ci
COPY . .

# ❌ Laisser des outils de build dans l'image finale
RUN apt-get install -y build-essential && make && # outils présents dans l'image !
# ✅ Utiliser le multi-stage build (section 5)

# ─── Stage 1: Dépendances ────────────────────────────
FROM node:20-alpine AS deps
WORKDIR /app
COPY package*.json ./
RUN npm ci

# ─── Stage 2: Build ──────────────────────────────────
FROM node:20-alpine AS builder
WORKDIR /app
COPY --from=deps /app/node_modules ./node_modules
COPY . .
RUN npm run build

# ─── Stage 3: Tests (optionnel, ciblable séparément) ─
FROM builder AS test
RUN npm run test -- --coverage

# ─── Stage 4: Production ─────────────────────────────
FROM node:20-alpine AS production
WORKDIR /app
ENV NODE_ENV=production

RUN addgroup -S appgroup && adduser -S appuser -G appgroup

# Copier uniquement le build final + deps de prod
COPY --from=builder --chown=appuser:appgroup /app/dist ./dist
COPY --from=deps /app/node_modules ./node_modules
COPY --chown=appuser:appgroup package.json ./

USER appuser
EXPOSE 3000
CMD ["node", "dist/server.js"]

# Builder jusqu'au stage "production" uniquement
docker build --target production -t monapp:prod .

# Builder jusqu'au stage "test" (utile en CI)
docker build --target test -t monapp:test .

# Le stage "test" peut être lancé pour valider
docker run --rm monapp:test

# ARG : disponible uniquement pendant le build
ARG APP_VERSION=1.0.0
ARG BUILD_DATE

# ENV : persisté dans l'image, accessible au runtime
ENV NODE_ENV=production \
    PORT=3000 \
    APP_VERSION=${APP_VERSION}

LABEL org.opencontainers.image.version=${APP_VERSION} \
      org.opencontainers.image.created=${BUILD_DATE}

# Passer au build
# docker build --build-arg APP_VERSION=2.1.0 --build-arg BUILD_DATE=$(date -I) .

# HTTP healthcheck (wget disponible sur alpine)
HEALTHCHECK \
  --interval=30s \    # fréquence de vérification
  --timeout=5s \      # délai max par check
  --start-period=30s \# délai avant 1er check (app en démarrage)
  --retries=3 \       # nb d'échecs avant unhealthy
  CMD wget -qO- http://localhost:3000/health || exit 1

# Voir l'état de santé
# docker inspect --format='{{.State.Health.Status}}' monapp
# docker inspect --format='{{json .State.Health}}' monapp | jq

#!/bin/sh   # docker-entrypoint.sh
set -e

# Attendre que la base de données soit prête
until nc -z ${DB_HOST:-db} ${DB_PORT:-5432}; do
  echo "Waiting for PostgreSQL..."
  sleep 2
done

# Lancer les migrations
node dist/migrate.js

# Lancer l'application avec les arguments passés à docker run
exec "$@"

COPY docker-entrypoint.sh /usr/local/bin/
RUN chmod +x /usr/local/bin/docker-entrypoint.sh
ENTRYPOINT ["docker-entrypoint.sh"]
CMD ["node", "dist/server.js"]

# ─── Volumes nommés ──────────────────────────────────
docker volume create mon-volume
docker volume ls
docker volume inspect mon-volume
docker volume rm mon-volume
docker volume prune         # supprimer volumes non utilisés

# Monter un volume dans un container
docker run -d -v mon-volume:/data postgres:16-alpine

# ─── Bind mount (développement) ──────────────────────
# Code source monté en live → hot reload
docker run -d \
  -v $(pwd)/src:/app/src \
  -v $(pwd)/public:/app/public \
  -p 3000:3000 monapp:dev

# ─── Partager un volume entre containers ─────────────
docker run -d --name db -v pgdata:/var/lib/postgresql/data postgres:16
docker run -d --name app -v pgdata:/backups:ro backup-tool

# ─── Sauvegarder / restaurer un volume ───────────────
# Backup
docker run --rm -v mon-volume:/data -v $(pwd):/backup alpine \
  tar czf /backup/mon-volume.tar.gz -C /data .

# Restore
docker run --rm -v mon-volume:/data -v $(pwd):/backup alpine \
  tar xzf /backup/mon-volume.tar.gz -C /data

# Créer un réseau bridge personnalisé
docker network create mon-reseau
docker network create --driver bridge --subnet 172.20.0.0/16 mon-reseau

# Lister les réseaux
docker network ls
docker network inspect mon-reseau

# Connecter des containers au même réseau
docker run -d --name db --network mon-reseau postgres:16-alpine
docker run -d --name app --network mon-reseau -p 3000:3000 monapp

# Depuis "app", accéder à "db" par son nom (DNS automatique)
# DATABASE_URL=postgres://user:pass@db:5432/mydb  ← "db" résolu automatiquement !

# Connecter un container existant à un réseau
docker network connect mon-reseau mon-container
docker network disconnect mon-reseau mon-container

# Supprimer un réseau
docker network rm mon-reseau
docker network prune   # supprimer réseaux non utilisés

# Version de la syntaxe Compose
version: '3.9'

services:
  # ─── Application Node.js ─────────────────────────
  app:
    build:
      context: .
      dockerfile: Dockerfile
      target: production          # stage multi-stage
    image: monapp:latest
    container_name: monapp
    restart: unless-stopped
    ports:
      - "3000:3000"
    environment:
      NODE_ENV: production
      DATABASE_URL: postgres://user:password@db:5432/mydb
      REDIS_URL: redis://cache:6379
    env_file:
      - .env                      # variables depuis fichier
    depends_on:
      db:
        condition: service_healthy # attendre que db soit healthy
      cache:
        condition: service_started
    networks:
      - backend
    volumes:
      - ./uploads:/app/uploads
    healthcheck:
      test: ["CMD", "wget", "-qO-", "http://localhost:3000/health"]
      interval: 30s
      timeout: 5s
      retries: 3

  # ─── Base de données PostgreSQL ───────────────────
  db:
    image: postgres:16-alpine
    container_name: postgres
    restart: unless-stopped
    environment:
      POSTGRES_USER: user
      POSTGRES_PASSWORD: password
      POSTGRES_DB: mydb
    volumes:
      - pgdata:/var/lib/postgresql/data
      - ./db/init.sql:/docker-entrypoint-initdb.d/init.sql
    networks:
      - backend
    healthcheck:
      test: ["CMD-SHELL", "pg_isready -U user -d mydb"]
      interval: 10s
      timeout: 5s
      retries: 5

  # ─── Cache Redis ──────────────────────────────────
  cache:
    image: redis:7-alpine
    container_name: redis
    restart: unless-stopped
    command: redis-server --appendonly yes --maxmemory 256mb
    volumes:
      - redisdata:/data
    networks:
      - backend

networks:
  backend:
    driver: bridge

volumes:
  pgdata:
  redisdata:

# docker-compose.yml          ← base commune (partagée)
# docker-compose.override.yml ← dev (chargé automatiquement)
# docker-compose.prod.yml     ← production (spécifié manuellement)

# Développement (override automatique)
docker compose up

# Production
docker compose -f docker-compose.yml -f docker-compose.prod.yml up -d

# CI/CD
docker compose -f docker-compose.yml -f docker-compose.ci.yml up --build --exit-code-from tests

version: '3.9'
services:
  app:
    build:
      target: development        # stage dev du multi-stage
    volumes:
      - .:/app                   # bind mount pour hot reload
      - /app/node_modules        # exclure node_modules du bind
    environment:
      NODE_ENV: development
      DEBUG: "app:*"
    ports:
      - "9229:9229"               # port debug Node.js
    command: npm run dev         # surcharger CMD du Dockerfile

  db:
    ports:
      - "5432:5432"               # exposer PG en dev seulement

services:
  app:
    image: monapp
    # pas de profile = toujours démarré

  adminer:
    image: adminer
    profiles: ["tools"]           # démarré uniquement si profil activé
    ports:
      - "8080:8080"

  mailhog:
    image: mailhog/mailhog
    profiles: ["tools", "dev"]
    ports:
      - "1025:1025"
      - "8025:8025"

# Activer un profile
# docker compose --profile tools up -d
# COMPOSE_PROFILES=tools docker compose up -d

# Définir des blocs réutilisables
x-common-env: &common-env
  NODE_ENV: production
  TZ: Europe/Paris
  LOG_LEVEL: info

x-common-labels: &common-labels
  labels:
    app: monapp
    env: production

services:
  api:
    image: monapp-api
    environment:
      <<: *common-env
      PORT: 3001
    <<: *common-labels

  worker:
    image: monapp-worker
    environment:
      <<: *common-env
      WORKER_CONCURRENCY: 4
    <<: *common-labels

# Scaler un service à 3 instances
docker compose up -d --scale worker=3

# Dans le compose, déclarer le deploy (pour Swarm aussi)
services:
  worker:
    image: monapp-worker
    deploy:
      replicas: 3
      restart_policy:
        condition: on-failure
        max_attempts: 3
      resources:
        limits:
          cpus: '0.5'
          memory: 256M

# ─── Docker Hub ──────────────────────────────────────
docker login                              # login interactif
docker login -u $USER -p $TOKEN           # login non-interactif (CI)

docker tag monapp:1.0 monuser/monapp:1.0
docker push monuser/monapp:1.0
docker pull monuser/monapp:1.0

# ─── GitHub Container Registry ───────────────────────
echo $GITHUB_TOKEN | docker login ghcr.io -u $GITHUB_USER --password-stdin
docker tag monapp:1.0 ghcr.io/monorg/monapp:1.0
docker push ghcr.io/monorg/monapp:1.0

# ─── AWS ECR ─────────────────────────────────────────
aws ecr get-login-password --region eu-west-1 | \
  docker login --username AWS --password-stdin 123456789.dkr.ecr.eu-west-1.amazonaws.com
docker tag monapp:1.0 123456789.dkr.ecr.eu-west-1.amazonaws.com/monapp:1.0
docker push 123456789.dkr.ecr.eu-west-1.amazonaws.com/monapp:1.0

# ─── Registry privé local (développement/CI) ─────────
docker run -d -p 5000:5000 --name registry registry:2
docker tag monapp:1.0 localhost:5000/monapp:1.0
docker push localhost:5000/monapp:1.0
docker pull localhost:5000/monapp:1.0

# ✅ Tags recommandés par build
IMAGE=ghcr.io/monorg/monapp
COMMIT=$(git rev-parse --short HEAD)
VERSION=$(git describe --tags --abbrev=0 2>/dev/null || echo "dev")

docker build \
  -t $IMAGE:$VERSION \      # ex: v1.2.3
  -t $IMAGE:$COMMIT \       # ex: a1b2c3d (traçabilité)
  -t $IMAGE:latest \        # toujours pointer vers le dernier
  .

# ✅ Immutable tags en production : utiliser le sha256 digest
docker pull monapp@sha256:abc123def456...
# Garantit qu'on lance exactement cette image, même si le tag change

version: '3.9'
services:
  app:
    image: monapp
    secrets:
      - db_password
      - api_key
    environment:
      # L'app lit /run/secrets/db_password au runtime
      DB_PASSWORD_FILE: /run/secrets/db_password

  db:
    image: postgres:16-alpine
    secrets:
      - db_password
    environment:
      POSTGRES_PASSWORD_FILE: /run/secrets/db_password

secrets:
  db_password:
    file: ./secrets/db_password.txt   # fichier local (dev)
  api_key:
    external: true                     # secret Swarm externe (prod)

// Lire le secret depuis le fichier monté par Docker
const readSecret = (name) => {
  const path = `/run/secrets/${name}`;
  try {
    return require('fs').readFileSync(path, 'utf8').trim();
  } catch {
    // Fallback sur variable d'environnement (dev sans secret)
    return process.env[name.toUpperCase()] || null;
  }
};

const dbPassword = readSecret('db_password');

# Limites via docker run
docker run \
  --memory 512m \          # max RAM (aussi: 1g, 256m)
  --memory-swap 512m \     # =memory → désactive le swap
  --cpus 1.5 \             # max 1.5 cores
  --cpu-shares 512 \       # priorité relative (défaut 1024)
  monapp

# Vérifier en live
docker stats monapp

# Dans Compose
services:
  app:
    deploy:
      resources:
        limits:
          cpus: '1.0'
          memory: 512M
        reservations:
          cpus: '0.25'
          memory: 128M

docker run \
  --name monapp \
  --user 1001:1001 \
  --read-only \
  --tmpfs /tmp:rw,noexec,nosuid,size=64m \
  --cap-drop ALL \
  --cap-add NET_BIND_SERVICE \
  --security-opt no-new-privileges \
  --security-opt seccomp=/etc/docker/seccomp.json \
  --pids-limit 200 \
  --memory 512m \
  --memory-swap 512m \
  --cpus 1.0 \
  --network mon-reseau \
  --restart unless-stopped \
  -p 3000:3000 \
  monapp:1.0

# Installer Trivy (scanner de vulnérabilités open-source)
docker run --rm -v /var/run/docker.sock:/var/run/docker.sock \
  aquasec/trivy:latest image monapp:1.0

# Rapport en JSON
docker run --rm -v /var/run/docker.sock:/var/run/docker.sock \
  aquasec/trivy:latest image --format json monapp:1.0 > rapport.json

# Docker Scout (intégré dans Docker Desktop)
docker scout cves monapp:1.0
docker scout recommendations monapp:1.0

mon-projet/
├── Dockerfile                    # multi-stage
├── docker-compose.yml            # base
├── docker-compose.override.yml   # dev
├── docker-compose.prod.yml       # prod
├── .dockerignore
├── .env.example                  # template (committé)
├── .env                          # valeurs réelles (ignoré par git)
├── nginx/
│   ├── nginx.conf
│   └── ssl/
├── src/
│   └── server.js
└── package.json

# ── Stage deps ────────────────────────────────────────
FROM node:20-alpine AS deps
WORKDIR /app
COPY package*.json ./
RUN npm ci --only=production && npm cache clean --force

# ── Stage dev (hot reload, debug) ─────────────────────
FROM node:20-alpine AS development
WORKDIR /app
COPY package*.json ./
RUN npm ci
COPY . .
ENV NODE_ENV=development
EXPOSE 3000 9229
CMD ["npm", "run", "dev"]

# ── Stage production ───────────────────────────────────
FROM node:20-alpine AS production
WORKDIR /app

RUN addgroup -S appgroup && adduser -S appuser -G appgroup

COPY --from=deps --chown=appuser:appgroup /app/node_modules ./node_modules
COPY --chown=appuser:appgroup . .

ENV NODE_ENV=production \
    PORT=3000

USER appuser
EXPOSE 3000

HEALTHCHECK --interval=30s --timeout=5s --start-period=20s --retries=3 \
  CMD wget -qO- http://localhost:3000/health || exit 1

CMD ["node", "src/server.js"]

version: '3.9'

services:
  nginx:
    image: nginx:1.25-alpine
    ports:
      - "80:80"
      - "443:443"
    volumes:
      - ./nginx/nginx.conf:/etc/nginx/nginx.conf:ro
      - ./nginx/ssl:/etc/nginx/ssl:ro
      - static_files:/app/public:ro
    depends_on:
      app:
        condition: service_healthy
    networks:
      - frontend
    restart: unless-stopped

  app:
    build:
      context: .
      target: production
    env_file: .env
    environment:
      DATABASE_URL: postgres://${DB_USER}:${DB_PASS}@db:5432/${DB_NAME}
      REDIS_URL: redis://cache:6379
    depends_on:
      db:
        condition: service_healthy
      cache:
        condition: service_started
    networks:
      - frontend
      - backend
    restart: unless-stopped
    volumes:
      - static_files:/app/public

  db:
    image: postgres:16-alpine
    env_file: .env
    environment:
      POSTGRES_USER: ${DB_USER}
      POSTGRES_PASSWORD: ${DB_PASS}
      POSTGRES_DB: ${DB_NAME}
    volumes:
      - pgdata:/var/lib/postgresql/data
      - ./db/init.sql:/docker-entrypoint-initdb.d/01-init.sql:ro
    networks:
      - backend
    restart: unless-stopped
    healthcheck:
      test: ["CMD-SHELL", "pg_isready -U ${DB_USER} -d ${DB_NAME}"]
      interval: 10s
      timeout: 5s
      retries: 5

  cache:
    image: redis:7-alpine
    command: redis-server --appendonly yes --maxmemory 128mb --maxmemory-policy allkeys-lru
    volumes:
      - redisdata:/data
    networks:
      - backend
    restart: unless-stopped

networks:
  frontend:
    driver: bridge
  backend:
    driver: bridge
    internal: true    # réseau interne, pas d'accès internet direct

volumes:
  pgdata:
  redisdata:
  static_files:

events { worker_connections 1024; }

http {
  upstream api {
    server app:3000;          # résolution DNS Compose
    keepalive 32;
  }

  # Redirect HTTP → HTTPS
  server {
    listen 80;
    return 301 https://$host$request_uri;
  }

  server {
    listen 443 ssl http2;
    ssl_certificate     /etc/nginx/ssl/cert.pem;
    ssl_certificate_key /etc/nginx/ssl/key.pem;
    ssl_protocols       TLSv1.2 TLSv1.3;

    # API proxy
    location /api/ {
      proxy_pass         http://api;
      proxy_set_header   Host $host;
      proxy_set_header   X-Real-IP $remote_addr;
      proxy_set_header   X-Forwarded-For $proxy_add_x_forwarded_for;
      proxy_set_header   X-Forwarded-Proto $scheme;
    }

    # Fichiers statiques
    location / {
      root  /app/public;
      try_files $uri $uri/ /index.html;
      gzip on;
      expires 1d;
    }
  }
}

# Base de données
DB_USER=monapp
DB_PASS=changeme
DB_NAME=monapp_db

# Application
NODE_ENV=production
JWT_SECRET=changeme_secret_32chars_minimum
SESSION_SECRET=changeme_session_secret

# Redis
REDIS_TTL=3600

# Premier déploiement
cp .env.example .env   # adapter les valeurs !
docker compose up -d --build

# Mise à jour sans downtime
docker compose pull app
docker compose up -d --no-deps --build app

# Voir l'état de la stack
docker compose ps
docker compose logs -f --tail 50

# Backup base de données
docker compose exec db pg_dump -U $DB_USER $DB_NAME > backup-$(date +%Y%m%d).sql

# Restaurer
docker compose exec -T db psql -U $DB_USER $DB_NAME < backup.sql