Pourquoi ce guide existe

Why this guide exists

Le repository Fast-Docker est une excellente base d'auto-formation, mais il s'adresse à des lecteurs qui savent déjà se repérer dans la documentation Docker. Ce guide accompagne pas à pas : il explique le pourquoi avant le comment, illustre les concepts par des schémas, et indique à chaque étape ce qu'il faut vérifier pour être sûr d'avoir compris.

The Fast-Docker repository is an excellent self-study foundation, but it speaks to readers already comfortable navigating Docker's documentation. This guide walks you through step by step: it explains the why before the how, illustrates concepts with diagrams, and tells you at each step what to verify to be sure you've understood.

À qui s'adresse ce manuel

Who this manual is for

• Débutants complets qui ont entendu parler de Docker mais n'ont jamais lancé un conteneur.
• Développeurs qui utilisent des images préparées par d'autres et veulent prendre le contrôle.
• Administrateurs systèmes et SRE qui doivent industrialiser le déploiement d'applications.
• Étudiants et stagiaires en cycle DevOps, infrastructure ou cybersécurité.
• Architectes Cloud qui souhaitent consolider leurs fondamentaux avant d'aborder Kubernetes.

• Complete beginners who have heard of Docker but have never launched a container.
• Developers who use images prepared by others and want to take control.
• System administrators and SREs who need to industrialize application deployments.
• Students and interns in DevOps, infrastructure or cybersecurity tracks.
• Cloud architects who want to solidify their fundamentals before tackling Kubernetes.

Ce que vous saurez faire à la fin

What you'll be able to do by the end

Comment lire ce guide

How to read this guide

Chaque laboratoire suit la même structure : un objectif énoncé en une phrase, une durée estimée, un schéma mental ou visuel, les commandes essentielles, les pièges classiques, et un critère de validation qui vous permet de savoir, sans ambiguïté, si vous avez compris.

Each lab follows the same structure: an objective stated in one sentence, an estimated duration, a mental or visual diagram, the essential commands, the classic pitfalls, and a validation criterion that lets you know, unambiguously, whether you've understood.

Lecture linéaire ou en zigzag : les douze laboratoires sont indépendants. Une recommandation d'ordre de progression est proposée au §4.

Linear or zigzag reading: the twelve labs are independent. A recommended progression order is proposed in §4.

Prérequis et installation

Prerequisites and installation

Connaissances supposées

Assumed knowledge

Aucune connaissance préalable de Docker n'est nécessaire. Il faut simplement être à l'aise avec :

No prior Docker knowledge is required. You simply need to be comfortable with:

• Un terminal (Bash sous Linux/macOS, PowerShell ou WSL2 sous Windows).
• Les commandes de base : cd, ls, mkdir, cat, redirection >.
• La notion de variable d'environnement et de port réseau.
• Les bases de Git pour cloner le repository.

• A terminal (Bash on Linux/macOS, PowerShell or WSL2 on Windows).
• Basic commands: cd, ls, mkdir, cat, redirection >.
• The notion of environment variable and network port.
• The basics of Git to clone the repository.

Installer Docker

Install Docker

# Méthode officielle, en une commande
curl -fsSL https://get.docker.com | sh

# Ajouter votre utilisateur au groupe docker
sudo usermod -aG docker $USER
# Se déconnecter / reconnecter pour appliquer

# Official method, in one command
curl -fsSL https://get.docker.com | sh

# Add your user to the docker group
sudo usermod -aG docker $USER
# Log out / log back in to apply

Vérifier l'installation

Verify the installation

docker version            # client + daemon >= 24.x
docker compose version    # v2.x (avec espace, pas de tiret)
docker buildx version     # buildx présent par défaut
docker run hello-world    # test fonctionnel

docker version            # client + daemon >= 24.x
docker compose version    # v2.x (with space, no dash)
docker buildx version     # buildx ships by default
docker run hello-world    # functional test

Cloner le repository

Clone the repository

git clone https://github.com/Jihatech/Fast-Docker.git
cd Fast-Docker
ls -la

Outils complémentaires recommandés

Recommended additional tools

Aucun n'est obligatoire, mais ils enrichissent l'apprentissage.

None are mandatory, but they enrich the learning experience.

Les concepts qu'il faut comprendre avant de pratiquer

The concepts to grasp before practicing

