Date de création : 2025/11/23 00:06
Docker est une plateforme de virtualisation légère basée sur les conteneurs. Son objectif principal est de permettre d'embarquer une application, ses dépendances, sa configuration et son environnement dans un paquet isolé, reproductible et portable : le conteneur.
Docker résout les problèmes majeurs rencontrés dans les environnements de développement et de production :
Docker garantit que le même code fonctionne exactement de la même manière partout.
Un modèle immuable contenant l’environnement complet nécessaire à une application.
Une instance vivante d’une image, équivalente à un processus isolé.
Le moteur responsable des images, conteneurs, réseaux et volumes.
Dépôt d’images (Docker Hub, GitHub Container Registry…).
| Caractéristique | Docker | VM |
|---|---|---|
| Démarrage | <1 sec | 30 sec à plusieurs minutes |
| RAM | Faible | Élevée |
| Isolation | Processus | OS complet |
| Taille | Mo / centaines de Mo | Go |
| Performances | Natives | Réduites |
| Migration | Très simple | Complexe |
Schéma :
MACHINE VIRTUELLE CONTENEUR
+—————————+ +——————————–+
| Application | Application |
+—————————+ +——————————–+
| Bibliothèques de l'app | Bibliothèques de l'app |
+—————————+ +——————————–+
| OS COMPLET (Ubuntu…) | LIBRAIRIES SYSTÈME MINIMALES |
+—————————+ +——————————–+
| Hyperviseur (VMWare…) | Noyau de l'hôte partagé |
+—————————+ +——————————–+
| Matériel physique | Matériel physique |
+—————————+ +——————————–+
brew install –cask docker
sudo apt update sudo apt install docker.io -y sudo systemctl enable –now docker
Installation via Docker Desktop Windows (WSL2 requis).
docker version docker run hello-world
docker stop docker start docker rm docker logs docker exec
Schéma : docker run → création → exécution → arrêt → suppression
Tester installation avec hello-world.
Lancer Nginx et afficher la page depuis navigateur.
Explorer un conteneur via : docker exec -it <id> sh
Comprendre en profondeur le fonctionnement interne de Docker :
Ce module développe chaque concept avec des schémas, explications détaillées et exercices pratiques.
Schéma conceptuel :
[ Docker CLI ] → (API HTTP) → [ Docker Daemon ]
↓
[ Images / Layers ]
↓
[ Containers ]
↓
[ Registries ]
Docker est construit autour d’une architecture client/serveur.
L’outil en ligne de commande utilisé par l’utilisateur :
Il ne fait que transmettre des commandes au daemon via une API REST.
Le cœur de Docker. Il gère :
Tout passe par le daemon.
Une image est un ensemble de couches immuables (layers). Chaque instruction Dockerfile produit une nouvelle couche.
Structure :
Commande pour voir les layers :
docker history nginx
Docker utilise un mécanisme CoW (copy-on-write).
Schéma :
IMAGE (read-only)
▲ layers immuables |
CONTAINER (read-write)
Lorsqu’un fichier est modifié dans le conteneur :
1. Docker copie le fichier dans la couche RW du conteneur. 2. La modification s'applique uniquement au conteneur.
Cela rend les conteneurs légers et rapides.
Un conteneur est :
Cycle de vie :
docker create docker start docker stop docker restart docker kill docker rm
Commande pour inspecter un conteneur :
docker inspect mon_container
Les namespaces fournissent l’isolation au niveau du noyau. Chaque conteneur a son propre ensemble de namespaces.
Schéma :
[ Host OS ] ├─ Namespace A → Container 1 ├─ Namespace B → Container 2 └─ Namespace C → Container 3
Les cgroups limitent les ressources :
Exemples :
docker run –memory=“512m” nginx docker run –cpus=“1.5” nginx
On peut donc isoler les ressources de chaque conteneur.
Les drivers gèrent le système de fichiers interne des conteneurs.
docker info | grep Storage
Sous Linux (Ubuntu), Docker utilise overlay2.
Les registres stockent les images Docker.
docker pull nginx docker push johnben/monimage:1.0 docker login
docker run nginx ↓ Docker CLI → API HTTP UNIX socket → Docker Daemon ↓ Daemon vérifie si l’image existe ↓ Image présente ? sinon → téléchargement ↓ Création du conteneur (RW layer) ↓ Lancement du processus principal (ENTRYPOINT/CMD)
Sous Linux :
journalctl -u docker
Sous macOS : Docker Desktop → menu → Troubleshoot → logs
1. Télécharger nginx :
docker pull nginx
2. Inspecter ses layers :
docker history nginx
3. Inspecter l’image :
docker inspect nginx
1. Lancer nginx :
docker run -d --name test-nginx nginx
2. Inspecter le conteneur :
docker inspect test-nginx
3. Analyser :
Depuis le conteneur :
docker exec -it test-nginx sh
Tester :
ps aux hostname
Comprendre en profondeur :
Ce module est fondamental pour produire des images professionnelles, propres et performantes.
Une image est un ensemble immuable de couches (layers) représentant :
Schéma structurel :
Les images sont read-only, les conteneurs ajoutent une couche RW.
Chaque instruction Dockerfile crée une couche :
Commande :
Analyse typique :
Docker optimise fortement le build avec un cache basé sur les layers.
Si une instruction ne change pas, Docker réutilise le layer précédent → gain massif de temps.
Exemple :
COPY package*.json ./ RUN npm install COPY . .
→ modifier seulement les fichiers sources n’invalide pas npm install.
Structure générale recommandée 2025 :
FROM ... WORKDIR ... COPY ... ... RUN ... COPY ... ... EXPOSE ... USER ... ENTRYPOINT ... CMD ...
Définit l’image de base. Exemples :
FROM node:20-alpine FROM python:3.12-slim FROM ubuntu:22.04
Meilleures pratiques :
Définit le répertoire de travail.
WORKDIR /app
Avantages :
Copie des fichiers dans l’image.
COPY . . COPY src/ /app/src/ COPY package*.json ./
Points importants :
Exécute des commandes lors du build.
RUN apt update && apt install -y curl
Bonnes pratiques :
Définit une variable d’environnement dans l’image.
ENV NODE_ENV=production
Commande utilisée par défaut si aucune autre n’est fournie.
CMD [“npm”, “start”]
Commande forcée, non écrasable.
ENTRYPOINT [“python”] CMD [“app.py”]
Exécution : → python app.py
Objectif :
Exemple Node.js :
FROM node:20-alpine AS build WORKDIR /app COPY package*.json ./ RUN npm ci –only=production COPY . .
FROM node:20-alpine AS runtime WORKDIR /app COPY –from=build /app . CMD [“node”, “server.js”]
Avantages :
Bonnes pratiques 2025 :
RUN adduser -D appuser
USER appuser * limiter les outils installés * scanner les images : docker scan monimage * utiliser des bases officielles minimalistes (alpine, slim, distroless)
RUN rm -rf /var/lib/apt/lists/*
docker inspect monimage
docker history monimage
docker run --rm -it monimage sh
Exemple de .dockerignore recommandé :
node_modules
.git
.gitignore
Dockerfile
docker-compose.yml
dist
.env
Étapes :
mkdir docker-app cd docker-app
print(“Hello Johnny, Docker fonctionne en version ultra !”)
FROM python:3.12-slim WORKDIR /app COPY . . CMD [“python”, “app.py”]
docker build -t monpython:1.0 .
docker run monpython:1.0
Hello Johnny, Docker fonctionne en version ultra !
Le module 3 est crucial pour produire des images propres, rapides, petites et adaptées à la production.
Ce module couvre en profondeur :
Un conteneur est une instance vivante d’une image Docker. Il représente :
Schéma :
IMAGE (read-only layers)
│
▼
CONTAINER (read-write layer)
│
▼
Processus principal (ENTRYPOINT/CMD)
Un conteneur vit tant que SON PROCESSUS PRINCIPAL est en vie.
Commandes de base :
Les états visibles via :
docker ps -a
États courants :
docker run -d nginx
docker run –name web nginx
docker run -e APP_ENV=prod monapp
docker run -it ubuntu bash
docker run -v /host/data:/container/data nginx
Docker peut redémarrer automatiquement un conteneur.
--restart=no (par défaut) --restart=on-failure (si process error) --restart=always (toujours) --restart=unless-stopped
Exemple :
docker run --restart=always myservice
Très utilisé en production hors orchestrateur.
docker inspect moncontainer
Parties importantes :
docker inspect -f 'networksettings.ipaddress' moncontainer
docker logs moncontainer docker logs -f moncontainer
Options utiles :
docker exec -it moncontainer bash
ou si bash n’existe pas :
docker exec -it moncontainer sh
docker exec moncontainer ls -la
Chaque conteneur n’a qu’un seul processus principal.
Vérifier :
docker top moncontainer
Dans un OS classique :
ps aux
docker stop envoie :
1. SIGTERM (arrêt propre) 2. après 10 secondes → SIGKILL (forcé)
Changer le délai :
docker stop --time=3 moncontainer
Schéma :
HOST : 8080 → CONTAINER : 80
Commande :
docker run -p 8080:80 nginx
Lister les ports :
docker port moncontainer
Le conteneur a son propre système :
docker exec -it moncontainer sh ls -la
Pour copier un fichier :
docker cp fichier.txt moncontainer:/tmp/ docker cp moncontainer:/etc/nginx/nginx.conf .
docker rm id docker rm -f id docker container prune docker system prune
→ mauvais CMD / erreur au démarrage
docker logs
→ le port hôte est occupé
→ conteneur arrêté, vérifier avec docker ps -a
→ volumes ou fichiers hôte non accessibles
docker run -d -p 8080:80 –name demo-nginx nginx
docker exec -it demo-nginx sh
docker logs -f demo-nginx
docker cp demo-nginx:/etc/nginx/nginx.conf .
docker restart demo-nginx
docker rm -f demo-nginx
Ce module donne toutes les bases nécessaires pour maîtriser les conteneurs de manière professionnelle.
Ce module ultra complet couvre :
Ce module est essentiel pour les bases de données, les CMS (WordPress), les APIs persistant des données, etc.
Par défaut, un conteneur Docker :
Donc sans volume :
Il faut donc des volumes persistants.
| Type | Description | Persistance | Usage recommandé |
|---|---|---|---|
| Anonymous volumes | créés automatiquement | Oui | cas rares |
| Named volumes | gérés par Docker | Oui | base de données |
| Bind mounts | mapping d’un dossier hôte | Oui | développement local |
Création :
docker volume create data-mysql
Utilisation :
docker run -d -v data-mysql:/var/lib/mysql mysql:8
Lister :
docker volume ls
Inspecter :
docker volume inspect data-mysql
Avantages :
Syntaxe :
-v /chemin/hote:/chemin/conteneur
Exemple :
docker run -d -v /home/johnny/site:/var/www/html php:8.2-apache
Avantages :
Inconvénients :
Sous Linux :
/var/lib/docker/volumes/
Sous macOS et Windows (Docker Desktop) : Stockés dans un disque virtuel interne.
Depuis un conteneur temporaire :
docker run –rm -it -v data-mysql:/data alpine sh
Puis dans le conteneur :
ls -la /data
Dans un volume, les permissions dépendent du conteneur, pas de l’hôte (sauf bind mount).
Corriger une permission avec alpine :
docker run –rm -v data:/data alpine chown -R 1000:1000 /data
Création d’une archive :
docker run –rm -v data-mysql:/source -v /backup:/backup alpine tar czvf /backup/mysql.tar.gz /source
Restauration :
docker run –rm -v data-mysql:/dest -v /backup:/backup alpine tar xzvf /backup/mysql.tar.gz -C /dest –strip 1
Supprimer un volume spécifique :
docker volume rm data-mysql
Supprimer les volumes inutilisés :
docker volume prune
Objectif :
Commandes à exécuter :
docker volume create mysql-data docker run -d –name mydb -e MYSQL_ROOT_PASSWORD=1234 -v mysql-data:/var/lib/mysql mysql:8
Ajouter une table :
docker exec -it mydb mysql -u root -p1234 -e “CREATE DATABASE test;” docker exec -it mydb mysql -u root -p1234 -e “USE test; CREATE TABLE demo(id INT);”
Supprimer le conteneur :
docker rm -f mydb
Vérification :
docker run –rm -it -v mysql-data:/data alpine ls -la /data
→ les fichiers .ibd et .frm sont présents → la base est bien persistée
Création bind mount :
mkdir ~/monapp echo “hello” > ~/monapp/test.txt
docker run –rm -it -v ~/monapp:/data alpine sh
Dans alpine :
cat /data/test.txt
MODIFIER depuis le conteneur :
echo “modifié” > /data/test.txt
Quitter, puis vérifier côté hôte :
cat ~/monapp/test.txt
→ Le fichier local a été modifié → preuve que bind mount = partage natif
Créer un volume :
docker volume create testdata
Ajouter des fichiers :
docker run –rm -v testdata:/data alpine sh -c “echo 'Johnny' > /data/name.txt”
Sauver :
mkdir ~/backup docker run –rm -v testdata:/source -v ~/backup:/backup alpine tar czvf /backup/archive.tar.gz /source
Fichier créé :
ls -la ~/backup/archive.tar.gz
→ archive présente → backup réussi
Ce module ultra complet couvre :
Ce module est essentiel pour comprendre comment les conteneurs communiquent.
Lorsqu’un conteneur Docker est lancé, Docker lui attribue :
Schéma général :
[Host Network]
│
[Docker Engine]
│
[Bridge Network] — Conteneurs isolés + IP internes
Chaque conteneur vit dans un namespace réseau isolé.
| Type | Description | Usage |
|---|---|---|
| bridge | par défaut, réseau isolé en NAT | usage général |
| host | partage le réseau du host | performance, accès direct |
| none | aucun réseau | sécurité maximale |
| overlay | réseau multi-hôte, Swarm/K8s | clusters |
| macvlan | donne une adresse MAC réelle | intégration LAN |
| ipvlan | similaire macvlan mais plus simple | datacenters |
Le réseau *bridge* est créé automatiquement :
docker network ls
On y voit :
bridge host none
IP par défaut :
172.17.0.0/16
Lorsqu’un conteneur démarre :
docker run -d nginx
Il reçoit une IP locale :
172.17.0.2
Le mapping :
-p 8080:80
Signifie :
HÔTE port 8080 → CONTENEUR port 80
Docker configure automatiquement :
docker network inspect bridge
docker inspect moncontainer
Sections importantes :
Créer :
docker network create monreseau
Lancer deux conteneurs :
docker run -d –name web –network monreseau nginx docker run -d –name api –network monreseau alpine sleep 9999
Tester la communication :
docker exec -it api ping web
Résultat attendu :
PING web (172.x.x.x): 56 data bytes
Docker crée automatiquement un DNS interne.
Créer un alias :
docker run -d –network monreseau –network-alias backend nginx
Tester :
docker exec -it api ping backend
docker run –network host nginx
Le conteneur :
Avantage → perf maximale Inconvénient → aucune isolation
docker run –network none alpine
Résultat :
Idéal pour :
Macvlan permet d’attribuer une vraie adresse MAC.
Exemple de création :
docker network create -d macvlan –subnet=192.168.1.0/24 –gateway=192.168.1.1 -o parent=eth0 pubnet
Les conteneurs apparaissent comme des machines réelles sur le LAN.
Utilisé pour Swarm ou Kubernetes.
Permet à des conteneurs :
Exemple :
version: “3.9” services:
web:
image: nginx
networks:
- backend
api:
image: alpine
command: sleep 9999
networks:
- backend
networks:
backend: driver: bridge
Test DNS :
docker compose exec api ping web
docker exec -it conteneur nslookup web
docker run –rm -it –net=host nicolaka/netshoot
Netshoot contient :
Commandes :
docker run -d –name test-nginx nginx docker inspect -f 'networksettings.ipaddress' test-nginx
RÉPONSE ATTENDUE : → Une IP interne `172.17.x.x`
Création réseau :
docker network create reseau-test
Lancement conteneurs :
docker run -d –name c1 –network reseau-test alpine sleep 9999 docker run -d –name c2 –network reseau-test alpine sleep 9999
Ping :
docker exec -it c1 ping -c 2 c2
RÉPONSE ATTENDUE : → Ping OK grâce au DNS Docker
docker run –network none alpine ip a
RÉPONSE ATTENDUE : → Seule interface disponible : `lo`
Ce module permet de maîtriser tous les aspects réseau indispensables en production.
Ce module ultra complet couvre :
Docker Compose est l’outil indispensable pour gérer des environnements multi-conteneurs.
Docker Compose permet de :
Commande principale :
docker compose up -d
Structure générale :
version: “3.9” services:
service1: ... service2: ...
networks:
...
volumes:
...
Les sections principales :
Exemple :
services:
web:
image: nginx
ports:
- "8080:80"
Options courantes :
services:
api:
build: .
ports:
- "3000:3000"
Compose exécutera automatiquement :
docker build .
environment:
Fichier `.env` :
APP_ENV=prod PORT=8080
Compose :
ports:
Exemple :
services:
db:
image: mysql
volumes:
- dbdata:/var/lib/mysql
volumes:
dbdata:
Permet la persistance automatique.
Définir un réseau :
networks:
backend: driver: bridge
Assigner un service :
services:
api:
image: myapi
networks:
- backend
Par défaut, Compose crée un réseau :
<dossier>_default
services:
web:
depends_on:
- db
IMPORTANT : depends_on ne garantit PAS que db soit prêt, seulement qu'il démarre avant.
Pour vérifier la santé :
healthcheck:
test: ["CMD", "curl", "-f", "http://localhost"] interval: 5s timeout: 3s retries: 5
services:
app: image: node command: ["npm", "start"]
Override ENTRYPOINT :
entrypoint: [“python3”] command: [“app.py”]
restart: always restart: on-failure restart: unless-stopped
docker compose up -d –scale web=3
Limites :
Exemple correct :
ports:
(= port dynamique)
docker compose up -d docker compose down docker compose ps docker compose logs -f docker compose exec <service> <commande> docker compose restart docker compose up -d –build
version: “3.9” services:
web:
image: nginx
ports:
- "8080:80"
volumes:
- ./nginx.conf:/etc/nginx/nginx.conf
depends_on:
- php
php:
image: php:8.2-fpm
volumes:
- ./app:/var/www/html
db:
image: mysql:8
environment:
MYSQL_ROOT_PASSWORD: root
volumes:
- dbdata:/var/lib/mysql
volumes:
dbdata:
version: “3.9” services:
api:
build: ./api
ports:
- "3000:3000"
depends_on:
- redis
redis:
image: redis:7
command: ["redis-server", "--appendonly", "yes"]
volumes:
- redisdata:/data
volumes:
redisdata:
docker-compose.yml :
version: “3.9” services:
web:
image: nginx
ports:
- "8080:80"
Commande :
docker compose up -d
RÉPONSE : http://localhost:8080 affiche Nginx.
docker-compose.yml :
services:
c1: image: alpine command: sleep 9999
c2: image: alpine command: sleep 9999
Test :
docker compose exec c1 ping -c 2 c2
RÉPONSE : Le ping fonctionne grâce au DNS interne Docker.
docker-compose.yml :
version: “3.9” services:
db:
image: mysql:8
environment:
MYSQL_ROOT_PASSWORD: 1234
volumes:
- mysqldata:/var/lib/mysql
volumes:
mysqldata:
Test :
docker compose exec db mysql -uroot -p1234 -e “CREATE DATABASE testdb;” docker compose down docker compose up -d docker compose exec db mysql -uroot -p1234 -e “SHOW DATABASES;”
RÉPONSE : La base testdb apparaît → la persistance fonctionne.
Ce module est indispensable pour déployer des stacks multi-services (WordPress, Laravel, Django, Node.js, Next.js…).
Ce module ultra complet couvre :
Ce module est essentiel pour un usage professionnel de Docker.
Docker apporte une isolation, mais pas une sécurité absolue.
Risques courants :
Objectif : Protéger l’hôte, les conteneurs et les données.
Le conteneur tourne par défaut en root, ce qui permettrait :
Solution recommandée : Créer un utilisateur interne.
Exemple dans Dockerfile :
RUN adduser -D appuser USER appuser
Pour vérifier :
docker exec -it monapp id
Docker retire la majorité des capabilities, mais certaines restent.
Lister les capabilities disponibles :
docker run –rm alpine capsh –print
Désactiver TOUTES les capabilities :
docker run –cap-drop=ALL myapp
N’en autoriser qu’une :
docker run –cap-drop=ALL –cap-add=NET_ADMIN myapp
Seccomp = sandbox de syscalls Linux.
Voir le profil par défaut :
/usr/share/docker/seccomp.json
Exécuter un conteneur sans seccomp :
docker run –security-opt seccomp=unconfined myapp
→ DÉCONSEILLÉ en production.
Voir profils :
aa-status
Activer un profil :
docker run –security-opt apparmor=monprofil myapp
Mode permissif :
setenforce 0
Mode enforcing :
setenforce 1
Label SELinux pour Docker :
docker run -v data:/data:Z myapp
Docker propose un scan natif :
docker scan monimage
Sortie :
Autre outil : Trivy
docker run aquasec/trivy image monimage
Activer la confiance :
export DOCKER_CONTENT_TRUST=1
Signer une image :
docker trust sign monrepo/monimage:1.0
Valider une signature :
docker trust inspect monrepo/monimage
Bonnes pratiques 2025 :
RUN apk del curl git build-base
docker run –pids-limit 100 myapp
docker run –memory=512m myapp
docker run –cpus=“1.0” myapp
docker run –read-only myapp
docker run –security-opt no-new-privileges myapp
—- Réduire la surface d'exposition —-
—- Exemple : Nginx accessible seulement via backend —-
networks:
backend: public:
services:
nginx:
networks:
- public
- backend
api:
networks:
- backend
—- Firewall interne —-
docker run –cap-add NET_ADMIN alpine iptables -L
Ne jamais mettre les secrets dans :
secrets:
db_pass: file: ./db_pass.txt
services:
db:
secrets:
- db_pass
Dans le conteneur :
/run/secrets/db_pass
Authentification :
docker login registry.example.com
Limiter le push :
docker push registry.example.com/secure/image:1.0
Registry privé sécurisé :
Objectif : Créer un conteneur avec un utilisateur non-root.
Solution :
docker run -it –user 1000:1000 alpine id
RÉPONSE : Le conteneur affiche :
uid=1000 gid=1000
Commandes :
docker run –cap-drop=ALL alpine sh -c “ping 8.8.8.8”
RÉSULTAT ATTENDU :
ping: socket: Operation not permitted
→ NORMAL : capability supprimée.
docker scan nginx
RÉSULTAT ATTENDU : Liste de CVE + niveaux critique/haut/moyen.
docker run –read-only -it alpine touch /test
RÉPONSE ATTENDUE :
touch: /test: Read-only file system
Ce module est indispensable pour un déploiement professionnel sécurisé.
Ce module ultra complet couvre :
C’est le module le plus pratique pour travailler comme un professionnel.
Portainer permet :
Installation :
docker volume create portainer_data docker run -d -p 9443:9443 –name portainer –restart=always -v /var/run/docker.sock:/var/run/docker.sock -v portainer_data:/data portainer/portainer-ce
Accès :
Permet :
Compose complet :
version: “3.9” services:
npm:
image: jc21/nginx-proxy-manager:latest
ports:
- "80:80"
- "81:81"
- "443:443"
volumes:
- npm-data:/data
- npm-letsencrypt:/etc/letsencrypt
volumes:
npm-data: npm-letsencrypt:
Traefik permet :
Exemple service avec labels :
services:
api:
image: myapi
labels:
- "traefik.enable=true"
- "traefik.http.routers.api.rule=Host(`api.example.com`)"
docker run -d –name watchtower -v /var/run/docker.sock:/var/run/docker.sock containrrr/watchtower
Fonctions :
docker run –rm -it nicolaka/netshoot
Inclut :
Ex : résolution DNS interne →
dig web
docker run -d -p 8080:8080 –name cadvisor –volume=/:/rootfs:ro –volume=/var/run:/var/run:ro –volume=/sys:/sys:ro –volume=/var/lib/docker/:/var/lib/docker:ro gcr.io/cadvisor/cadvisor
Interface :
Fonctions :
docker run –rm -it wagoodman/dive:latest <image>
Dive analyse :
Installation :
curl https://raw.githubusercontent.com/jesseduffield/lazydocker/master/scripts/install_update_linux.sh | bash
Interface :
lazydocker
Fonctions :
docker buildx create –use docker buildx build –platform linux/arm64,linux/amd64 -t image:latest .
Pratique pour :
stern “api-*”
Similaire à :
docker compose logs -f
Mais avec filtrage avancé.
Commandes :
docker volume create portainer_data docker run -d -p 9443:9443 –name portainer -v /var/run/docker.sock:/var/run/docker.sock -v portainer_data:/data portainer/portainer-ce
RÉPONSE : Accès → https://localhost:9443
Commandes :
docker run -d –name web nginx docker run -d –name api –network bridge alpine sleep 9999 docker exec -it api apk add bind-tools docker exec -it api dig web
RÉSULTAT ATTENDU : web.docker resolve vers → 172.17.x.x
Commande :
docker run –rm -it wagoodman/dive:latest nginx
RÉSULTAT ATTENDU :
Commande :
docker run -d –name watchtower -v /var/run/docker.sock:/var/run/docker.sock containrrr/watchtower –interval 30
RÉPONSE ATTENDUE : Watchtower surveille les images toutes les 30 secondes.
Ce module fournit l’ensemble des outils nécessaires à une gestion pro et simplifiée de Docker.
Ce module ultra complet couvre :
Ce module est la conclusion professionnelle de toute la formation.
Une stack Docker prête pour la production doit respecter :
Le mot d’ordre : minimalisme + sécurité + observabilité.
Images recommandées :
Éviter :
Bonne pratique :
FROM node:20-alpine RUN adduser -D appuser USER appuser
docker run –cpus=“1.0” myapp
docker run –memory=“512m” myapp
docker run –pids-limit=100 myapp
docker run –read-only myapp
Ne jamais stocker les logs DANS le conteneur.
Solutions recommandées :
Logging driver :
docker run –log-driver json-file myapp
Outils essentiels :
Exemple cAdvisor :
docker run -d -p 8080:8080 gcr.io/cadvisor/cadvisor
Traefik :
Exemple labels :
labels:
Déployer progressif → réduire risques.
2 versions en parallèle → switch instantané.
Un petit pourcentage du trafic teste la nouvelle version.
Toujours sauvegarder :
Backup modèle :
docker run –rm -v data:/source -v /backup:/backup alpine tar czvf /backup/data.tar.gz /source
Pipeline GitHub Actions :
name: Deploy on: push jobs:
build:
runs-on: ubuntu-latest
steps:
- uses: actions/checkout@v3
- run: docker build -t myapp .
- run: docker login -u $USER -p $PASS
- run: docker push myapp
Pipeline complet :
docker swarm init docker service create –replicas 3 nginx
Fonctions :
Kubernetes permet :
Idéal pour :
Checklist :
Exemple :
docker run –security-opt no-new-privileges –cap-drop=ALL myapp
Séparer les réseaux :
Exemple Compose :
networks:
public: internal:
services:
web:
networks:
- public
- internal
db:
networks:
- internal
Commande :
docker run –cpus=“0.5” –memory=“256m” nginx
RÉPONSE : Le conteneur ne peut utiliser que :
docker scan nginx
RÉPONSE : La liste des CVE s’affiche → corrigées avant mise en prod.
docker run –read-only -it alpine touch /test
RÉSULTAT ATTENDU :
touch: /test: Read-only file system
Ce module final clôture toute la formation en vous donnant les standards industriels actuels.
Cette page a pour source partielle ou intégrale la ou les page(s) suivante(s):
Page dans la catégorie: