Aller au contenu
NextiaNextia Learning
English

Installer et vérifier

  • Leçon 3
  • 50 min
  • Module 1 : Comprendre les conteneurs
Leçon 3 sur 15 · L'essentiel de Docker et du nuage pour les développeurs en IAInstaller et vérifier
Aperçu du cours

1. Comprendre les conteneurs

  1. Cohérence des environnements
  2. Images et conteneurs en cours d'exécution
  3. Installer et vérifier

2. Construire l'image de l'application

  1. L'essentiel du Dockerfile
  2. Construire efficacement
  3. Sécurité à l'exécution

3. Réseau, configuration et persistance

  1. Ports et accès au service
  2. Configuration à l'exécution
  3. Données persistantes

4. Les services de base du nuage

  1. Régions et types de services
  2. Identité et secrets
  3. Connaître les coûts

5. Déployer et nettoyer

  1. Registre et déploiement
  2. Configuration opérationnelle
  3. Vérifier et supprimer

Ce que vous saurez faire

Avant de construire quoi que ce soit avec Docker, assurez-vous que votre installation fonctionne. Vous installez Docker, le vérifiez avec un premier conteneur connu, puis exécutez un serveur Web dans un conteneur. Ensuite, vous supprimez tout. Vous savez ainsi comment revenir à un état propre.

Avant de commencerCe qu’il faut savoir et avoir sous la mainEnviron 50 minutes

Ce que vous devez savoir

Ce qu’il vous faut sur votre ordinateur

  • Un ordinateur où vous pouvez installer des programmes : droits d’administration sur macOS, compte Windows pouvant autoriser une installation, ou sudo sur Linux.
  • Au moins 4 Go de mémoire sur un Mac, ou 8 Go sur Windows (les minimums de Docker). Environ 2 Go d’espace disque libre pour Docker et les images de ce module.
  • Une connexion Internet. Les images de ce module proviennent de Docker Hub.
  • Un navigateur Web et curl (Windows : curl.exe dans PowerShell, comme dans le cours sur les API).

Testé avec Docker Desktop 4.81.0 (Docker Engine 29.6.1) sur macOS, avec une puce Apple. Les étapes Windows et Linux ne sont pas testées : elles suivent les pages d’installation de Docker.

Docker Desktop ou Docker Engine

Section intitulée « Docker Desktop ou Docker Engine »

Docker existe sous deux formes :

  • Docker Engine est le programme qui exécute les conteneurs, avec la commande docker. Il fonctionne sur Linux. Il est gratuit et à code source ouvert.
  • Docker Desktop est une application pour macOS, Windows et Linux. Elle contient Docker Engine dans une petite machine virtuelle Linux, avec une fenêtre pour le gérer. Sur macOS et Windows, vous en avez besoin, car les conteneurs ont besoin d’un noyau Linux.

Cette leçon installe Docker Desktop sur macOS et Windows, et Docker Engine sur Linux (Ubuntu).

La licence de Docker Desktop. Docker Desktop est gratuit pour l’usage personnel, l’enseignement, les projets à code source ouvert non commerciaux et les petites entreprises. Une petite entreprise compte moins de 250 employés et un chiffre d’affaires annuel inférieur à 10 millions de dollars US. Les grandes entreprises doivent payer un abonnement. Si vous utilisez un ordinateur de travail, demandez à votre entreprise quelle licence s’applique. Docker Engine sur Linux est gratuit pour tout le monde. (Source : Contrat de licence de Docker Desktop.)

D’autres outils peuvent aussi exécuter les mêmes images, par exemple Podman Desktop, Rancher Desktop et Colima. Ce cours teste seulement Docker.

L’architecture du processeur de votre ordinateur

Section intitulée « L’architecture du processeur de votre ordinateur »

Une image est construite pour une architecture de processeur : le type de processeur qui peut exécuter ses programmes. Deux architectures sont courantes :