Cinq notions structurent toute l'expérience Docker : l'architecture client/serveur, le cycle de vie du conteneur, le système de couches, les volumes, et les réseaux. En les visualisant correctement, l'essentiel des commandes deviennent évidentes.

Five notions structure the entire Docker experience: client/server architecture, container lifecycle, the layer system, volumes, and networks. With these clearly in mind, most commands become obvious.

Architecture Docker

Docker architecture

Docker est un système client / serveur. Quand vous tapez docker run dans votre terminal, vous parlez à un client. Ce client envoie une requête à un daemon (le serveur), qui se charge réellement de créer l'image, de lancer le conteneur, et de communiquer avec le registry où sont stockées les images publiées.

Docker is a client / server system. When you type docker run in your terminal, you talk to a client. That client sends a request to a daemon (the server), which actually does the work of creating the image, running the container, and communicating with the registry where published images are stored.

Cycle de vie d'un conteneur

Container lifecycle

Un conteneur n'a que cinq états possibles. Comprendre les transitions entre ces états élimine 90% des confusions de débutant — notamment la différence entre une image (modèle), un conteneur arrêté (instance gelée) et un conteneur actif (processus en cours).

A container has only five possible states. Understanding the transitions between them removes 90% of beginner confusion — especially the difference between an image (template), a stopped container (frozen instance) and a running container (live process).

Couches d'image (Union File System)

Image layers (Union File System)

Une image Docker n'est pas un fichier monolithique. C'est un empilement de couches en lecture seule, chaque instruction du Dockerfile (FROM, RUN, COPY...) produisant une couche. Lorsqu'un conteneur démarre, Docker ajoute par-dessus une couche fine en lecture-écriture. Toutes les modifications faites pendant l'exécution se trouvent dans cette couche éphémère.

A Docker image isn't a monolithic file. It's a stack of read-only layers, each Dockerfile instruction (FROM, RUN, COPY…) producing a layer. When a container starts, Docker adds a thin read-write layer on top. All modifications made during execution land in this ephemeral layer.

Modes réseau

Network modes

Docker propose cinq pilotes réseau, chacun adapté à un cas d'usage précis. Le choix par défaut, bridge, convient à la majorité des situations en mono-machine. Host supprime l'isolation réseau pour gagner en performance. Overlay permet à des conteneurs sur des machines différentes de se voir comme s'ils étaient en local.

Docker offers five network drivers, each suited to a specific use case. The default, bridge, fits most single-machine situations. Host removes network isolation for performance. Overlay lets containers on different machines see each other as if they were local.

Comprendre l'image, le conteneur et le volume, c'est tenir 80% de Docker. Le reste n'est qu'orchestration et ergonomie.

Understand image, container and volume, and you've got 80% of Docker. The rest is just orchestration and ergonomics.

Parcours d'apprentissage recommandé

Recommended learning path

Les douze laboratoires du repository peuvent être abordés dans n'importe quel ordre, mais l'expérience montre qu'une progression réfléchie évite frustrations et oublis. Voici trois parcours selon votre point de départ.

The repository's twelve labs can be tackled in any order, but experience shows that a thoughtful progression avoids frustration and gaps. Here are three paths depending on your starting point.

Parcours A · Découverte complète (recommandé)

Path A · Full discovery (recommended)

Pour qui n'a jamais touché Docker. Compter 8 à 12 heures réparties sur 2 à 3 semaines.

For someone who has never touched Docker. Plan for 8 to 12 hours spread across 2 to 3 weeks.

