La VM simule une machine entière ; le conteneur isole des processus qui partagent le noyau de l’hôte.

• Essayer un autre système, garder un poste propre → VM.
• Laboratoire de sécurité, programme douteux → VM isolée, instantané, réseau coupé.
• Faire tourner une application identique partout → conteneur.
• Application + base de données + cache → Docker Compose.
• Outils Linux sous Windows au quotidien → WSL 2.
• Les deux se combinent : Docker dans une VM Linux est courant.

• ISO : site officiel du système, empreinte vérifiée.
• Docker Hub : badges Docker Official Image et Verified Publisher ; regarder la date de mise à jour et le Dockerfile.
• ! VM « toutes prêtes » (OVA) et images d’inconnus : porte dérobée ou mineur de cryptomonnaie possibles.
• docker pull n’exécute rien ; docker run, si.

Moteurs de conteneurs : Docker, Podman (sans démon), containerd ; orchestration à grande échelle : Kubernetes.

1. Un instantané avant toute expérience.
2. Un instantané n’est pas une sauvegarde.
3. Un conteneur est jetable : les données vont dans un volume.
4. Fixer les versions : postgres:17, pas postgres:latest.
5. Images officielles ou d’éditeurs vérifiés.
6. Jamais de secret dans une image.

• VirtualBox : fonctionne (hyperviseur de type 2).
• WSL 2 : disponible — un vrai noyau Linux dans une VM légère.
• Hyper-V (gestionnaire) et Bac à sable Windows : réservés aux éditions Pro, Entreprise, Éducation.
• Docker Desktop : les prérequis publiés citent Windows 11 Pro, Entreprise ou Éducation 23H2 ; une note y évoque les éditions Famille, limitées aux conteneurs Linux → à vérifier avant d’installer.
• Solution sûre : Docker Engine dans une VM Linux.
• ! Si WSL 2 est actif, VirtualBox passe par la plateforme de l’hyperviseur Windows : plus lent, parfois instable.

Désactivée ? Réglages UEFI (BIOS) au démarrage : Intel VT-x (« Virtualization Technology ») ou AMD-V (« SVM Mode »).

Versions vérifiées sur les sites officiels le 29 septembre 2026 : elles évoluent vite.

• VM et images visent une architecture : amd64 (x86-64, PC courants) ou arm64 (Mac à puce Apple, Raspberry Pi, certains portables).
• Images multi-architectures : Docker choisit seul la bonne variante.
• Architecture étrangère : émulation possible (QEMU), mais lente.
• Connaître la sienne : uname -m (Linux) · $env:PROCESSOR_ARCHITECTURE (PowerShell).

1. Télécharger l’image ISO sur le site officiel du système.
2. Vérifier son empreinte : Get-FileHash f.iso (PowerShell) ou sha256sum f.iso, à comparer à celle publiée.
3. Nouvelle machine : nom, type et version du système (64 bits).
4. Mémoire vive, processeurs, disque virtuel (voir ci-dessous).
5. Insérer l’ISO dans le lecteur optique virtuel, démarrer, installer.
6. Mettre à jour l’invité, installer les additions invité.
7. Éteindre proprement, prendre un instantané « propre ».

• Apportent : écran redimensionnable, presse-papiers partagé, glisser-déposer, dossiers partagés, pilotes plus rapides.
• VirtualBox : menu Périphériques → Insérer l’image CD des Additions invité ; sous Linux, installer d’abord les outils de compilation et les en-têtes du noyau.
• Dossier partagé sous Linux : /media/sf_nom, accessible au groupe vboxsf : sudo usermod -aG vboxsf $USER, puis rouvrir la session.
• Équivalents : open-vm-tools (VMware), qemu-guest-agent et spice-vdagent (KVM).
• ! Presse-papiers, glisser-déposer et dossiers partagés percent l’isolement : les couper pour un laboratoire.

• Dossier partagé (additions invité) : le plus simple.
• SSH par la redirection NAT : scp -P 2222 f utilisateur@127.0.0.1: (serveur SSH à installer dans l’invité : sudo apt install openssh-server).
• Glisser-déposer, presse-papiers : pratiques au quotidien.
• Clé USB attachée à la VM (menu Périphériques → USB) ou image ISO de fichiers.

Convertir : qemu-img convert -f vmdk -O qcow2 a.vmdk b.qcow2. Agrandir le disque ne suffit pas : étendre ensuite la partition dans l’invité.

! Un instantané n’est pas une sauvegarde : si le disque d’origine est perdu, l’instantané l’est aussi. Supprimer un instantané fusionne les différences sans toucher à l’état actuel. Éviter les longues chaînes.

