Docker de zero

# Lancer un serveur web Nginx en arrière-plan
docker run --name web -p 8080:80 -d nginx:1.25

# Ouvrir http://localhost:8080 dans ton navigateur
# Tu vois la page d'accueil de Nginx

# Voir les conteneurs en cours
docker ps

# arrêter le conteneur
docker stop web

# Le redémarrer
docker start web

# Le supprimer (il doit être arrete d'abord)
docker rm web

# Lancer un shell bash dans Ubuntu (temporaire, supprime a la sortie)
docker run -it --rm ubuntu:24.04 bash

# Tu es maintenant dans le conteneur. Essaye :
apt update
apt install -y curl
curl http://localhost
exit   # quitte ET supprime le conteneur (--rm)

# télécharger une image sans la lancer
docker pull python:3.12-slim

# Lister les images locales
docker images

# Supprimer une image
docker rmi python:3.12-slim

# Supprimer les images inutilisees
docker image prune

# Supprimer toutes les images non utilisees (attention)
docker image prune -a

FROM node:20-alpine

WORKDIR /app

COPY package.json package-lock.json ./
RUN npm ci --only=production

COPY . .

EXPOSE 3000

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

# Construire une image nommee "mon-api" avec le tag "v1"
docker build -t mon-api:v1 .

# Le point final est important : c'est le "contexte de build"
# (le dossier envoye a Docker pour construire l'image)

# Lancer l'image construite
docker run -p 3000:3000 mon-api:v1

node_modules
npm-debug.log
.git
.env
.DS_Store
*.md
test/

# Volume nomme : Docker stocke les donnees pour toi
docker run -d --name db -v pg-data:/var/lib/postgresql/data postgres:16-alpine

# Bind mount : monte un dossier de ta machine
docker run -d --name web -p 8080:80 -v ./site:/usr/share/nginx/html nginx:1.25

# Lister les volumes
docker volume ls

# Voir les details d'un volume
docker volume inspect pg-data

# Supprimer un volume (les donnees sont perdues !)
docker volume rm pg-data

# Supprimer tous les volumes inutilises
docker volume prune

# 1. créer un réseau
docker network create mon-réseau

# 2. Lancer une base de donnees sur ce réseau
docker run -d --name db --network mon-réseau \
  -e POSTGRES_PASSWORD=secret \
  postgres:16-alpine

# 3. Lancer une app qui peut joindre "db" par son nom
docker run -d --name api --network mon-réseau \
  -p 3000:3000 \
  -e DB_HOST=db \
  -e DB_PORT=5432 \
  mon-api:v1

# L'API peut se connecter a "db:5432" (DNS interne de Docker)

# Variable unique
docker run -e PORT=3000 mon-api:v1

# Plusieurs variables
docker run -e PORT=3000 -e DB_HOST=db mon-api:v1

# Depuis un fichier .env
docker run --env-file .env mon-api:v1

FROM node:20-alpine
ENV NODE_ENV=production
ENV PORT=3000
# Ces valeurs sont des valeurs par defaut, surchargeables au runtime

services:
  web:
    image: nginx:1.25-alpine
    ports:
      - "8080:80"
    volumes:
      - ./site:/usr/share/nginx/html

  api:
    build: .
    ports:
      - "3000:3000"
    environment:
      - DB_HOST=db
      - DB_PORT=5432
    depends_on:
      - db

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

volumes:
  pg-data:

# Lancer tous les services (en arrière-plan)
docker compose up -d

# Lancer et construire les images en même temps
docker compose up -d --build

# Voir les services en cours
docker compose ps

# Voir les logs de tous les services
docker compose logs -f

# Voir les logs d'un service precis
docker compose logs -f api

# exécuter une commande dans un service
docker compose exec api sh

# arrêter et supprimer les conteneurs (volumes conserves)
docker compose down

# arrêter et supprimer aussi les volumes (attention !)
docker compose down -v

mon-app/
├── compose.yaml
├── frontend/
│   ├── index.html
│   └── Dockerfile
├── api/
│   ├── package.json
│   ├── server.js
│   └── Dockerfile
└── .env

import express from 'express';

const app = express();
const PORT = process.env.PORT || 3000;
const DB_HOST = process.env.DB_HOST || 'localhost';
const DB_PORT = process.env.DB_PORT || 5432;

app.get('/api/health', (req, res) => {
  res.json({ status: 'ok', db: `${DB_HOST}:${DB_PORT}` });
});

app.listen(PORT, () => console.log(`API sur le port ${PORT}`));

FROM node:20-alpine
WORKDIR /app
COPY package.json package-lock.json ./
RUN npm ci --only=production
COPY . .
EXPOSE 3000
CMD ["node", "server.js"]

FROM nginx:1.25-alpine
COPY index.html /usr/share/nginx/html/
EXPOSE 80

services:
  frontend:
    build: ./frontend
    ports:
      - "8080:80"
    depends_on:
      - api

  api:
    build: ./api
    ports:
      - "3000:3000"
    environment:
      - DB_HOST=db
      - DB_PORT=5432
    depends_on:
      db:
        condition: service_healthy

  db:
    image: postgres:16-alpine
    environment:
      - POSTGRES_PASSWORD=secret
      - POSTGRES_DB=app
    volumes:
      - pg-data:/var/lib/postgresql/data
    healthcheck:
      test: ["CMD-SHELL", "pg_isready -U postgres"]
      interval: 5s
      timeout: 3s
      retries: 5

