Cours Docker Complet 🐳

# Vérifier l'installation
docker –version # Docker version 27.x
docker compose version # Docker Compose v2.x

# Tester avec le conteneur hello-world
docker run hello-world
# → Télécharge l'image, crée un conteneur, exécute, affiche un message

# Mapper un port → accès depuis le navigateur
docker run -d -p 8080:80 nginx
# → http://localhost:8080 affiche la page Nginx
# Format : -p PORT_HOTE:PORT_CONTENEUR

# Lancer un shell interactif dans un conteneur
docker run -it ubuntu bash
# -i = interactif (garde stdin ouvert)
# -t = pseudo-terminal (TTY)

# Exécuter dans un conteneur en cours
docker exec -it mon-nginx bash
docker exec mon-nginx cat /etc/nginx/nginx.conf

# Arrêter / Démarrer / Redémarrer
docker stop mon-nginx # Arrêt gracieux (SIGTERM)
docker kill mon-nginx # Arrêt immédiat (SIGKILL)
docker start mon-nginx # Redémarrer un conteneur arrêté
docker restart mon-nginx

# Logs
docker logs mon-nginx # Tous les logs
docker logs -f mon-nginx # Suivre en temps réel (tail -f)
docker logs –tail 50 mon-nginx # 50 dernières lignes

# Inspecter
docker inspect mon-nginx # JSON complet (IP, volumes, config)
docker stats # CPU, RAM, réseau en temps réel

# Supprimer
docker rm mon-nginx # Supprimer un conteneur arrêté
docker rm -f mon-nginx # Forcer (même en cours)

# Nettoyage global
docker system prune -a # Tout supprimer (conteneurs, images, cache)

# Lister les images locales
docker images
docker image ls

# Supprimer une image
docker rmi node:20-alpine
docker image prune # Supprimer les images inutilisées

# 1. Image de base
FROM node:20-alpine

# 2. Dossier de travail dans le conteneur
WORKDIR /app

# 3. Copier les fichiers de dépendances EN PREMIER (cache Docker)
COPY package*.json ./

# 4. Installer les dépendances
RUN npm ci –only=production

# 5. Copier le reste du code
COPY . .

# 6. Port exposé (documentation)
EXPOSE 3000

# 7. Utilisateur non-root (sécurité)
USER node

# 8. Commande de démarrage
CMD [« node », « server.js »]

# Lancer
docker run -d -p 3000:3000 –name api mon-app:1.0

# .dockerignore — ne pas copier dans l'image
node_modules
.git
.env
npm-debug.log
Dockerfile
docker-compose.yml

WORKDIR /app

# Empêcher Python de bufferiser stdout (logs en temps réel)
ENV PYTHONUNBUFFERED=1
ENV PYTHONDONTWRITEBYTECODE=1

# Dépendances système si nécessaires
RUN apt-get update && apt-get install -y –no-install-recommends \
gcc libpq-dev \
&& rm -rf /var/lib/apt/lists/*

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

# Code
COPY . .

EXPOSE 8000

CMD [« gunicorn », « app:create_app() », « –bind », « 0.0.0.0:8000 »]

# 2. Bind Mount — dossier hôte → conteneur (développement)
docker run -d \
-v $(pwd)/src:/app/src \
-p 3000:3000 \
mon-app
# Modifications locales → visibles dans le conteneur (hot reload)

# 3. tmpfs — en mémoire (données temporaires)
docker run -d \
–tmpfs /tmp \
mon-app

# Lancer des conteneurs sur le même réseau
docker run -d –name db \
–network mon-reseau \
-e POSTGRES_PASSWORD=secret \
postgres:16

docker run -d –name api \
–network mon-reseau \
-p 3000:3000 \
-e DATABASE_URL=postgresql://postgres:secret@db:5432/postgres \
mon-app

# « db » est résolu automatiquement en IP par Docker DNS
# → Les conteneurs se parlent par leur NOM

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

# Étape 2 : Production (image légère, seulement le résultat)
FROM node:20-alpine
WORKDIR /app
COPY –from=builder /app/dist ./dist
COPY –from=builder /app/node_modules ./node_modules
COPY package*.json ./
USER node
EXPOSE 3000
CMD [« node », « dist/server.js »]

# Résultat : image finale ne contient PAS le code source,
# les devDependencies, ni les outils de build

# Ou avec curl
HEALTHCHECK –interval=30s –timeout=5s –retries=3 \
CMD curl -f http://localhost:3000/health || exit 1

# Vérifier le statut
docker ps # → affiche « healthy » ou « unhealthy »

services:
# Application Node.js
api:
build: .
ports:
– « 3000:3000 »
environment:
– DATABASE_URL=postgresql://postgres:secret@db:5432/mydb
– REDIS_URL=redis://cache:6379
– NODE_ENV=production
depends_on:
db:
condition: service_healthy
cache:
condition: service_started
restart: unless-stopped

# Base de données PostgreSQL
db:
image: postgres:16-alpine
environment:
POSTGRES_DB: mydb
POSTGRES_USER: postgres
POSTGRES_PASSWORD: secret
volumes:
– pgdata:/var/lib/postgresql/data
ports:
– « 5432:5432 »
healthcheck:
test: [« CMD-SHELL », « pg_isready -U postgres »] interval: 10s
timeout: 5s
retries: 5
restart: unless-stopped

# Cache Redis
cache:
image: redis:7-alpine
ports:
– « 6379:6379 »
restart: unless-stopped

volumes:
pgdata:

db:
image: postgres:16-alpine
environment:
POSTGRES_PASSWORD: secret
volumes:
– pgdata:/var/lib/postgresql/data

volumes:
pgdata:

db:
ports:
– « 5432:5432 » # Exposer pour les outils locaux

# Lancer en prod
docker compose -f compose.yml -f compose.prod.yml up -d

# compose.yml
services:
api:
ports:
– « $:3000 »
env_file:
– .env # Injecter toutes les variables

# GitHub Container Registry (ghcr.io)
docker login ghcr.io -u USERNAME
docker build -t ghcr.io/monuser/mon-app:1.0 .
docker push ghcr.io/monuser/mon-app:1.0

# Taguer une image
docker tag mon-app:1.0 monuser/mon-app:latest
docker tag mon-app:1.0 monuser/mon-app:1.0

on:
push:
branches: [main]

jobs:
build:
runs-on: ubuntu-latest
steps:
– uses: actions/checkout@v4

– name: Login to Docker Hub
uses: docker/login-action@v3
with:
username: $
password: $

– name: Build and push
uses: docker/build-push-action@v6
with:
push: true
tags: monuser/mon-app:latest,monuser/mon-app:$

# 2. Image minimale
FROM node:20-alpine # Moins de packages = moins de vulnérabilités

# 3. Scanner les vulnérabilités
docker scout cves mon-app:1.0

# 4. Ne pas stocker de secrets dans l'image
# ❌ ENV API_KEY=secret123
# ✅ Passer au runtime : docker run -e API_KEY=$API_KEY

# 5. Read-only filesystem
docker run –read-only –tmpfs /tmp mon-app