Architecture Nom Linux Ordinateurs
linux/arm64 aarch64 Mac avec une puce Apple, beaucoup de nouveaux portables Windows, certains serveurs infonuagiques
linux/amd64 x86_64 La plupart des PC Windows et Linux (processeurs Intel et AMD), la plupart des serveurs infonuagiques

Trouvez la vôtre :

Fenêtre de terminal
uname -m

arm64 signifie une puce Apple. x86_64 signifie Intel.

Sur le Mac d’Amira, uname -m affiche arm64.

La plupart des images officielles sont multiplateformes : un seul nom et une seule étiquette, avec une variante pour chaque architecture. Docker télécharge la variante adaptée à votre ordinateur. Cette commande liste les variantes (résultat abrégé) :

Terminal
docker buildx imagetools inspect python:3.14.8-slim-trixie
Sortie (abrégée)
Name:      docker.io/library/python:3.14.8-slim-trixie
MediaType: application/vnd.oci.image.index.v1+json
Digest:    sha256:f85c5697265c178cc6887276c55fe16cf3d14ca35c3df6a5eab3b360534a55d2
...
  Platform:    linux/amd64
...
  Platform:    linux/arm/v5
  Platform:    linux/arm/v7
  Platform:    linux/arm64/v8
  Platform:    linux/386
  Platform:    linux/ppc64le
  Platform:    linux/riscv64
  Platform:    linux/s390x

(La sortie contient aussi des entrées avec Platform: unknown/unknown. Elles décrivent la construction de l’image et ne contiennent pas de programmes.)

Docker Desktop peut aussi exécuter l’autre architecture, lentement, grâce à l’émulation : un logiciel qui imite l’autre processeur. --platform choisit la variante :

Terminal
docker run --rm --platform linux/amd64 python:3.14.8-slim-trixie python -c "import platform; print(platform.machine())"
Sortie
x86_64

L’architecture compte à nouveau au module 5. Azure Container Apps exécute seulement des images linux/amd64. Sur un Mac avec une puce Apple, vous construisez donc l’image de l’API pour linux/amd64.

Installer Docker

Section intitulée « Installer Docker »

Choisissez votre système. Suivez un seul onglet.

Docker Desktop prend en charge la version actuelle de macOS et les deux versions précédentes.

  1. Trouvez votre processeur avec uname -m, comme dans la section précédente.
  2. Ouvrez Installer Docker Desktop sur Mac et téléchargez l’installateur pour votre processeur : Apple silicon (puce Apple) ou Intel chip (puce Intel).
  3. Ouvrez le fichier Docker.dmg téléchargé.
  4. Glissez l’icône Docker dans le dossier Applications.
  5. Ouvrez Docker depuis le dossier Applications.
  6. Lisez le contrat Docker Subscription Service Agreement. Acceptez-le si les conditions dans Docker Desktop ou Docker Engine permettent votre utilisation.
  7. Attendez que Docker Desktop indique que le moteur fonctionne. Vous n’avez pas besoin de vous connecter à Docker Hub pour ce cours. Si Docker Desktop le demande, ignorez la connexion.

Docker Desktop doit fonctionner quand vous utilisez la commande docker. Après un redémarrage du Mac, ouvrez-le à nouveau ou activez son démarrage à la connexion.

Vérifier l’installation

Section intitulée « Vérifier l’installation »

Effectuez trois vérifications, dans cet ordre. Chacune teste une partie de plus.

1. La commande docker peut joindre le moteur.

Terminal
docker version

La sortie (abrégée) :

Client:
 Version:           29.6.1
 API version:       1.55
 OS/Arch:           darwin/arm64
 Context:           desktop-linux


Server: Docker Desktop 4.81.0 (232925)
 Engine:
  Version:          29.6.1
  API version:      1.55 (minimum version 1.40)
  OS/Arch:          linux/arm64
...

