Mini-test 6

Commandes
Docker

build, run, ps, logs, exec, stop, rm, rmi, prune, inspect

9 questions + 3 supplement

construire lancer inspecter nettoyer

Cliquez Voir la solution sur chaque slide

← → naviguer · S solution · R recommencer

Question 1 / 9 vue d'ensemble - drag & drop

Associer chaque commande Docker a son role

Glissez chaque commande dans la case qui decrit son role. Cliquez sur une commande deja deposee pour la retirer. Le bouton Voir la solution (S) verifie vos placements.

docker build

docker run

docker ps

docker logs

docker exec

docker stop

docker rm

docker rmi

docker system prune

docker inspect

10 commandes - 10 roles. Drag & drop chaque commande sur sa description :

Construire une image

a partir d'un Dockerfile

Creer et lancer un container

a partir d'une image

Lister les containers

actifs (ou tous avec -a)

Voir la sortie d'un container

stdout / stderr du PID 1

Executer une commande

DANS un container actif

Arret propre d'un container

SIGTERM puis SIGKILL 10s apres

Supprimer un container

stoppe (l'instance)

Supprimer une image

le modele, plus aucun container ne l'utilise

Liberer l'espace disque

containers stoppes + images dangling + reseaux

Voir la config detaillee

JSON complet (IP, env, volumes...)

Reponses (a savoir par coeur) :

Commande	Role
`docker build`	construire une image depuis un Dockerfile
`docker run`	creer et lancer un nouveau container
`docker ps`	lister les containers
`docker logs`	voir stdout/stderr du PID 1
`docker exec`	executer une commande DANS un container actif
`docker stop`	arret propre (SIGTERM puis SIGKILL)
`docker rm`	supprimer un container stoppe
`docker rmi`	supprimer une image
`docker system prune`	liberer l'espace (stoppes + dangling + reseaux + cache)
`docker inspect`	voir la config detaillee (JSON)

Astuce mnemonique - les 3 grandes familles :

Images : build, pull, images, rmi
Containers : run, ps, logs, exec, stop, start, rm, inspect, stats, top
Maintenance : prune (variantes : container prune, image prune, builder prune, system prune)

Question 2 / 9 docker build + run

Recevoir un projet docker et le lancer

Une etudiante vous donne le projet jeu-2048-quebec, un clone web du jeu 2048. Vous le clonez localement et vous trouvez la structure suivante :

jeu-2048-quebec/
├── Dockerfile           # deja fourni
├── index.html
├── script.js
├── style.css
└── README.md

Le Dockerfile expose le port 80. Vous voulez (a) compiler l'image et la tagger jeu-2048:1.0, puis (b) lancer un container en arriere-plan, accessible depuis http://localhost:8080.

a) Compilation de l'image (depuis le repertoire parent de jeu-2048-quebec/) :

b) Lancement en arriere-plan, port 8080 (hote) sur 80 (container) :

DOCKER(1) - extrait du manuel

NAME
       docker - Docker container management

COMMANDS PRINCIPALES

   Cycle de vie d'un container
       run       cree et lance un container depuis une image
       start     demarre un container arrete
       stop      arrete un container
       restart   redemarre
       rm        supprime un container

   Inspection
       ps        liste les containers (-a pour tous)
       logs      voir la sortie (-f pour suivre en temps reel)
       inspect   info detaillee (format JSON)
       exec      executer une commande dans un container actif

   Images
       build     construit une image depuis un Dockerfile
       images    liste les images
       rmi       supprime une image
       pull      telecharge depuis un registry

OPTIONS de docker run (les plus frequentes)
       -d, --detach          arriere-plan
       --name STRING       nom au container
       --rm                auto-supprime apres l'arret
       -p HOST:CONTAINER  publier un port
       -v HOST:CONTAINER  bind mount un volume
       -e KEY=VALUE       variable d'environnement
       -it                interactif + TTY (pour bash)
       --restart POLICY    no, on-failure, always, unless-stopped

OPTIONS de docker build
       -t NOM:TAG          tag pour l'image (peut etre repete)
       -f CHEMIN           Dockerfile alternatif
       --build-arg KEY=VAL passer une valeur a un ARG
       --no-cache          rebuild sans cache
       --target STAGE      arreter a un stage (multi-stage)

EXEMPLES
       # Lancer en arriere-plan avec port mapping
       docker run -d -p 8080:80 --name web nginx

       # Avec volume + variable d'environnement
       docker run -d --name bdd \
           -v /data/postgres:/var/lib/postgresql/data \
           -e POSTGRES_PASSWORD=secret \
           postgres:15

       # Interactif (shell pour deboguer)
       docker run -it ubuntu bash

       # Auto-supprime apres execution
       docker run --rm alpine echo "hello"

       # Construire une image
       docker build -t monapp:1.0 .

       # Avec un build-arg
       docker build --build-arg VERSION=2.0 -t monapp:2.0 .