• Deux VM ou plus en réseau interne nommé (ex. labo) : elles se voient, et rien d’autre.
• Pas de DHCP en réseau interne : adresses fixes (ex. 10.10.10.1, 10.10.10.2).
• Besoin d’Internet pour installer ? Ajouter temporairement une 2^e carte en NAT, puis la retirer.
• ! Une machine volontairement vulnérable ne va jamais en mode pont.

! Déplacer, renommer : par VirtualBox, jamais à la main.

• Virtualisation matérielle activée (page 1) et additions invité installées.
• Disque virtuel sur un SSD ; hôte pas à court de mémoire.
• Ne pas surallouer : trop de processeurs ou de mémoire ralentit l’hôte… et la VM.
• Invité Linux : carte réseau paravirtualisée (virtio-net).

Chaque commande ci-dessous commence par VBoxManage : VBoxManage list vms.

Sous Windows, VBoxManage.exe se trouve dans C:\Program Files\Oracle\VirtualBox (souvent absent du PATH).

# chaque ligne commence par VBoxManage
createvm --name labo --ostype Ubuntu_64 --register
modifyvm labo --memory 4096 --cpus 2 --nic1 nat
createmedium disk --filename labo.vdi --size 25600
storagectl labo --name SATA --add sata
storageattach labo --storagectl SATA --port 0 --device 0
    --type hdd --medium labo.vdi          # suite de la ligne
storageattach labo --storagectl SATA --port 1 --device 0
    --type dvddrive --medium systeme.iso  # suite
startvm labo

--size en Mo : 25600 = 25 Go. Identifiant exact du système : list ostypes.

Interface graphique : virt-manager. Gérer sans sudo : sudo usermod -aG libvirt $USER. Noms des paquets (QEMU, libvirt) : selon la distribution.

# %UserProfile%\.wslconfig — limiter la VM de WSL 2
[wsl2]
memory=4GB
processors=2

Appliquer : wsl --shutdown. Fichiers Windows vus de Linux : /mnt/c ; fichiers Linux vus de Windows : \\wsl.localhost\distribution. Travailler dans le système de fichiers Linux : bien plus rapide.

Activation : Fonctionnalités de Windows → Hyper-V. Commandes PowerShell en administrateur.

• docker build : Dockerfile → image · docker pull : registre → image locale · docker run : image → conteneur.
• Image = modèle en lecture seule ; conteneur = image + une couche inscriptible, effacée avec lui.
• Sous le démon : containerd gère les conteneurs, runc les crée à l’aide du noyau (espaces de noms, cgroups).
• Docker Desktop (Windows, macOS) = démon dans une VM Linux + interface graphique.

Aucune « machine » : un conteneur est un processus ordinaire de l’hôte, simplement cloisonné.

Puis ouvrir http://localhost:8080. Tout ce qui suit l’image remplace sa commande par défaut : docker run --rm alpine ls /etc.

Formes longues équivalentes : docker container run = docker run, docker container ls = docker ps, docker image ls = docker images.

Un conteneur vit tant que son processus principal vit : si ce processus se termine, le conteneur s’arrête.

docker run hello-world
docker run -it --rm alpine sh        # shell jetable
docker run -d --name web -p 8080:80 nginx:alpine
docker ps                            # web est « Up »
docker logs web                      # journal d’accès
docker stop web && docker rm web     # ménage

! Désinstaller d’abord les paquets non officiels (docker.io, podman-docker…). Le script get.docker.com : réservé aux essais, pas à la production.

Un préfixe unique de l’identifiant suffit : docker stop 3f2a.

• Registre par défaut : Docker Hub · espace library = images officielles.
• Sans étiquette : latest — ce n’est pas forcément la plus récente, juste l’étiquette par défaut.
• L’empreinte @sha256: désigne un contenu immuable ; une étiquette peut être déplacée.

! docker export / import travaillent sur un conteneur : système de fichiers aplati, sans couches ni réglages. docker commit fige un conteneur bricolé à la main : préférer un Dockerfile, reproductible.

# syntax=docker/dockerfile:1
FROM python:3.14-slim          # base officielle, version fixée
WORKDIR /app                   # dossier de travail
COPY requirements.txt .        # 1. les dépendances…
RUN pip install --no-cache-dir -r requirements.txt
COPY . .                       # 2. …puis le code
RUN useradd --create-home appli
USER appli                     # ne pas rester root
ENV PORT=8000
EXPOSE 8000                    # documente le port
CMD ["python", "app.py"]       # commande par défaut

docker login                      # Docker Hub
docker tag appli:1.0 compte/appli:1.0
docker push compte/appli:1.0

Autre registre : préfixer par son adresse, registre/appli:1.0. ! Un dépôt public est visible de tous.