Il y a deux parties. Client est la commande docker sur votre ordinateur (darwin/arm64 : macOS sur une puce Apple). Server (serveur) est le moteur. Son OS/Arch (système et architecture) est linux/arm64, car il fonctionne dans la machine virtuelle Linux de Docker Desktop. Si la partie Server manque, consultez l’encadré après la troisième vérification.

2. Le moteur utilise le système et l’architecture attendus.

Terminal
docker info --format '{{.OperatingSystem}} {{.Architecture}}'
Sortie
Docker Desktop aarch64

Sur Windows, les premiers mots sont aussi Docker Desktop. Sur Linux, vous voyez plutôt le nom de votre système Linux.

3. Le moteur peut télécharger une image depuis un registre et exécuter un conteneur.

Terminal
docker run hello-world

La sortie, sur un ordinateur qui n’a pas encore l’image :

Unable to find image 'hello-world:latest' locally
latest: Pulling from library/hello-world
58dee6a49ef1: Pulling fs layer
58dee6a49ef1: Download complete
c3bdf82c34d1: Download complete
58dee6a49ef1: Pull complete
Digest: sha256:5e23090353324d887c48ad5e5c56d294eab81588df9605b07d1afe895f9cc8f8
Status: Downloaded newer image for hello-world:latest


Hello from Docker!
This message shows that your installation appears to be working correctly.


To generate this message, Docker took the following steps:
 1. The Docker client contacted the Docker daemon.
 2. The Docker daemon pulled the "hello-world" image from the Docker Hub.
    (arm64v8)
 3. The Docker daemon created a new container from that image which runs the
    executable that produces the output you are currently reading.
 4. The Docker daemon streamed that output to the Docker client, which sent it
    to your terminal.
...

Le message lui-même liste ce qui a fonctionné. Le démon est le moteur : un programme qui fonctionne en arrière-plan. hello-world:latest : vous n’avez pas fourni d’étiquette, alors Docker a utilisé l’étiquette latest. (arm64v8) est l’architecture de la variante téléchargée. Sur un ordinateur Intel ou AMD, c’est amd64. L’image hello-world fait 22,6 ko, donc cette vérification est rapide.

Exemple détaillé : un serveur Web dans un conteneur

Section intitulée « Exemple détaillé : un serveur Web dans un conteneur »

Voici maintenant un conteneur que vous pouvez joindre depuis le navigateur. nginx est un serveur Web. Amira exécute l’image officielle nginx avec une version fixe, 1.30.5, la version stable lors de la rédaction du cours :

Terminal
docker run -d --name c18m01-web -p 127.0.0.1:8080:80 nginx:1.30.5
Partie Signification
-d Exécuter en arrière-plan.
--name c18m01-web Le nom du conteneur.
-p 127.0.0.1:8080:80 Publier un port. Un port est un numéro qui détermine quel programme sur un ordinateur reçoit une connexion (comme dans le cours sur les API). Les connexions au port 8080 de cet ordinateur vont au port 80 du conteneur, où nginx écoute. 127.0.0.1 signifie que seul cet ordinateur peut se connecter. Le module 3 explique chaque partie.
nginx:1.30.5 L’image et une version exacte.

La sortie :

Unable to find image 'nginx:1.30.5' locally
1.30.5: Pulling from library/nginx
a36cd258528a: Pulling fs layer
...
Digest: sha256:9bf97bd7714f5e24c1ccd545ecb9eb5435cb6d109c97cebb15e7e455e0239edb
Status: Downloaded newer image for nginx:1.30.5
de15a5783a027b866ca221ac078b172bb11af74007f11fe8f6f459d2e4b06c3b

docker ps affiche le port publié dans la colonne PORTS (ports) :

Terminal
docker ps --filter name=c18m01-web
Sortie
CONTAINER ID   IMAGE          COMMAND                  CREATED                  STATUS                  PORTS                    NAMES
de15a5783a02   nginx:1.30.5   "/docker-entrypoint.…"   Less than a second ago   Up Less than a second   127.0.0.1:8080->80/tcp   c18m01-web