# a) Compilation : on lance le build depuis le repertoire parent
docker build -t jeu-2048:1.0 ./jeu-2048-quebec

# Variante : on entre d'abord dans le repertoire
cd jeu-2048-quebec
docker build -t jeu-2048:1.0 .
#                              ^ le point = repertoire courant comme contexte de build

# b) Lancement en arriere-plan avec mapping de port
docker run -d -p 8080:80 jeu-2048:1.0
#                ^^^^^^^^ 8080 sur l'hote -> 80 dans le container

Decryptage de docker build -t jeu-2048:1.0 ./jeu-2048-quebec :

build : commande de construction d'image
-t jeu-2048:1.0 : nom (jeu-2048) et tag (1.0) de l'image resultante
./jeu-2048-quebec : build context, le repertoire envoye au daemon Docker (qui doit contenir le Dockerfile)

Decryptage de docker run -d -p 8080:80 jeu-2048:1.0 :

run : creer et lancer un container
-d : detached (arriere-plan) - libere le terminal
-p 8080:80 : publier le port. Format EXTERNE:INTERNE. L'hote ecoute 8080, le container ecoute 80
jeu-2048:1.0 : l'image qu'on vient de compiler

Pour acceder au jeu : ouvrir http://localhost:8080 dans un navigateur.

Pour le donner un nom et auto-supprimer apres usage :

docker run -d --name jeu --rm -p 8080:80 jeu-2048:1.0
# --name jeu : nom du container (au lieu d'un hash aleatoire)
# --rm : auto-supprime le container apres son arret

Question 3 / 9 docker ps

Lister et filtrer les containers

Vous avez lance plusieurs containers du jeu-2048-quebec aujourd'hui pour tester differents ports, et certains ont plante. Un coup d'oeil rapide a la console :

CONTAINER ID   IMAGE          STATUS                NAMES
a12bc3d4       jeu-2048:1.0   Up 12 minutes         jeu-prod
f56ef7a8       jeu-2048:1.0   Up 3 minutes          jeu-test
9876dcba       jeu-2048:1.0   Exited (137) 1h ago   jeu-crash
4567abcd       nginx:latest   Up 2 hours            proxy

Donnez la commande exacte pour chaque sous-question.

a) Lister seulement les containers actifs :

b) Lister tous les containers, y compris ceux qui ont plante :

c) Lister tous les containers dont le nom contient jeu :

d) Afficher seulement les IDs de tous les containers (utile pour piper a une autre commande) :

DOCKER-PS(1) - extrait du manuel

NAME
       docker ps - lister les containers

SYNOPSIS
       docker ps [OPTIONS]

OPTIONS
       -a, --all
              affiche tous les containers (par defaut : seulement
              ceux qui sont actifs)

       -q, --quiet
              affiche seulement les IDs (utile pour piper)

       --filter CLE=VALEUR
              filtre la liste. Cles courantes :
                name=...      nom du container (sous-chaine)
                status=...    running, exited, paused, restarting
                ancestor=...  image dont descend le container
                label=...     label Docker

       -n NB           affiche les N derniers crees
       -s, --size    ajoute la taille des containers
       --format TPL    template Go pour formater la sortie

COLONNES PAR DEFAUT
       CONTAINER ID, IMAGE, COMMAND, CREATED, STATUS, PORTS, NAMES

STATUS - les codes utiles
       Up 5 minutes           tourne depuis 5 min
       Exited (0) 2h ago      stoppe normalement (code 0)
       Exited (137) 1m ago    SIGKILL ou OOM kill
       Restarting (1)         boucle de redemarrage (bug !)

EXEMPLES
       # Tous les containers
       docker ps -a

       # Filtrer par nom
       docker ps -a --filter name=jeu

       # Filtrer par statut
       docker ps -a --filter status=exited

       # Juste les IDs (pour les piper)
       docker ps -aq

       # Combinaison : tous les IDs des containers "jeu"
       docker ps -aq --filter name=jeu

       # Usage pratique : stopper tous les containers "jeu"
       docker stop $(docker ps -aq --filter name=jeu)

# a) Containers actifs (defaut)
docker ps

# b) Tous, y compris les stoppes
docker ps -a

# c) Filtre par nom (sous-chaine)
docker ps -a --filter name=jeu

# d) Seulement les IDs (utile pour piper)
docker ps -aq

Pourquoi le filtre par nom marche en sous-chaine : Docker fait du contains, donc name=jeu attrape jeu-prod, jeu-test et jeu-crash en meme temps.

Reflexe combine : on enchaine souvent ps + une autre commande :

# Stopper tous les "jeu" en un coup
docker stop $(docker ps -aq --filter name=jeu)

# Supprimer tous les containers stoppes
docker rm $(docker ps -aq --filter status=exited)

Lire le STATUS :

Up 12 minutes = tourne depuis 12 min
Exited (0) = stoppe normalement
Exited (137) = SIGKILL ou OOM kill (manque de RAM)
Restarting (1) = boucle de redemarrage, le container plante au demarrage

Question 4 / 9 docker logs

Suivre la sortie d'un container

Le container jeu-test (image jeu-2048:1.0) repond mais le score ne s'affiche pas dans le navigateur. Vous voulez voir ce qu'ecrit nginx pour comprendre.

a) Voir tous les logs de jeu-test depuis son demarrage :

b) Suivre les logs en temps reel (comme tail -f) :

c) Voir seulement les 50 dernieres lignes :

d) Suivre en temps reel mais en commencant aux 20 dernieres lignes :

DOCKER-LOGS(1) - extrait du manuel

NAME
       docker logs - afficher la sortie d'un container

SYNOPSIS
       docker logs [OPTIONS] CONTAINER

OPTIONS
       -f, --follow
              suivre la sortie en temps reel (comme tail -f)

       --tail NB
              affiche seulement les NB dernieres lignes
              (par defaut : all, tout l'historique)

       -t, --timestamps
              prefixer chaque ligne avec l'horodatage

       --since DUREE_OU_DATE
              n'afficher que depuis cette date / il y a cette duree
              ex : 10m, 2h, 2026-05-22T13:00:00

       --until DUREE_OU_DATE
              n'afficher que jusqu'a cette date

CE QUE VOIT logs
       Tout ce que le processus PID 1 du container ecrit sur
       stdout et stderr. Si l'application ecrit dans
       un fichier interne, docker logs ne verra rien.
       D'ou la convention "log to stdout" pour les containers.

EXEMPLES
       docker logs jeu-test
       docker logs -f jeu-test
       docker logs --tail 50 jeu-test
       docker logs -f --tail 20 jeu-test
       docker logs --since 10m jeu-test
       docker logs -ft jeu-test

# a) Tous les logs depuis le demarrage
docker logs jeu-test

# b) Suivre en temps reel (comme tail -f)
docker logs -f jeu-test

# c) 50 dernieres lignes
docker logs --tail 50 jeu-test

# d) Suivre, mais partir des 20 dernieres
docker logs -f --tail 20 jeu-test

# Bonus : avec horodatage
docker logs -ft jeu-test

# Filtrer par date
docker logs --since 10m jeu-test
docker logs --since "2026-05-22T13:00:00" jeu-test

Ce que voit docker logs : tout ce que le processus PID 1 ecrit sur stdout et stderr. Si nginx ecrit dans /var/log/nginx/access.log a l'interieur du container, docker logs ne verra rien - sauf si l'image a redirige ce fichier vers /dev/stdout (ce que font nginx:alpine et la plupart des images officielles).

Question 5 / 9 docker exec

Entrer dans un container actif

Pour deboguer le jeu-prod qui tourne (base sur nginx:alpine), vous voulez explorer ce qui est servi par le serveur web a l'interieur du container, sans le redemarrer.

a) Ouvrir un shell interactif dans jeu-prod (image alpine, donc sh) :

b) Lister le contenu de /usr/share/nginx/html dans jeu-prod, sans ouvrir de shell (commande unique) :

c) Afficher le contenu du fichier /usr/share/nginx/html/index.html :

DOCKER-EXEC(1) - extrait du manuel

NAME
       docker exec - executer une commande dans un container ACTIF

SYNOPSIS
       docker exec [OPTIONS] CONTAINER COMMANDE [ARG...]

OPTIONS
       -i, --interactive
              garde stdin ouvert (necessaire pour un shell)

       -t, --tty
              alloue un pseudo-terminal (pour le prompt, vi, etc.)

       -it     forme combinee, quasi systematique pour un shell

       -d, --detach
              lancer la commande en arriere-plan dans le container

       -e KEY=VALEUR
              passer une variable d'environnement a la commande

       -u, --user NOM
              executer en tant que cet utilisateur (par defaut : root)

       -w, --workdir CHEMIN
              repertoire de travail dans le container

SHELLS DISPONIBLES selon l'image
       debian, ubuntu, fedora   bash et sh
       alpine, busybox          sh seulement (pas de bash !)

ATTENTION
       docker exec ne marche que sur un container actif.
       Pour un container stoppe : le redemarrer (docker start)
       ou utiliser docker run --rm -it IMAGE sh.