HEALTHCHECK --interval=30s --timeout=3s --retries=3 \
  CMD curl -fs http://localhost:8000/ || exit 1

docker ps affiche alors (healthy), (unhealthy) ou (health: starting). ! L’outil appelé (curl) doit exister dans l’image.

• Chaque instruction produit une couche ; si l’une change, toutes les suivantes sont reconstruites.
• Ordre : ce qui change rarement en haut (système, dépendances), le code en bas.
• Installer et nettoyer dans la même couche, sinon les fichiers supprimés pèsent encore :

RUN apt-get update \
 && apt-get install -y --no-install-recommends curl \
 && rm -rf /var/lib/apt/lists/*

FROM node:22 AS build          # 1. outils complets
WORKDIR /src
COPY package*.json ./
RUN npm ci
COPY . .
RUN npm run build              # produit /src/dist
FROM nginx:alpine              # 2. image finale légère
COPY --from=build /src/dist /usr/share/nginx/html

L’image finale ne contient que le résultat : ni compilateur, ni sources, ni dépendances de développement.

.git
node_modules
*.log
.env                 # secrets : jamais dans le contexte

• Image de base officielle et minimale (-slim, alpine, distroless), version fixée.
• Un processus principal par conteneur.
• ! Aucun secret dans l’image : ENV, ARG et fichiers copiés restent lisibles (docker history, couches).
• Utilisateur non root ; HEALTHCHECK pour les services.

• -v crée silencieusement un dossier d’hôte absent (appartenant à root) ; --mount signale l’erreur.
• Un volume nommé vide reçoit le contenu du dossier de l’image ; un montage lié le masque.
• Droits : le conteneur écrit avec son identifiant (UID) ; aligner avec --user.

# sauvegarde : archive dans le dossier courant
docker run --rm -v donnees:/source:ro \
  -v "$(pwd)":/sauv alpine \
  tar czf /sauv/donnees.tar.gz -C /source .
# restauration dans un volume (vide)
docker run --rm -v donnees:/cible \
  -v "$(pwd)":/sauv alpine \
  tar xzf /sauv/donnees.tar.gz -C /cible

Arrêter d’abord le conteneur qui écrit dans le volume. Pour une base de données, préférer son outil d’export (pg_dump, mysqldump).

{
  "log-driver": "json-file",
  "log-opts": { "max-size": "10m", "max-file": "3" },
  "data-root": "/srv/docker",
  "default-address-pools": [
    { "base": "10.200.0.0/16", "size": 24 } ]
}

• ! Journaux json-file sans rotation par défaut : un conteneur bavard remplit le disque. Les options valent pour les conteneurs créés ensuite.
• data-root : déplacer le stockage de Docker ; default-address-pools : si 172.17.x.x entre en conflit avec le réseau local.
• Appliquer : sudo systemctl restart docker · Docker Desktop : Settings → Docker Engine.

docker network create appnet
docker run -d --name cache --network appnet redis:alpine
docker run -it --rm --network appnet redis:alpine \
  redis-cli -h cache ping          # → PONG

Le nom du conteneur (cache) sert de nom d’hôte. Sur le réseau bridge par défaut, cette résolution ne fonctionne pas.

• ! Linux : les ports publiés contournent le pare-feu ufw ; publier sur 127.0.0.1 ce qui ne doit pas sortir.
• Dans un conteneur, localhost = le conteneur lui-même, pas l’hôte.
• Joindre l’hôte : host.docker.internal (Docker Desktop ; sous Linux : --add-host=host.docker.internal:host-gateway).
• Entre conteneurs d’un même réseau : le port interne (db:5432), sans publication.

• Linux : /var/lib/docker — images, conteneurs, volumes. ! N’y rien modifier à la main.
• Docker Desktop : dans le disque virtuel de sa VM.
• docker system df -v : détail par image, conteneur, volume.
• ~/.docker/config.json : réglages du client ; ! docker login y range les identifiants simplement encodés, sans chiffrement, faute d’assistant d’identifiants (credential helper).

services:
  web:                          # nom du service = nom d’hôte
    build: .                    # image construite ici
    ports:
      - "127.0.0.1:8000:8000"
    environment:
      DB_HOST: db               # le service « db »
    env_file: .env              # variables injectées
    depends_on:
      db:
        condition: service_healthy
    restart: unless-stopped

  db:
    image: postgres:17          # version fixée
    environment:
      POSTGRES_USER: appli
      POSTGRES_DB: appli
      POSTGRES_PASSWORD_FILE: /run/secrets/db_mdp
    secrets: [db_mdp]
    volumes:
      - donnees:/var/lib/postgresql/data
    healthcheck:
      test: ["CMD-SHELL", "pg_isready -U appli"]
      interval: 5s
      retries: 5

volumes:
  donnees:                      # volume nommé

secrets:
  db_mdp:
    file: ./db_mdp.txt          # hors dépôt Git !

Le mot de passe est lu dans un fichier monté en /run/secrets/, pas écrit en clair dans le YAML. ! YAML : indentation par espaces (jamais de tabulation) ; mettre les ports entre guillemets.

• depends_on seul garantit l’ordre de lancement, pas que le service soit prêt.
• Avec condition: service_healthy, Compose attend que le healthcheck du service réussisse.
• L’application doit tout de même savoir réessayer une connexion perdue.

docker compose pull          # nouvelles images
docker compose up -d         # recrée ce qui a changé
docker image prune           # anciennes images

• Lire les notes de version ; sauvegarder les volumes avant.
• ! Base de données : changer de version majeure (PostgreSQL 17 → 18) exige une migration des données.
• Image construite localement : docker compose up -d --build.

• Un fichier décrit toute l’application : services, réseaux, volumes, secrets.
• Nom par défaut : compose.yaml (préféré) ; docker-compose.yml reste lu.
• Commande actuelle : docker compose (avec une espace) ; l’ancien docker-compose (tiret) est obsolète.
• La clé version: en tête de fichier est obsolète : Compose l’ignore et avertit.
• Un réseau projet_default relie les services : chacun joint les autres par son nom.
• Projet = nom du dossier, préfixe des conteneurs et volumes (-p nom pour le changer).

Chaque commande commence par docker compose : docker compose up -d.

• .env du dossier du projet : lu automatiquement pour remplacer ${VAR} dans le YAML.
• ${VAR:-défaut} valeur par défaut · ${VAR:?message} erreur si absente.
• env_file: injecte des variables dans le conteneur : ce n’est pas le même mécanisme.
• compose.override.yaml, s’il existe, est fusionné automatiquement : réglages de développement.
• ! .env et fichiers de secrets : dans .gitignore et .dockerignore.

• ! Jamais --privileged ni -v /var/run/docker.sock:… sans comprendre : c’est donner l’hôte.
• ! Le groupe docker donne des droits équivalents à root sur l’hôte (documentation officielle). Alternatives : mode rootless, Podman.
• Images officielles ou d’éditeurs vérifiés ; version fixée ; les mettre à jour ; analyser les vulnérabilités (docker scout cves image, Trivy, Grype).
• Secrets : fichiers montés (secrets:), jamais dans l’image ni dans le dépôt.

1. VM dédiée, jamais le poste principal ni un conteneur : le noyau partagé rend l’évasion plus plausible.
2. Instantané propre avant, retour à cet instantané après.
3. Réseau interne ou non connecté ; pas de dossier partagé, de presse-papiers ni de glisser-déposer.
4. ! WSL n’est pas une frontière de sécurité : Linux y lit et écrit les fichiers Windows (/mnt/c).
5. Idéalement : inspection du code avant toute exécution.

• Mettre à jour l’hyperviseur : des failles d’évasion de VM existent.
• Un instantané pris VM allumée contient la mémoire : mots de passe, clés… le protéger comme la VM.
• Données sensibles : chiffrer le disque dans l’invité (LUKS, BitLocker).
• N’importer que des OVA de source sûre ; couper dossiers partagés, presse-papiers et USB quand ils ne servent pas.

1. Image à version fixée, base officielle, reconstruite régulièrement.
2. Utilisateur non root, privilèges retirés (--cap-drop).
3. healthcheck et restart: unless-stopped.
4. Limites de mémoire et de processeur ; journaux bornés (max-size).
5. Ports liés à 127.0.0.1, derrière un proxy inverse en HTTPS.
6. Volumes sauvegardés et restauration testée.
7. Secrets hors de l’image et du dépôt ; mises à jour surveillées.

• Mêmes commandes : podman run, podman ps, podman build… (alias docker=podman).
• Sans démon et sans root par défaut ; notion de pod (groupe de conteneurs).
• ! Donner les noms d’images complets : docker.io/library/nginx:alpine.

• docs.docker.com : guides, référence de la CLI, de Compose et du Dockerfile.
• virtualbox.org/manual : manuel de VirtualBox, dont VBoxManage.
• learn.microsoft.com/windows/wsl : WSL.
• libvirt.org · qemu.org : KVM et QEMU.
• Pratiquer : tout refaire dans une VM jetable, instantané à l’appui.

Tout prune demande confirmation ; -f la saute. Lire la liste avant de valider.

Démarche : docker ps -a → docker logs → docker inspect → docker exec -it c sh ; conteneur qui s’arrête aussitôt : docker run -it --rm --entrypoint sh image pour regarder dedans.