volumes:
  pg-data:

# Tout lancer
docker compose up -d --build

# Tester
curl http://localhost:3000/api/health
# Ouvrir http://localhost:8080 pour le frontend

# Tout arrêter
docker compose down

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

# Stage 2 : production (image finale, leger)
FROM nginx:1.25-alpine
COPY --from=builder /app/dist /usr/share/nginx/html
EXPOSE 80
CMD ["nginx", "-g", "daemon off;"]

FROM node:20-alpine
# ... app ...
HEALTHCHECK --interval=30s --timeout=3s --retries=3 \
  CMD wget -qO- http://localhost:3000/health || exit 1

services:
  api:
    build: .
    healthcheck:
      test: ["CMD", "wget", "-qO-", "http://localhost:3000/health"]
      interval: 10s
      timeout: 3s
      retries: 3
      start_period: 10s

  frontend:
    build: ./frontend
    depends_on:
      api:
        condition: service_healthy

# Logs d'un conteneur
docker logs web

# Suivre les logs en temps reel
docker logs -f web

# Les 50 dernieres lignes
docker logs --tail 50 web

# Logs avec timestamp
docker logs -t web

# Logs depuis une date
docker logs --since 2026-01-01T00:00:00 web

# Entrer dans un conteneur en cours
docker exec -it web sh

# Infos detaillees sur un conteneur (IP, config, volumes, etc.)
docker inspect web

# Voir l'utilisation de ressources
docker stats

# Voir les processus dans un conteneur
docker top web

FROM node:20-alpine
RUN addgroup -S app && adduser -S app -G app
WORKDIR /app
COPY --chown=app:app . .
USER app
CMD ["node", "server.js"]

# Docker Scout (integre a Docker Desktop)
docker scout cves mon-api:v1

# Voir l'historique des layers (detecte les secrets oublies)
docker history mon-api:v1

# Limiter la memoire et le CPU
docker run -d --name api --memory=512m --cpus=1 mon-api:v1

# Mal : 3 layers, 3 images intermediaires
RUN apt update
RUN apt install -y curl
RUN rm -rf /var/lib/apt/lists/*

# Bien : 1 layer, cleanup dans la même commande
RUN apt update && \
    apt install -y --no-install-recommends curl && \
    rm -rf /var/lib/apt/lists/*

# Voir les layers et leur taille
docker history mon-api:v1

# Dive : outil externe pour analyser une image en detail
# https://github.com/wagoodman/dive
dive mon-api:v1

services:
  api:
    build: .
    ports:
      - "3000:3000"
    volumes:
      - ./:/app          # Monte le code source
      - /app/node_modules # Evite que node_modules hote ecrase celui du conteneur
    command: npx nodemon server.js
    environment:
      - NODE_ENV=development

# 1. Se connecter a Docker Hub
docker login

# 2. Tagger l'image avec ton nom d'utilisateur
docker tag mon-api:v1 tonuser/mon-api:v1

# 3. Pousser l'image
docker push tonuser/mon-api:v1

# 4. Quelqu'un d'autre peut la télécharger
docker pull tonuser/mon-api:v1

name: Build and Push

on:
  push:
    branches: [main]

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

      - name: Login to GHCR
        run: echo "${{ secrets.GITHUB_TOKEN }}" | docker login ghcr.io -u ${{ github.actor }} --password-stdin

      - name: Build and push
        run: |
          docker build -t ghcr.io/${{ github.repository }}:latest .
          docker push ghcr.io/${{ github.repository }}:latest

# Voir l'espace utilise par Docker
docker system df

# Supprimer les conteneurs arretes
docker container prune

# Supprimer les images inutilisees
docker image prune

# Supprimer les volumes inutilises (attention aux donnees !)
docker volume prune

# Supprimer les réseaux inutilises
docker network prune

# Tout nettoyer d'un coup (conteneurs arretes, images, réseaux, cache)
docker system prune

# Version extrême : supprime aussi les volumes (donnees perdues !)
docker system prune -a --volumes

# Erreur : "port is already allocated"
# Solution : trouver ce qui occupe le port
# Linux/macOS :
lsof -i :8080
# Windows :
netstat -ano | findstr :8080

# Puis soit arrêter le processus, soit changer le port
docker run -p 8081:80 nginx

# Erreur : "permission denied while trying to connect to Docker daemon"
# Solution (Linux) : ajouter ton user au groupe docker
sudo usermod -aG docker $USER
newgrp docker

# Voir le code de sortie
docker ps -a

# Lire les logs du conteneur arrete
docker logs mon-conteneur

# Causes fréquentes :
# - CMD mal ecrit (pas de mode daemon)
# - App qui crash au démarrage (verifier les logs)
# - Variable d'environnement manquante

# Voir l'espace utilise
docker system df

# Nettoyer (prudent)
docker system prune

# Nettoyer le cache de build
docker builder prune