EXEMPLES
       # Shell interactif (image classique)
       docker exec -it monApp bash

       # Shell interactif (image alpine)
       docker exec -it jeu-prod sh

       # Commande unique (pas de shell)
       docker exec jeu-prod ls /usr/share/nginx/html
       docker exec jeu-prod cat /etc/nginx/nginx.conf

       # Avec variable d'env
       docker exec -e DEBUG=1 jeu-prod ./diagnostic.sh

       # En tant qu'utilisateur non-root
       docker exec -u nginx -it jeu-prod sh

# a) Shell interactif - alpine donc sh (pas bash !)
docker exec -it jeu-prod sh

# b) Lister sans entrer dans le container
docker exec jeu-prod ls /usr/share/nginx/html

# c) Lire un fichier sans entrer
docker exec jeu-prod cat /usr/share/nginx/html/index.html

Pourquoi -i ET -t pour un shell :

-i (interactive) : garde stdin ouvert, sinon le shell se ferme aussitot car personne ne lui parle.
-t (tty) : alloue un pseudo-terminal, sinon pas de prompt et certaines commandes (comme vi) s'affichent mal.
On les combine quasi toujours en -it. Pour une commande unique non-interactive (b et c), on n'en a pas besoin.

Alpine vs Debian : les images alpine et busybox n'ont pas de bash, juste sh. Toujours essayer sh d'abord avec ces images.

Limite : docker exec ne marche que sur un container actif. Pour un container stoppe, le redemarrer ou utiliser docker run --rm -it IMAGE sh.

Question 6 / 9 arret et nettoyage

Tout demonter : stop, rm, rmi

Vous avez fini de tester le jeu-2048-quebec. Vous voulez tout demonter proprement : arreter le container jeu-test, le supprimer, puis supprimer l'image jeu-2048:1.0 au complet.

a) Arreter proprement le container jeu-test :

b) Supprimer le container jeu-test (il est deja stoppe) :

c) Supprimer l'image jeu-2048:1.0 (plus aucun container ne l'utilise) :

DOCKER-STOP(1) - extrait du manuel

NAME
       docker stop - arret PROPRE d'un container actif

SYNOPSIS
       docker stop [OPTIONS] CONTAINER [CONTAINER...]

OPTIONS
       -t, --time SEC
              delai entre SIGTERM et SIGKILL.
              Par defaut : 10 secondes

       -s, --signal SIG
              signal initial a envoyer (par defaut SIGTERM)

SIGNAUX
       envoie d'abord SIGTERM au PID 1 du container.
       Si le container n'a pas obei apres --time secondes,
       envoie SIGKILL (arret forcé immediat).

       Pour un SIGKILL direct : docker kill CONTAINER.

ON NE PEUT PAS
       stopper un container deja stoppe (no-op, pas d'erreur).
       stopper une image (stop = container seulement).

EXEMPLES
       # Arret propre
       docker stop jeu-test

       # Arret avec delai personnalise (30s avant SIGKILL)
       docker stop -t 30 jeu-test

       # Plusieurs containers en une commande
       docker stop jeu-test jeu-prod

       # Tous les containers actifs
       docker stop $(docker ps -q)

DOCKER-RM(1) - extrait du manuel

NAME
       docker rm - supprimer un ou plusieurs CONTAINERS

SYNOPSIS
       docker rm [OPTIONS] CONTAINER [CONTAINER...]

OPTIONS
       -f, --force
              forcer la suppression d'un container actif
              (envoie SIGKILL puis supprime - equivalent stop+rm)

       -v, --volumes
              supprimer aussi les volumes anonymes rattaches
              (NB : les volumes nommes sont epargnes)

       -l, --link
              supprimer le lien reseau, pas le container

ON NE PEUT PAS
       supprimer un container ACTIF (sans -f).
       Il faut docker stop d'abord.

DIFFERENCE AVEC rmi
       docker rm  -> supprime un CONTAINER (instance)
       docker rmi -> supprime une IMAGE (modele)

EXEMPLES
       # Suppression standard (container deja stoppe)
       docker rm jeu-test

       # Force : stop + rm en un
       docker rm -f jeu-test

       # Plusieurs containers
       docker rm jeu-test jeu-prod jeu-crash

       # Tous les containers stoppes
       docker rm $(docker ps -aq --filter status=exited)
       # (ou plus simple : docker container prune)

DOCKER-RMI(1) - extrait du manuel

NAME
       docker rmi - supprimer une ou plusieurs IMAGES

SYNOPSIS
       docker rmi [OPTIONS] IMAGE [IMAGE...]

OPTIONS
       -f, --force
              forcer malgre containers existants qui utilisent l'image

       --no-prune
              ne pas supprimer les images parentes intermediaires

ON NE PEUT PAS
       supprimer une image utilisee par un container EXISTANT
       (meme un container stoppe). Il faut docker rm d'abord
       tous les containers de cette image.

REFERENCER UNE IMAGE
       Par NOM:TAG     ex : jeu-2048:1.0
       Par NOM          equivaut a NOM:latest
       Par ID           ex : a1b2c3d4e5f6 (les 12 premiers car.)

DIFFERENCE AVEC rm
       docker rm  -> supprime un CONTAINER (instance)
       docker rmi -> supprime une IMAGE (modele)

EXEMPLES
       # Suppression par nom:tag
       docker rmi jeu-2048:1.0

       # Plusieurs images
       docker rmi jeu-2048:1.0 jeu-2048:2.0

       # Force malgre containers stoppes
       docker rmi -f jeu-2048:1.0

       # Supprimer toutes les images dangling (sans tag)
       docker rmi $(docker images -f "dangling=true" -q)
       # (ou plus simple : docker image prune)

# a) Arret propre (SIGTERM, puis SIGKILL 10s apres)
docker stop jeu-test

# b) Suppression du container (qui est maintenant stoppe)
docker rm jeu-test

# c) Suppression de l'image (aucun container ne l'utilise)
docker rmi jeu-2048:1.0

Pourquoi cet ordre :

On ne peut pas rm un container qui tourne encore - il faut le stopper d'abord, ou utiliser rm -f
On ne peut pas rmi une image encore utilisee par un container existant (meme stoppe)
D'ou la sequence : stop -> rm container -> rmi image

Raccourcis pratiques :

# Force stop + rm en un
docker rm -f jeu-test

# Arret de tous les containers actifs
docker stop $(docker ps -q)

# Suppression de tous les containers stoppes
docker container prune

SIGTERM vs SIGKILL : docker stop envoie d'abord SIGTERM (poliment "arrete-toi"). Si le container n'a pas obtempere apres 10 secondes, SIGKILL (force brute). docker kill envoie directement SIGKILL.

Question 7 / 9 prune : nettoyer

Faire le menage : les niveaux de prune

Cette semaine vous avez lance et stoppe 15 containers du jeu-2048-quebec et reconstruit l'image 8 fois en testant des Dockerfile differents. Votre disque est plein de containers stoppes, d'images intermediaires <none> et de caches de build.

a) Niveau 1 - supprimer SEULEMENT les containers stoppes :

b) Niveau 2 - supprimer les images sans tag (dangling, affichees <none>) :

c) Niveau 3 - supprimer le cache de build (peut etre enorme apres plusieurs builds) :

d) Niveau 4 - tout d'un coup : containers stoppes + images dangling + reseaux + cache :

DOCKER prune - extrait du manuel

NAME
       docker ... prune - liberer de l'espace en supprimant les
                          ressources Docker non utilisees

SOUS-COMMANDES, par cible
       docker container prune
              supprime les containers stoppes (status=exited|dead)

       docker image prune
              supprime les images dangling (sans tag, <none>)
              avec -a : supprime aussi les images sans container actif

       docker builder prune
              supprime le cache de build (les layers intermediaires)
              avec -a : tout le cache, y compris utilise recemment

       docker volume prune
              supprime les volumes non utilises
              ATTENTION : ce sont les donnees

       docker network prune
              supprime les reseaux non utilises

       docker system prune
              equivalent a container + image (dangling) + network + builder
              avec -a : aussi les images sans container actif
              avec --volumes : aussi les volumes (DONNEES !)

OPTIONS COMMUNES
       -f, --force     pas de confirmation
       --filter CRITERE  conserver selon un critere (ex: until=24h)

VOIR L'ESPACE PRIS
       docker system df      vue d'ensemble
       docker system df -v   detaillee (par image, container, volume)

REGLES DE SECURITE
       En developpement local :
           docker system prune -a regulier, c'est OK.

       Sur serveur de production :
           Ne JAMAIS faire -a aveuglement. Une image sans container
           actif peut etre legitime (ex: mise a jour roulante).
           Ne JAMAIS mettre --volumes sauf si certain. Ce sont les donnees.

# a) Niveau 1 : containers stoppes uniquement
docker container prune

# b) Niveau 2 : images sans tag (dangling)
docker image prune

# c) Niveau 3 : cache de build (peut etre enorme)
docker builder prune

# d) Niveau 4 : tout d'un coup
docker system prune

# Niveau 5 (DANGER) : ajoute aussi les images sans container actif
docker system prune -a

# Niveau 6 (DANGER MAX) : ajoute meme les volumes (donnees !)
docker system prune -a --volumes

Voir l'espace pris par Docker avant de pruner :