Ouvrez http://127.0.0.1:8080 dans le navigateur. La page porte le titre Welcome to nginx! (bienvenue dans nginx!) et contient quelques lignes de texte. Depuis le terminal, curl affiche le début de la même page :

Fenêtre de terminal
curl -s http://127.0.0.1:8080 | head -4
Sortie
<!DOCTYPE html>
<html>
<head>
<title>Welcome to nginx!</title>

nginx écrit une ligne de journal pour chaque requête. docker logs les affiche (les dernières lignes) :

Terminal
docker logs c18m01-web
Sortie (dernières lignes)
...
2026/10/07 16:52:59 [notice] 1#1: start worker process 37
2026/10/07 16:52:59 [notice] 1#1: start worker process 38
172.17.0.1 - - [07/Oct/2026:16:52:59 +0000] "GET / HTTP/1.1" 200 896 "-" "curl/8.7.1" "-"

La requête venait d’une adresse comme 172.17.0.1, et non de 127.0.0.1. Docker a transmis la connexion au conteneur par son propre petit réseau. Cette adresse représente le côté Docker de ce réseau. Le module 3 l’explique.

Ensuite, Amira regarde à l’intérieur du conteneur. Elle demande sa version à nginx et modifie la page d’accueil dans le conteneur :

Terminal
docker exec c18m01-web nginx -v
docker exec c18m01-web sh -c 'echo "<h1>Changed in the container</h1>" > /usr/share/nginx/html/index.html'
curl -s http://127.0.0.1:8080
Sortie
nginx version: nginx/1.30.5
<h1>Changed in the container</h1>

docker diff c18m01-web liste la page modifiée, C /usr/share/nginx/html/index.html. Il liste aussi les fichiers créés par nginx au démarrage, comme A /run/nginx.pid. docker inspect affiche l’état et la configuration du conteneur :

Terminal
docker inspect c18m01-web --format '{{.State.Status}} {{.Config.Image}} {{json .NetworkSettings.Ports}}'
Sortie
running nginx:1.30.5 {"80/tcp":[{"HostIp":"127.0.0.1","HostPort":"8080"}]}

Prédisez : Amira supprime le conteneur et en lance un nouveau avec la même commande. Quelle page le navigateur affiche-t-il?

Terminal
docker stop c18m01-web
docker rm c18m01-web
docker run -d --name c18m01-web -p 127.0.0.1:8080:80 nginx:1.30.5
curl -s http://127.0.0.1:8080 | grep title
Sortie
c18m01-web
c18m01-web
862f869879fcebb37848ce3029080ce6c73f35cfa4ef893db53f85426a2ba799
<title>Welcome to nginx!</title>

La page d’origine est revenue. La page modifiée était dans la couche accessible en écriture de l’ancien conteneur. nginx s’est arrêté immédiatement (0,3 s ici), car il réagit à la demande d’arrêt. À la fin, elle supprime le conteneur :

Terminal
docker rm -f c18m01-web

Réinitialiser : revenir à un état propre

Section intitulée « Réinitialiser : revenir à un état propre »

Vous pouvez toujours revenir à l’état d’avant ce module. Effectuez ces étapes à la fin du module, ou quand quelque chose n’est pas clair :

  1. Listez tous vos conteneurs, même ceux qui sont arrêtés : docker ps -a. Cherchez les noms qui commencent par c18m01- et le conteneur hello-world. Un conteneur lancé sans --name a un nom aléatoire, comme laughing_pare.
  2. Supprimez chaque conteneur que vous avez créé, par son nom : docker rm -f c18m01-web. Pour le conteneur hello-world, utilisez son nom aléatoire : docker rm laughing_pare.
  3. Supprimez les images dont vous n’avez plus besoin : docker image rm nginx:1.30.5 hello-world. Gardez python:3.14.8-slim-trixie : le module 2 l’utilise.
  4. Vérifiez l’espace utilisé par Docker : docker system df.

Sur un ordinateur de test où il ne restait que l’image Python, docker system df a affiché :