Parcours B · Express (4 heures, l'essentiel)

Path B · Express (4 hours, the essentials)

Pour qui veut comprendre Docker rapidement avant un projet ou un entretien.

For someone who wants to understand Docker quickly before a project or interview.

• LAB 01 → LAB 02 → LAB 03 → LAB 11 → LAB 12

Parcours C · Préparation Kubernetes / CKA

Path C · Kubernetes / CKA preparation

Pour qui prépare une certification CKA, CKAD ou CKS.

For someone preparing for a CKA, CKAD or CKS certification.

• LAB 01 → LAB 02 → LAB 11 → LAB 12 → §7 (pont vers Kubernetes)
• Sauter LAB 04 (Swarm est hors syllabus CKA)

• LAB 01 → LAB 02 → LAB 11 → LAB 12 → §7 (bridge to Kubernetes)
• Skip LAB 04 (Swarm is out of the CKA syllabus)

Méthode de session efficace

Effective session method

Une session de 90 minutes bien structurée vaut mieux que trois heures dispersées :

A well-structured 90-minute session beats three scattered hours:

• 10 min — relire la section théorique correspondante du README.
• 50 min — exécuter le lab, puis introduire des variations volontaires (changer une image, casser un truc, réparer).
• 15 min — prendre des notes personnelles (un fichier notes/LABxx.md dans votre fork).
• 15 min — formuler une question ouverte qui reste en suspens. Ouvrir une issue dans votre fork pour la traiter plus tard.

• 10 min — re-read the corresponding theory section in the README.
• 50 min — run the lab, then introduce deliberate variations (change an image, break something, fix it).
• 15 min — take personal notes (a notes/LABxx.md file in your fork).
• 15 min — formulate one open question that remains unanswered. Open an issue in your fork to address it later.

Les douze laboratoires

The twelve labs

Chaque lab est conçu pour être autonome. Faites-les un par un, exécutez chaque commande, et ne passez à la suite que lorsque le critère de validation est rempli.

Each lab is designed to be self-contained. Do them one by one, run every command, and only move on once the validation criterion is met.

# 1. Construire l'image depuis un Dockerfile
docker image build -t hello .

# 2. Lancer un conteneur
docker container run -d --name c1 hello

# 3. Inspecter
docker container ls
docker container logs c1
docker container exec -it c1 sh

# 4. Nettoyer
docker container rm -f c1
docker image rm hello

# 1. Build the image from a Dockerfile
docker image build -t hello .

# 2. Run a container
docker container run -d --name c1 hello

# 3. Inspect
docker container ls
docker container logs c1
docker container exec -it c1 sh

# 4. Clean up
docker container rm -f c1
docker image rm hello

# Volume nommé
docker volume create data
docker run -v data:/app alpine sh -c "echo hello > /app/file.txt"
docker run -v data:/app alpine cat /app/file.txt
# => hello (donnée persistée)

# Bind mount
docker run -v $(pwd)/local:/app alpine ls /app

# Inspection
docker volume ls
docker volume inspect data

# Named volume
docker volume create data
docker run -v data:/app alpine sh -c "echo hello > /app/file.txt"
docker run -v data:/app alpine cat /app/file.txt
# => hello (data persisted)

# Bind mount
docker run -v $(pwd)/local:/app alpine ls /app

# Inspection
docker volume ls
docker volume inspect data

# Pas de "version:" — obsolète en Compose v2
services:
  db:
    image: mysql:8.0
    restart: always
    environment:
      MYSQL_ROOT_PASSWORD: secret
      MYSQL_DATABASE: wordpress
    volumes:
      - mydata:/var/lib/mysql
    healthcheck:
      test: ["CMD", "mysqladmin", "ping", "-h", "localhost"]
      interval: 10s
      retries: 5

  wordpress:
    image: wordpress:latest
    depends_on:
      db:
        condition: service_healthy
    ports:
      - "8080:80"
    environment:
      WORDPRESS_DB_HOST: db:3306
      WORDPRESS_DB_PASSWORD: secret

volumes:
  mydata:

# No "version:" — obsolete in Compose v2
services:
  db:
    image: mysql:8.0
    restart: always
    environment:
      MYSQL_ROOT_PASSWORD: secret
      MYSQL_DATABASE: wordpress
    volumes:
      - mydata:/var/lib/mysql
    healthcheck:
      test: ["CMD", "mysqladmin", "ping", "-h", "localhost"]
      interval: 10s
      retries: 5

  wordpress:
    image: wordpress:latest
    depends_on:
      db:
        condition: service_healthy
    ports:
      - "8080:80"
    environment:
      WORDPRESS_DB_HOST: db:3306
      WORDPRESS_DB_PASSWORD: secret

volumes:
  mydata:

docker compose up -d         # lancer en arrière-plan
docker compose ps            # lister
docker compose logs -f       # suivre les logs
docker compose down          # arrêter
docker compose down -v       # arrêter + supprimer volumes

docker compose up -d         # launch in background
docker compose ps            # list
docker compose logs -f       # follow logs
docker compose down          # stop
docker compose down -v       # stop + remove volumes

docker swarm init
docker service create --name web --replicas 3 -p 8080:80 nginx
docker service ls
docker service scale web=5
docker service update --image nginx:1.25 web
docker service rollback web
docker swarm leave --force

# Lancer un registry local
docker run -d -p 5000:5000 --name registry registry:2

# Tagger une image pour le registry local
docker tag hello localhost:5000/hello:v1

# Pousser
docker push localhost:5000/hello:v1

# Lister via l'API
curl http://localhost:5000/v2/_catalog
curl http://localhost:5000/v2/hello/tags/list

# Récupérer depuis le registry
docker pull localhost:5000/hello:v1

# Run a local registry
docker run -d -p 5000:5000 --name registry registry:2

# Tag an image for the local registry
docker tag hello localhost:5000/hello:v1

# Push
docker push localhost:5000/hello:v1

# List via the API
curl http://localhost:5000/v2/_catalog
curl http://localhost:5000/v2/hello/tags/list

# Pull from the registry
docker pull localhost:5000/hello:v1

# Copier un fichier vers le conteneur
docker cp ./config.json mycontainer:/etc/app/

# Récupérer un fichier depuis le conteneur
docker cp mycontainer:/var/log/app.log ./

# Récupérer un dossier complet
docker cp mycontainer:/etc/nginx ./nginx-backup

# Copy a file to the container
docker cp ./config.json mycontainer:/etc/app/

# Pull a file from the container
docker cp mycontainer:/var/log/app.log ./

# Pull a whole directory
docker cp mycontainer:/etc/nginx ./nginx-backup

# Stage 1 : build
FROM golang:1.22 AS builder
WORKDIR /src
COPY . .
RUN CGO_ENABLED=0 go build -o /app

# Stage 2 : runtime minimaliste
FROM gcr.io/distroless/static-debian12
COPY --from=builder /app /app
USER 65532
ENTRYPOINT ["/app"]

# Stage 1: build
FROM golang:1.22 AS builder
WORKDIR /src
COPY . .
RUN CGO_ENABLED=0 go build -o /app

# Stage 2: minimal runtime
FROM gcr.io/distroless/static-debian12
COPY --from=builder /app /app
USER 65532
ENTRYPOINT ["/app"]

{
  "insecure-registries": ["registry.local:5000"],
  "registry-mirrors": ["https://mirror.gcr.io"],
  "log-driver": "json-file",
  "log-opts": {
    "max-size": "10m",
    "max-file": "3"
  },
  "default-runtime": "runc",
  "live-restore": true
}

[Service]
Environment="HTTP_PROXY=http://proxy.corp:3128"
Environment="HTTPS_PROXY=http://proxy.corp:3128"
Environment="NO_PROXY=localhost,127.0.0.1,.corp.local"

sudo systemctl daemon-reload
sudo systemctl restart docker

# Créer un builder dédié
docker buildx create --name multi --use
docker buildx inspect --bootstrap

# Build pour deux architectures et push direct
docker buildx build \
  --platform linux/amd64,linux/arm64 \
  -t myrepo/myapp:1.0 \
  --push .

# Vérifier le manifest multi-arch
docker manifest inspect myrepo/myapp:1.0

# Create a dedicated builder
docker buildx create --name multi --use
docker buildx inspect --bootstrap

# Build for two architectures and push directly
docker buildx build \
  --platform linux/amd64,linux/arm64 \
  -t myrepo/myapp:1.0 \
  --push .

# Verify the multi-arch manifest
docker manifest inspect myrepo/myapp:1.0

# syntax=docker/dockerfile:1.4
FROM --platform=$BUILDPLATFORM golang:1.22 AS builder
ARG TARGETOS TARGETARCH
WORKDIR /src
COPY . .
RUN CGO_ENABLED=0 GOOS=$TARGETOS GOARCH=$TARGETARCH \
    go build -o /app

FROM alpine:latest
COPY --from=builder /app /usr/local/bin/
CMD ["app"]

FROM node:20 AS builder
WORKDIR /app
COPY package*.json ./
RUN npm ci --only=production
COPY . .

# Final : aucun shell, aucun package manager
FROM gcr.io/distroless/nodejs20-debian12
COPY --from=builder /app /app
WORKDIR /app
CMD ["index.js"]

FROM node:20 AS builder
WORKDIR /app
COPY package*.json ./
RUN npm ci --only=production
COPY . .

# Final: no shell, no package manager
FROM gcr.io/distroless/nodejs20-debian12
COPY --from=builder /app /app
WORKDIR /app
CMD ["index.js"]

FROM alpine:3.19
RUN addgroup -S app && adduser -S app -G app
COPY --chown=app:app . /app
USER app
WORKDIR /app
CMD ["./run.sh"]

# Trivy (open source, le plus populaire)
trivy image myapp:latest

# Docker Scout (intégré à Docker Desktop)
docker scout quickview myapp:latest
docker scout cves myapp:latest
docker scout recommendations myapp:latest

# En CI/CD : échec si CVE critique
trivy image --severity CRITICAL --exit-code 1 myapp:latest

# Trivy (open source, the most popular)
trivy image myapp:latest

# Docker Scout (built into Docker Desktop)
docker scout quickview myapp:latest
docker scout cves myapp:latest
docker scout recommendations myapp:latest

# In CI/CD: fail on critical CVE
trivy image --severity CRITICAL --exit-code 1 myapp:latest

FROM nginx:alpine

HEALTHCHECK --interval=30s --timeout=3s --start-period=5s --retries=3 \
  CMD wget --quiet --tries=1 --spider http://localhost/ || exit 1

# Git
.git
.gitignore

# Dépendances locales
node_modules
venv
__pycache__
*.pyc

# Build
dist
build
target

# Secrets (CRITIQUE)
.env
.env.*
*.pem
*.key
secrets/

# IDE & OS
.vscode
.idea
.DS_Store

# Documentation et tests (optionnel)
*.md
README*
tests/

# Git
.git
.gitignore

# Local dependencies
node_modules
venv
__pycache__
*.pyc

# Build
dist
build
target

# Secrets (CRITICAL)
.env
.env.*
*.pem
*.key
secrets/

# IDE & OS
.vscode
.idea
.DS_Store

# Documentation and tests (optional)
*.md
README*
tests/

Cheatsheet — Les commandes à connaître

Cheatsheet — The commands to know

Une page-aide-mémoire à imprimer ou à garder ouverte dans un onglet.

A reference page to print or keep open in a tab.

Images

docker image ls                          # lister
docker image build -t name:tag .         # construire
docker image pull name:tag               # télécharger
docker image push name:tag               # publier
docker image rm name:tag                 # supprimer
docker image prune -a                    # nettoyer (toutes images orphelines)
docker image inspect name:tag            # détails JSON
docker image history name:tag            # couches

docker image ls                          # list
docker image build -t name:tag .         # build
docker image pull name:tag               # download
docker image push name:tag               # publish
docker image rm name:tag                 # remove
docker image prune -a                    # clean (all orphan images)
docker image inspect name:tag            # JSON details
docker image history name:tag            # layers

Conteneurs

Containers

docker container ls -a                   # lister tous (running + stopped)
docker container run -d --name n image   # lancer en background
docker container run -it --rm image sh   # interactif jetable
docker container exec -it n sh           # shell dans un conteneur
docker container logs -f n               # suivre les logs
docker container stop n                  # arrêter (SIGTERM)
docker container kill n                  # tuer (SIGKILL)
docker container rm -f n                 # supprimer
docker container stats                   # top-like temps réel
docker container inspect n               # détails JSON
docker container prune                   # supprimer tous arrêtés

docker container ls -a                   # list all (running + stopped)
docker container run -d --name n image   # launch in background
docker container run -it --rm image sh   # interactive throwaway
docker container exec -it n sh           # shell into a container
docker container logs -f n               # follow logs
docker container stop n                  # stop (SIGTERM)
docker container kill n                  # kill (SIGKILL)
docker container rm -f n                 # remove
docker container stats                   # real-time top-like
docker container inspect n               # JSON details
docker container prune                   # remove all stopped

Volumes

docker volume create name
docker volume ls
docker volume inspect name
docker volume rm name
docker volume prune                      # supprimer orphelins

docker volume create name
docker volume ls
docker volume inspect name
docker volume rm name
docker volume prune                      # remove orphans

Réseaux

Networks

docker network create --driver bridge mynet
docker network ls
docker network inspect mynet
docker network connect mynet container
docker network rm mynet

Compose v2

docker compose up -d                     # démarrer en arrière-plan
docker compose ps                        # lister
docker compose logs -f service           # logs d'un service
docker compose exec service sh           # shell dans un service
docker compose restart service           # redémarrer un service
docker compose down                      # tout arrêter
docker compose down -v                   # + supprimer volumes
docker compose pull                      # mettre à jour les images
docker compose build                     # reconstruire

docker compose up -d                     # start in background
docker compose ps                        # list
docker compose logs -f service           # logs of a service
docker compose exec service sh           # shell into a service
docker compose restart service           # restart a service
docker compose down                      # stop everything
docker compose down -v                   # + remove volumes
docker compose pull                      # update images
docker compose build                     # rebuild

Buildx (multi-arch)

docker buildx ls
docker buildx create --name multi --use
docker buildx build --platform linux/amd64,linux/arm64 \
  -t name:tag --push .

Système

System

docker system df                         # utilisation disque
docker system prune -a --volumes         # grand ménage
docker info                              # informations daemon
docker events                            # flux d'événements

docker system df                         # disk usage
docker system prune -a --volumes         # big cleanup
docker info                              # daemon info
docker events                            # event stream

Vers Kubernetes — Ce qui se transpose

Toward Kubernetes — What carries over

Une fois Fast-Docker maîtrisé, Kubernetes devient la suite naturelle pour qui vise la production. Bonne nouvelle : la plupart des concepts Docker se retrouvent en K8s, sous d'autres noms.

Once Fast-Docker is mastered, Kubernetes becomes the natural next step for anyone aiming at production. Good news: most Docker concepts reappear in K8s, under different names.

Concepts Docker non couverts par CKA mais essentiels

Docker concepts not covered by CKA but essential

Le syllabus CKA est centré ops, pas build. Les compétences suivantes restent à votre charge :

The CKA syllabus is ops-focused, not build-focused. The following skills remain on you:

• Multi-stage builds
• BuildKit et build secrets
• Distroless
• Scan de vulnérabilités
• Multi-arch builds

• Multi-stage builds
• BuildKit and build secrets
• Distroless
• Vulnerability scanning
• Multi-arch builds

Ce guide les couvre toutes — ne les zappez pas même si elles ne sont pas testées au CKA.

This guide covers all of them — don't skip them even if they aren't tested in CKA.

Ressources externes

External resources

Documentation officielle

Official documentation

• docs.docker.com — référence complète
• BuildKit — moteur de build moderne
• Docker Compose v2
• kubernetes.io — pour la suite

• docs.docker.com — full reference
• BuildKit — modern build engine
• Docker Compose v2
• kubernetes.io — for what's next

Outils complémentaires

Complementary tools

• dive — explorer les couches d'une image visuellement
• hadolint — linter Dockerfile (à mettre en pre-commit Git)
• Trivy — scanner de vulnérabilités open source
• Distroless — images minimales Google
• Chainguard Images — alternative distroless durcie

• dive — visually explore an image's layers
• hadolint — Dockerfile linter (use as a Git pre-commit)
• Trivy — open-source vulnerability scanner
• Distroless — Google minimal images
• Chainguard Images — hardened distroless alternative

Sécurité

Security

• OWASP Docker Security Cheat Sheet
• Docker Scout — analyse de supply chain
• CIS Docker Benchmark — checklist de durcissement

• OWASP Docker Security Cheat Sheet
• Docker Scout — supply chain analysis
• CIS Docker Benchmark — hardening checklist

Pratique en ligne

Online practice

• Play with Docker — sandbox sans installation
• Killercoda Docker — scénarios interactifs

• Play with Docker — sandbox, no install needed
• Killercoda Docker — interactive scenarios

Lire la documentation, c'est apprendre la grammaire. Faire les labs, c'est apprendre à parler.

Reading the docs is learning the grammar. Doing the labs is learning to speak.

Comment utiliser ce fork au quotidien

How to use this fork day-to-day

1. Forker le repository pour avoir votre copie.
2. Cloner en local : git clone.
3. Créer un dossier notes/ où vous prenez vos notes lab par lab.
4. Tenir un journal des erreurs rencontrées et de leurs résolutions — c'est le contenu le plus précieux à long terme.
5. Synchroniser périodiquement avec l'upstream omerbsezer/Fast-Docker pour récupérer les mises à jour.

1. Fork the repository to get your own copy.
2. Clone locally: git clone.
3. Create a notes/ folder where you keep notes lab by lab.
4. Keep a journal of errors encountered and how you fixed them — that's the most valuable long-term content.
5. Sync periodically with the upstream omerbsezer/Fast-Docker to pick up updates.