docker system df
docker system df -v   # plus detaille

Reflexes :

En dev local : docker system prune -a regulier, c'est OK.
En production : NE PAS faire -a aveugle. Une image sans container actif peut etre legitime (ex: mise a jour roulante).
--volumes : jamais sans etre absolument certain. Ce sont les donnees.

Question 8 / 9 QCM diagnostic

Choisir la bonne commande - diagnostic

Pour chaque situation, cliquez sur la seule commande qui resout le probleme. Le bouton Voir la solution (S) revele les bonnes reponses.

a) Le container jeu-prod retourne 500 Internal Server Error. Vous voulez voir ce que nginx ecrit comme erreur :

docker inspect
jeu-prod

docker logs
jeu-prod

docker stats
jeu-prod

docker ps
jeu-prod

b) Vous voulez verifier que jeu-test est encore actif sans entrer dedans :

docker exec
jeu-test ls

docker logs
jeu-test

docker ps --filter
name=jeu-test

docker rm
jeu-test

c) Le container jeu-prod semble consommer 90% de la RAM. Pour le constater en temps reel :

docker logs
jeu-prod

docker top
jeu-prod

docker stats
jeu-prod

docker inspect
jeu-prod

d) Vous voulez connaitre l'IP interne de jeu-prod :

docker ps
jeu-prod

docker inspect --format
'{{.NetworkSettings.IPAddress}}'
jeu-prod

docker logs --tail 1
jeu-prod

docker stats
jeu-prod

a) B - docker logs jeu-prod - voir ce que nginx ecrit sur stdout/stderr.

b) C - docker ps --filter name=jeu-test - sans entrer, juste verifier l'existence et le statut. docker logs verrait l'historique meme si le container est mort.

c) C - docker stats jeu-prod - les pourcentages CPU et RAM en temps reel. docker top liste juste les processus (sans %).

d) B - docker inspect --format '{{.NetworkSettings.IPAddress}}' jeu-prod - extraction chirurgicale d'un champ via template Go.

Memo - quelle commande pour quel diagnostic ?

Quel statut ? -> ps
Pourquoi ca a plante ? -> logs
Combien de CPU/RAM ? -> stats
Quels processus ? -> top
Quelle config ? -> inspect

Question 9 / 9 QCM cycle de vie

Choisir la bonne commande - cycle de vie et erreurs

Cas tires de la vraie vie. Pour chaque message d'erreur ou besoin, choisir la bonne reponse.

a) Vous tapez docker rm jeu-test. Erreur : "You cannot remove a running container. Stop the container before attempting removal or force remove.". Le plus court chemin :

docker kill
jeu-test

puis recommencer

docker stop jeu-test
puis docker rm jeu-test

docker rm -f
jeu-test

Redemarrer Docker

b) Vous avez modifie le Dockerfile et vous voulez recompiler l'image en version 2.0 :

docker run -t
jeu-2048:2.0

docker build -t jeu-2048:2.0
./jeu-2048-quebec

docker pull
jeu-2048:2.0

docker exec
jeu-2048 build

c) docker rmi jeu-2048:1.0 refuse : "image is being used by stopped container". La commande la plus chirurgicale :

docker container prune
puis docker rmi jeu-2048:1.0

docker system prune -a
--volumes

docker stop $(docker ps -aq)
puis docker rmi

docker rm --force
jeu-2048:1.0

d) Apres 8 builds, votre disque est plein d'images intermediaires <none>. La commande la plus ciblee :

docker system prune
-a --volumes

docker image prune

docker rm $(docker ps -q)

docker rmi *

a) C - docker rm -f jeu-test - -f envoie SIGKILL et supprime en un seul appel. Sinon B en deux temps marche aussi (stop puis rm) mais c'est plus long. A (kill) supprime juste le processus, pas le container.

b) B - docker build -t jeu-2048:2.0 ./jeu-2048-quebec - build compile, run lance, pull telecharge depuis un registry.

c) A - docker container prune puis docker rmi - on supprime juste les containers stoppes (rien d'autre), puis l'image se laisse supprimer. B serait dramatiquement excessif (--volumes = donnees). D melange container/image.

d) B - docker image prune - cible exactement les images dangling (sans tag, <none>). A est trop agressif (touche aussi aux volumes !). C ne supprime pas les images.

Regle d'or : -f et system prune -a --volumes sont vos amis... ou vos pires ennemis. Dev local : on les utilise. Production : jamais sans une bonne raison.

Supplement

Aller plus loin

Non evalues a l'examen mais essentiels au quotidien

3 questions bonus

docker run docker build docker inspect

Supplement 1 docker run (non evalue)

Lancer un container avec toutes les options

Vous voulez lancer un container bot-irc:2.0 qui :