Sortie
TYPE            TOTAL     ACTIVE    SIZE      RECLAIMABLE
Images          1         0         205.8MB   205.8MB (99%)
Containers      0         0         0B        0B
Local Volumes   0         0         0B        0B
Build Cache     0         0         0B        0B

Vos chiffres sont plus élevés si vous avez d’autres images. Supprimez seulement les images et les conteneurs que vous connaissez. N’utilisez pas docker system prune : cette commande supprime aussi des éléments d’autres projets.

Erreur courante

Le port est déjà attribué

Symptôme : Amira lance un deuxième conteneur Web sur le même port. docker run échoue :

Terminal
docker run -d --name c18m01-web2 -p 127.0.0.1:8080:80 nginx:1.30.5
Sortie
ec0cb79f15b8a3b44612760dfb5ef515368fef837982ed3ff449e113a6e496b0
docker: Error response from daemon: failed to set up container networking: driver failed programming external connectivity on endpoint c18m01-web2 (28a55085448d341d9cc02dcf57bb2836ec659d84d0e1b8db9b43e377685a49f3): Bind for 127.0.0.1:8080 failed: port is already allocated


Run 'docker run --help' for more information

Le code de sortie est 125 : Docker lui-même a échoué, pas le programme dans le conteneur. Ensuite, docker ps -a affiche le nouveau conteneur avec l’état Created (créé) : il existe, mais n’a jamais démarré.

Cause : un seul programme peut utiliser un port sur une adresse. c18m01-web utilise déjà 127.0.0.1:8080. Le port du conteneur, 80, n’est pas le problème : chaque conteneur a son propre port 80.

Solution :

  1. Trouvez ce qui utilise le port : docker ps affiche 127.0.0.1:8080->80/tcp dans la colonne PORTS de c18m01-web. Si aucun conteneur ne l’utilise, un autre programme sur votre ordinateur l’utilise.
  2. Supprimez le conteneur qui a seulement été créé : docker rm c18m01-web2.
  3. Arrêtez le premier conteneur, ou utilisez un autre port de l’hôte : docker run -d --name c18m01-web2 -p 127.0.0.1:8081:80 nginx:1.30.5.
  4. Supprimez les deux conteneurs quand vous avez terminé : docker rm -f c18m01-web c18m01-web2.

Pour un vrai service d’IA : deux copies d’un service sur un ordinateur ont besoin de deux ports de l’hôte. Elles peuvent toutefois utiliser le même port de conteneur. Dans le nuage, la plateforme choisit le côté hôte pour vous (module 5).

Vérifiez votre compréhension

docker version affiche une partie Client, mais aucune partie Server. Qu'est-ce que cela vous indique, et que faites-vous?

Afficher la réponse

La commande docker est installée, mais elle ne peut pas joindre le moteur. Le client et le moteur sont deux programmes, et seul le client a répondu. Sur macOS et Windows, lancez Docker Desktop et attendez que le moteur fonctionne. Sur Linux, lancez le service avec sudo systemctl start docker. Vérifiez que vous utilisez sudo ou que vous êtes dans le groupe docker. Puis exécutez à nouveau docker version : les deux parties doivent apparaître.

Vérifiez votre compréhension

Le Mac d'Amira est arm64. Un serveur infonuagique est amd64. Pourquoi docker run python:3.14.8-slim-trixie fonctionne-t-il sur les deux? Que doit-elle retenir pour sa propre image plus tard?

Afficher la réponse

L’image Python est multiplateforme : un nom et une étiquette, avec une variante pour linux/arm64, une pour linux/amd64 et d’autres. Chaque ordinateur télécharge la variante adaptée à son processeur. Une image qu’elle construit sur son Mac est, par défaut, seulement pour linux/arm64. Un serveur qui exige linux/amd64, comme Azure Container Apps, ne peut pas l’exécuter. Au module 5, elle la construit donc pour linux/amd64.

Exercices du module