tourne en arriere-plan
s'appelle monBot
expose le port 8080 du container vers 9000 de l'hote
monte ./config de l'hote dans /etc/bot du container
passe la variable NICK=Robotine
s'auto-supprime quand il s'arrete

Donnez la commande :

DOCKER(1) - extrait du manuel

NAME
       docker - Docker container management

COMMANDS PRINCIPALES

   Cycle de vie d'un container
       run       cree et lance un container depuis une image
       start     demarre un container arrete
       stop      arrete un container
       restart   redemarre
       rm        supprime un container

   Inspection
       ps        liste les containers (-a pour tous)
       logs      voir la sortie (-f pour suivre en temps reel)
       inspect   info detaillee (format JSON)
       exec      executer une commande dans un container actif

   Images
       build     construit une image depuis un Dockerfile
       images    liste les images
       rmi       supprime une image
       pull      telecharge depuis un registry

OPTIONS de docker run (les plus frequentes)
       -d, --detach          arriere-plan
       --name STRING       nom au container
       --rm                auto-supprime apres l'arret
       -p HOST:CONTAINER  publier un port
       -v HOST:CONTAINER  bind mount un volume
       -e KEY=VALUE       variable d'environnement
       -it                interactif + TTY (pour bash)
       --restart POLICY    no, on-failure, always, unless-stopped

OPTIONS de docker build
       -t NOM:TAG          tag pour l'image (peut etre repete)
       -f CHEMIN           Dockerfile alternatif
       --build-arg KEY=VAL passer une valeur a un ARG
       --no-cache          rebuild sans cache
       --target STAGE      arreter a un stage (multi-stage)

EXEMPLES
       # Lancer en arriere-plan avec port mapping
       docker run -d -p 8080:80 --name web nginx

       # Avec volume + variable d'environnement
       docker run -d --name bdd \
           -v /data/postgres:/var/lib/postgresql/data \
           -e POSTGRES_PASSWORD=secret \
           postgres:15

       # Interactif (shell pour deboguer)
       docker run -it ubuntu bash

       # Auto-supprime apres execution
       docker run --rm alpine echo "hello"

       # Construire une image
       docker build -t monapp:1.0 .

       # Avec un build-arg
       docker build --build-arg VERSION=2.0 -t monapp:2.0 .

docker run -d \
    --name monBot \
    --rm \
    -p 9000:8080 \
    -v "$(pwd)/config:/etc/bot" \
    -e NICK=Robotine \
    bot-irc:2.0

Decomposition :

-d = detached (arriere-plan, libere le terminal)
--name nom = nom convivial (sinon Docker en genere un aleatoire)
--rm = supprime auto le container apres son arret (pratique en dev)
-p externe:interne = mapping de ports
-v hote:container = bind mount. Chemin absolu cote hote obligatoire (d'ou $(pwd)/...)
-e VAR=val = variable d'environnement (repetable)

Sans --rm : le container reste en etat exited apres son arret. On peut le redemarrer avec docker start monBot, ou le supprimer avec docker rm.

Supplement 2 docker build avance (non evalue)

Compiler avec tag et build-arg

Le repertoire ./bot-irc/ contient un Dockerfile qui declare ARG VERSION dans son entete. Vous etes dans le repertoire parent. L'image doit s'appeler bot-irc avec le tag 2.0, et vous voulez passer VERSION=2.0 a l'ARG du Dockerfile au moment de la compilation.

Donnez la commande complete :

DOCKER-BUILD(1) - extrait du manuel

NAME
       docker build - construire une image depuis un Dockerfile

SYNOPSIS
       docker build [OPTIONS] CHEMIN | URL | -

OPTIONS
       -t, --tag NOM:TAG
              nomme l'image (peut etre repete pour plusieurs tags)

       --build-arg CLE=VALEUR
              passe une valeur a une directive ARG du Dockerfile.
              Repetable : --build-arg A=1 --build-arg B=2

       -f, --file CHEMIN
              Dockerfile alternatif (par defaut : ./Dockerfile)

       --no-cache
              recompile tout, sans utiliser le cache des layers

       --target STAGE
              s'arrete a un stage precis (multi-stage build)

DERNIER ARGUMENT
       build context : repertoire envoye au daemon Docker, qui doit
       contenir le Dockerfile (ou indique par -f).
       Conventionnellement . (repertoire courant) ou un chemin relatif.

EXEMPLES
       # Tag simple
       docker build -t monapp:1.0 .

       # Plusieurs tags
       docker build -t monapp:1.0 -t monapp:latest .

       # Passer un ARG
       docker build --build-arg VERSION=2.0 -t monapp:2.0 .

       # Plusieurs ARG
       docker build --build-arg A=x --build-arg B=y -t img .

docker build -t bot-irc:2.0 --build-arg VERSION=2.0 ./bot-irc

Decomposition :

-t nom:tag = nom et version (tag par defaut = latest si omis)
--build-arg CLE=VAL = valeur pour un ARG du Dockerfile (repetable pour plusieurs ARG)
./bot-irc = build context, dernier argument. Docker enverra le contenu de ce repertoire au daemon.

Tags multiples :

docker build -t bot-irc:2.0 -t bot-irc:latest ./bot-irc

Reflexe : mettre un .dockerignore dans le build context pour ne pas envoyer node_modules/, .git/, etc. au daemon.

Supplement 3 inspect (non evalue)

Inspecter un container actif

Le container jeu-prod tourne et vous voulez verifier sa configuration : son IP interne, sa consommation CPU/RAM, et quel processus il fait tourner. Sans l'arreter.

a) Voir toute la config de jeu-prod (sortie JSON complete) :

b) Extraire seulement l'IP interne avec --format :

c) Voir les stats CPU/RAM en temps reel de jeu-prod :

d) Voir les processus actifs dans jeu-prod (equivalent ps a l'interieur) :

DOCKER inspect / stats / top - extrait du manuel

NAME
       docker inspect - voir la config detaillee (JSON) d'un objet Docker
       docker stats   - stats CPU/RAM/reseau en TEMPS REEL
       docker top     - processus actifs DANS le container

INSPECT - sources d'info
       docker inspect [OPTIONS] CIBLE [CIBLE...]

       CIBLE = container, image, volume, network, ...

OPTIONS de docker inspect
       --format TEMPLATE
              extraire un champ avec un template Go.
              Exemples :
                '{{.Config.Env}}'          variables d'env
                '{{.Config.Cmd}}'          commande de demarrage
                '{{.State.Status}}'        running/exited/paused
                '{{.NetworkSettings.IPAddress}}'  IP interne
                '{{.Config.ExposedPorts}}' ports declares
                '{{.Mounts}}'             volumes / bind mounts

       --type container|image|volume|network
              forcer le type (par defaut Docker devine)

DOCKER STATS
       docker stats [OPTIONS] [CONTAINER...]

       --no-stream    une seule mesure puis quitte
       -a             inclut les containers arretes (qui restent a 0)
       --format TPL   template Go pour formater

DOCKER TOP
       docker top CONTAINER [ps OPTIONS]

       Affiche les processus actifs DANS le container, en utilisant
       le ps de l'hote (donc avec les vrais PID hote).

EXEMPLES
       # Toute la config (JSON brut, long)
       docker inspect jeu-prod

       # Un seul champ
       docker inspect --format '{{.NetworkSettings.IPAddress}}' jeu-prod
       docker inspect --format '{{.Config.Env}}' jeu-prod
       docker inspect --format '{{.State.Status}}' jeu-prod

       # Stats temps reel
       docker stats jeu-prod
       docker stats --no-stream jeu-prod    # une seule fois

       # Processus dans le container
       docker top jeu-prod

       # Explorer le JSON avec jq
       docker inspect jeu-prod | jq '.[0].NetworkSettings'

# a) Tout l'inspect (long, en JSON)
docker inspect jeu-prod

# b) Avec un filtre Go template (un seul champ)
docker inspect --format '{{.NetworkSettings.IPAddress}}' jeu-prod

# c) Stats CPU/RAM/reseau en temps reel
docker stats jeu-prod

# d) Processus actifs DANS le container
docker top jeu-prod

Les --format les plus utiles :

{{.Config.Env}} = variables d'environnement
{{.Config.Cmd}} = commande de demarrage
{{.State.Status}} = running, exited, paused...
{{.NetworkSettings.IPAddress}} = IP interne du container
{{.Config.ExposedPorts}} = ports declares
{{.Mounts}} = volumes / bind mounts

Astuce : docker inspect jeu-prod | jq '.[0].NetworkSettings' (si jq est installe) pour explorer le JSON plus confortablement.

Difference stats vs top :

docker stats = mesures de ressources (CPU%, MEM%, NET I/O)
docker top = liste des processus en cours (comme ps)

Bilan

Ce que vous venez de pratiquer

build -t --build-arg - construire avec tag et args
run -d --name -p -v -e --rm - toutes les options du lancement
ps -a --filter - lister actifs ou tous, filtrer
logs -f --tail --since - suivre ce que dit le container
exec -it ... bash/sh - entrer dedans
stop / rm / rmi - sequence de nettoyage
prune (4 niveaux) - faire le menage
inspect --format / stats - observer en detail

R pour recommencer.

« Retour aux mini-tests

CommandesDocker