Section intitulée « Exercices du module »

Avec accompagnement : l’exemple détaillé ci-dessus est la partie guidée. Vous avez exécuté nginx, publié son port, lu sa page et ses journaux. Vous avez examiné son contenu avec exec, diff et inspect, puis remplacé le conteneur. Refaites ces étapes vous-même si vous les avez seulement lues.

Votre tâche : exécutez et inspectez votre propre petit conteneur, puis arrêtez-le et supprimez-le. Utilisez l’image Python comme petit serveur Web qui affiche les fichiers d’un dossier :

  1. Lancez python -m http.server 8000 dans un conteneur nommé c18m01-files, en arrière-plan. Publiez le port 8000 du conteneur sur 127.0.0.1:8081.
  2. Ouvrez http://127.0.0.1:8081 dans le navigateur et trouvez la requête dans les journaux du conteneur.
  3. Créez un fichier /practice.txt dans le conteneur. Récupérez-le avec le navigateur ou curl à l’adresse http://127.0.0.1:8081/practice.txt.
  4. Affichez les fichiers modifiés dans le conteneur, son processus principal, puis son image et sa commande avec docker inspect.
  5. Arrêtez le conteneur et examinez son état.
  6. Supprimez-le et vérifiez qu’il n’existe plus.
Afficher un exemple de réponse
Terminal
docker run -d --name c18m01-files -p 127.0.0.1:8081:8000 python:3.14.8-slim-trixie python -m http.server 8000
curl -s http://127.0.0.1:8081/ | grep title
docker logs c18m01-files
Sortie
8d637cfef539aca7ea7eda064f85ce136529f1cfe31e632d9e5ab4d3024fe0ba
<title>Directory listing for /</title>
172.17.0.1 - - [07/Oct/2026 17:01:06] "GET / HTTP/1.1" 200 -

La page affiche les dossiers du système de fichiers du conteneur (bin/, etc/, tmp/ et d’autres). Le serveur a démarré dans /.

Terminal
docker exec c18m01-files sh -c 'echo "practice" > /practice.txt'
curl -s http://127.0.0.1:8081/practice.txt
docker diff c18m01-files
docker top c18m01-files
docker inspect c18m01-files --format 'Image={{.Config.Image}} Cmd={{.Config.Cmd}} Status={{.State.Status}}'
Output (docker diff shortened)
practice
C /usr
C /usr/local
C /usr/local/lib
C /usr/local/lib/python3.14
...
A /usr/local/lib/python3.14/http/__pycache__/server.cpython-314.pyc
...
A /practice.txt
UID                 PID                 PPID                C                   STIME               TTY                 TIME                CMD
root                17450               17427               15                  17:01               ?                   00:00:00            python -m http.server 8000
Image=python:3.14.8-slim-trixie Cmd=[python -m http.server 8000] Status=running

docker diff affiche /practice.txt, ainsi que de nombreux fichiers __pycache__. Python a enregistré des copies compilées des modules importés dans la couche accessible en écriture. Le module 2 désactive ce comportement pour l’API de billets de soutien avec PYTHONDONTWRITEBYTECODE=1.

Terminal
docker stop c18m01-files
docker ps -a --filter name=c18m01-files
docker rm c18m01-files
docker ps -a --filter name=c18m01-files
Sortie
c18m01-files
CONTAINER ID   IMAGE                       COMMAND                  CREATED          STATUS                      PORTS     NAMES
8d637cfef539   python:3.14.8-slim-trixie   "python -m http.serv…"   14 seconds ago   Exited (137) 1 second ago             c18m01-files
c18m01-files
CONTAINER ID   IMAGE     COMMAND   CREATED   STATUS    PORTS     NAMES

docker stop a pris environ 11 secondes et s’est terminé avec Exited (137) (terminé avec le code 137). Comme sleep, ce serveur Python ne réagit pas à la demande d’arrêt. Docker a donc forcé son arrêt après 10 secondes. La dernière liste est vide : le conteneur a disparu, avec sa couche accessible en écriture et /practice.txt. L’image est toujours là.

Vérification des connaissances du module

Section intitulée « Vérification des connaissances du module »

Vérifiez votre compréhension

Rappel : quelle commande affiche aussi les conteneurs arrêtés, et quelle commande supprime un conteneur arrêté?

Afficher la réponse

docker ps -a affiche tous les conteneurs, même ceux qui sont arrêtés (docker ps affiche seulement ceux en cours d’exécution). docker rm <name> supprime un conteneur arrêté. Pour un conteneur en cours d’exécution, utilisez docker rm -f <name>, ou d’abord docker stop.

Vérifiez votre compréhension

Prédiction : Sam modifie la page d'accueil de nginx avec docker exec dans c18m01-web. Sam exécute ensuite docker stop c18m01-web et docker start c18m01-web. Quelle page le navigateur affiche-t-il? Et après docker rm -f et un nouveau docker run?

Afficher la réponse

Après stop et start : la page modifiée. Le conteneur existe toujours. Sa couche accessible en écriture, avec le fichier index.html modifié, est donc toujours là. Après docker rm -f et un nouveau docker run : Welcome to nginx! (Bienvenue dans nginx!) de nouveau. docker rm a supprimé l’ancienne couche accessible en écriture. Le nouveau conteneur voit seulement les couches en lecture seule de l’image, qui n’ont jamais changé.

Vérifiez votre compréhension

Vérification des acquis : expliquez quel état appartient à l'image et quel état appartient au conteneur en cours d'exécution. Utilisez les exercices du module comme exemple.

Afficher la réponse

L’image contient tout ce qui est identique pour chaque conteneur. Ce sont les couches en lecture seule avec les fichiers : Debian 13, Python 3.14.8 et sa bibliothèque standard. Elle contient aussi les métadonnées : la commande de démarrage python3 et les valeurs ENV. Elle ne change pas lorsqu’un conteneur s’exécute. docker history et docker image inspect l’affichent.

Le conteneur contient ce qui appartient à une seule copie en cours d’exécution :

  • son processus, python -m http.server 8000 (docker top);
  • sa couche accessible en écriture avec chaque modification : /practice.txt et les fichiers __pycache__ (docker diff);
  • son nom, son adresse réseau et son port publié, 127.0.0.1:8081;
  • ses journaux (docker logs) et son état : running (en cours d’exécution), puis Exited (137).

Vous choisissez la commande et le port avec docker run, et docker inspect les affiche. Tout cela disparaît avec docker rm. Les données à conserver ne peuvent donc pas rester dans la couche accessible en écriture d’un conteneur. Le module 3 montre où les placer.

Récapitulatif

Dans ce module, vous avez :

  • vu pourquoi un projet fonctionne sur un ordinateur et échoue sur un autre. L’environnement comprend plus que les paquets, et un fichier de verrouillage fixe seulement les paquets;
  • appris qu’une image combine des couches en lecture seule et des métadonnées. Un conteneur est un processus avec une couche accessible en écriture, sur un noyau Linux partagé. Une machine virtuelle possède son propre noyau;
  • installé Docker, vérifié son fonctionnement avec docker version, docker info et hello-world, et trouvé l’architecture de votre processeur;
  • exécuté, inspecté, modifié, arrêté et supprimé des conteneurs, et prouvé que docker rm supprime la couche accessible en écriture.

Procédure de remise à zéro : affichez vos conteneurs avec docker ps -a. Supprimez chaque conteneur c18m01- et le conteneur hello-world avec docker rm -f <name>. Supprimez nginx:1.30.5 et hello-world avec docker image rm. Conservez python:3.14.8-slim-trixie. Vérifiez avec docker system df. Le projet ticket-api n’a pas changé dans ce module.

Ensuite, vous écrirez un Dockerfile pour l’API de billets et construirez sa première image.

Leçon suivante : L'essentiel du Dockerfile