Chaque conteneur est visible dans le réseau à partir de son nom défini avec `--name`.
Le réseau `bridge` par défaut de Docker isole les conteneurs entre-eux. Il est nécessaire de créer un autre réseau avec le driver `bridge` pour répéter l'expérience ci-dessus.
Un conteneur situé en dehors du réseau `testnetwork` ne peut pas pinguer `c1` et `c2` : [](https://formation.tfrichet.fr/uploads/images/gallery/2025-08/603P8qQmJkNyr3EA-image.png)Le nom d'hôte du conteneur est affiché. Il est hérité depuis la machine hôte.
### Gestion des réseaux Il est possible de connecter un conteneur à un réseau existant avec `docker network connect`. [](https://formation.tfrichet.fr/uploads/images/gallery/2025-08/3bocO0a2nHDec8fi-image.png) Le détail d'un réseau peut être affiché avec la commande `docker network inspect`. [](https://formation.tfrichet.fr/uploads/images/gallery/2025-08/hhAvIiVSiofoxdGS-image.png) Un réseau `bridge` embarque une configuration IP, de la même manière qu'un réseau local. Le réseau est défini par un `subnet` et il possède une IP `gateway` attribuée à la machine hôte. Dans l'exemple ci-dessus, le réseau `reseau2` possède le subnet `172.19.0.0` avec un masque de sous-réseau `255.255.0.0` (ou `/16`). L'adresse IP de la machine hôte est `172.19.0.1` et celle du conteneur `c5` est `172.19.0.2`. # Administration : commandes utilesLes commandes ci-dessous sont directement copiées depuis la documentation de docker : [ 🔗 https://docs.docker.com/reference/cli/docker/](https://docs.docker.com/reference/cli/docker/)
Les usages principaux des commandes ont déjà été abordés jusqu'ici. ### docker image| **Command** | **Description** |
|---|---|
| [`docker image history`](https://docs.docker.com/reference/cli/docker/image/history/) | Show the history of an image |
| [`docker image import`](https://docs.docker.com/reference/cli/docker/image/import/) | Import the contents from a tarball to create a filesystem image |
| [`docker image inspect`](https://docs.docker.com/reference/cli/docker/image/inspect/) | **Display detailed information on one or more images** |
| [`docker image load`](https://docs.docker.com/reference/cli/docker/image/load/) | Load an image from a tar archive or STDIN |
| [`docker image ls`](https://docs.docker.com/reference/cli/docker/image/ls/) | List images |
| [`docker image prune`](https://docs.docker.com/reference/cli/docker/image/prune/) | Remove unused images |
| [`docker image pull`](https://docs.docker.com/reference/cli/docker/image/pull/) | Download an image from a registry |
| [`docker image push`](https://docs.docker.com/reference/cli/docker/image/push/) | Upload an image to a registry |
| [`docker image rm`](https://docs.docker.com/reference/cli/docker/image/rm/) | Remove one or more images |
| [`docker image save`](https://docs.docker.com/reference/cli/docker/image/save/) | Save one or more images to a tar archive (streamed to STDOUT by default) |
| [`docker image tag`](https://docs.docker.com/reference/cli/docker/image/tag/) | Create a tag TARGET\_IMAGE that refers to SOURCE\_IMAGE |
| **Command** | **Description** |
|---|---|
| [`docker container attach`](https://docs.docker.com/reference/cli/docker/container/attach/) | Attach local standard input, output, and error streams to a running container |
| [`docker container commit`](https://docs.docker.com/reference/cli/docker/container/commit/) | Create a new image from a container's changes |
| [`docker container cp`](https://docs.docker.com/reference/cli/docker/container/cp/) | Copy files/folders between a container and the local filesystem |
| [`docker container create`](https://docs.docker.com/reference/cli/docker/container/create/) | Create a new container |
| [`docker container diff`](https://docs.docker.com/reference/cli/docker/container/diff/) | Inspect changes to files or directories on a container's filesystem |
| [`docker container exec`](https://docs.docker.com/reference/cli/docker/container/exec/) | Execute a command in a running container |
| [`docker container export`](https://docs.docker.com/reference/cli/docker/container/export/) | Export a container's filesystem as a tar archive |
| [`docker container inspect`](https://docs.docker.com/reference/cli/docker/container/inspect/) | Display detailed information on one or more containers |
| [`docker container kill`](https://docs.docker.com/reference/cli/docker/container/kill/) | Kill one or more running containers |
| [`docker container logs`](https://docs.docker.com/reference/cli/docker/container/logs/) | Fetch the logs of a container |
| [`docker container ls`](https://docs.docker.com/reference/cli/docker/container/ls/) | List containers |
| [`docker container pause`](https://docs.docker.com/reference/cli/docker/container/pause/) | Pause all processes within one or more containers |
| [`docker container port`](https://docs.docker.com/reference/cli/docker/container/port/) | List port mappings or a specific mapping for the container |
| [`docker container prune`](https://docs.docker.com/reference/cli/docker/container/prune/) | Remove all stopped containers |
| [`docker container rename`](https://docs.docker.com/reference/cli/docker/container/rename/) | Rename a container |
| [`docker container restart`](https://docs.docker.com/reference/cli/docker/container/restart/) | Restart one or more containers |
| [`docker container rm`](https://docs.docker.com/reference/cli/docker/container/rm/) | Remove one or more containers |
| [`docker container run`](https://docs.docker.com/reference/cli/docker/container/run/) | Create and run a new container from an image |
| [`docker container start`](https://docs.docker.com/reference/cli/docker/container/start/) | Start one or more stopped containers |
| [`docker container stats`](https://docs.docker.com/reference/cli/docker/container/stats/) | Display a live stream of container(s) resource usage statistics |
| [`docker container stop`](https://docs.docker.com/reference/cli/docker/container/stop/) | Stop one or more running containers |
| [`docker container top`](https://docs.docker.com/reference/cli/docker/container/top/) | Display the running processes of a container |
| [`docker container unpause`](https://docs.docker.com/reference/cli/docker/container/unpause/) | Unpause all processes within one or more containers |
| [`docker container update`](https://docs.docker.com/reference/cli/docker/container/update/) | Update configuration of one or more containers |
| [`docker container wait`](https://docs.docker.com/reference/cli/docker/container/wait/) | Block until one or more containers stop, then print their exit codes |
| **Command** | **Description** |
|---|---|
| [`docker volume create`](https://docs.docker.com/reference/cli/docker/volume/create/) | Create a volume |
| [`docker volume inspect`](https://docs.docker.com/reference/cli/docker/volume/inspect/) | **Display detailed information on one or more volumes** |
| [`docker volume ls`](https://docs.docker.com/reference/cli/docker/volume/ls/) | List volumes |
| [`docker volume prune`](https://docs.docker.com/reference/cli/docker/volume/prune/) | Remove unused local volumes |
| [`docker volume rm`](https://docs.docker.com/reference/cli/docker/volume/rm/) | Remove one or more volumes |
| [`docker volume update`](https://docs.docker.com/reference/cli/docker/volume/update/) | Update a volume (cluster volumes only) |
| **Command** | **Description** |
|---|---|
| [`docker network connect`](https://docs.docker.com/reference/cli/docker/network/connect/) | Connect a container to a network |
| [`docker network create`](https://docs.docker.com/reference/cli/docker/network/create/) | Create a network |
| [`docker network disconnect`](https://docs.docker.com/reference/cli/docker/network/disconnect/) | Disconnect a container from a network |
| [`docker network inspect`](https://docs.docker.com/reference/cli/docker/network/inspect/) | Display detailed information on one or more networks |
| [`docker network ls`](https://docs.docker.com/reference/cli/docker/network/ls/) | List networks |
| [`docker network prune`](https://docs.docker.com/reference/cli/docker/network/prune/) | Remove all unused networks |
| [`docker network rm`](https://docs.docker.com/reference/cli/docker/network/rm/) | Remove one or more networks |
| **Command** | **Description** |
|---|---|
| [`docker system df`](https://docs.docker.com/reference/cli/docker/system/df/) | Show docker disk usage |
| [`docker system events`](https://docs.docker.com/reference/cli/docker/system/events/) | Get real time events from the server |
| [`docker system info`](https://docs.docker.com/reference/cli/docker/system/info/) | Display system-wide information |
| [`docker system prune`](https://docs.docker.com/reference/cli/docker/system/prune/) | Remove unused data |
La procédure d'installation détaillée est disponible sur [ 🔗 docs.portainer.io](https://docs.portainer.io/start/install-ce/server/docker/linux).
L'installation de Portainer s'effectue simplement avec une image docker : ```bash docker volume create portainer_data docker run -d -p 8000:8000 -p 9443:9443 --name portainer --restart=always \ -v /var/run/docker.sock:/var/run/docker.sock -v portainer_data:/data portainer/portainer-ce:lts ``` Portainer est accessible à l'adresse : [ 🔗 ](https://127.0.0.1:9443/)[https://127.0.0.1:9443/](https://127.0.0.1:9443/).Remplacez 127.0.0.1 par l'IP de votre hôte docker si nécessaire.
La création d'un utilisateur est obligatoire avant la première connexion. [](https://formation.tfrichet.fr/uploads/images/gallery/2025-08/n9LmUAM0yloJKFBp-image.png) Il faut ensuite sélectionner l'environnement local. [](https://formation.tfrichet.fr/uploads/images/gallery/2025-08/MmBghWudeqj5RZJQ-image.png) L'administration des containers, images, volumes, network est disponible. [](https://formation.tfrichet.fr/uploads/images/gallery/2025-08/EIuhypLARw2EWfwL-image.png) # Construction d'image avec Dockerfile ### Dockerfile et layers Les images Docker fonctionnent par couches successives d'instructions, **les layers**. Un **Dockerfile** est un fichier texte qui décrit les différentes couches d'une image Docker. Chaque couche permet d'ajouter des actions à l'image, par exemple : - Installation de dépendances - Configuration d'un environnement - Copie de fichiers depuis la machine hôte - Définition de la commande lancée au démarrage du conteneur - Etc.Le dockerfile est comparable à une recette de cuisine : chaque instruction du Dockerfile représente une étape dans la préparation de l’environnement logiciel souhaité.
Son utilisation offre certains avantages : - **Automatisation** : chaque build est reproductible et scripté. - **Traçabilité** : le fichier peut être versionné avec Git. - **Portabilité** : un Dockerfile peut être utilisé sur n'importe quelle machine. - **Modularité** : il permet de construire des images à partir d’autres images, facilitant la réutilisation. Ci-dessous un exemple de Dockerfile : ```bash FROM debian:trixie # point de départ : une image existante RUN apt-get update -y # commande à éxécuter RUN apt-get install fastfetch -y # une autre commande, pour une nouvelle couche ENTRYPOINT ["fastfetch"] # point d'entrée au lancement du conteneur ``` ### Les instructions d'un DockerfileN'hésitez pas à consulter la documentation de Docker à ce sujet : [🔗 Dockerfile reference](https://docs.docker.com/reference/dockerfile/).
#### `FROM` - Définir l'image de base ```bash FROM ubuntu:24.04 ``` C'est le point de départ de l'image : une autre image de base officielle ou personnalisée. #### `LABEL` - Ajouter des métadonnées ```bash LABEL Maintainer="Thibaud FRICHET" LABEL Description="Description de l'image" ``` Les métadonnées de l'image s'affichent avec `docker image inspect`. #### `WORKDIR` - Définir le répertoire de travail ```bash WORKDIR /var/www/html ``` Les instructions `RUN`, `CMD` et `ENTRYPOINT` s’exécutent dans le répertoire de travail. #### `COPY` - Copier des fichiers locaux dans l'image ```bash # copie fichier.txt à partir du répertoire courant de la machine hôte # dans le répertoire courant de l'image (défini avec WORKDIR) COPY fichier.txt ./ # copie le répertoire sources depuis la machine hôte vers le répertoire /var/www de l'image COPY /home/thibaud/projet/sources/ /var/www/ ``` #### `RUN` - Exécuter des commandes pendant la construction ```bash # installation et lancement de Redis RUN apt-get update -y RUN apt-get install redis-server -y RUN service redis-server start ``` Les commandes `RUN` s’exécutent pendant la construction de l'image, pas au démarrage d'un conteneur.Les commandes doivent se terminer sans saisie utilisateur.
##### `EXPOSE` - Indiquer les ports utilisés par l'application ```bash EXPOSE 80 EXPOSE 443 ``` Ce sont les ports d'écoute du conteneur, ils peuvent être redirigés avec `docker run -p 90:80` à l'exécution. ##### `CMD` - Définir les commandes par défaut à exécuter L'instruction CMD accepte un tableau en paramètre. ```bash CMD ["date", "echo Bonjour"] # affiche la date courante, puis "Bonjour" ``` Contrairement à `RUN`, l'instruction `CMD` est exécutée au démarrage du conteneur, pas pendant la construction. ##### `ENTRYPOINT` - Définir le point d'entrée du conteneur ```bash ENTRYPOINT ["service nginx start"] # lance le serveur web nginx ``` `CMD` et `ENTRYPOINT` définissent les commandes exécutées au démarrage d'un conteneur, mais avec un comportement différent : - `CMD` indique la commande avec des arguments par défaut qui peuvent être remplacés lors de l’exécution avec docker run. - `ENTRYPOINT` fixe le point d’entrée du conteneur, rendant son comportement plus rigide. Lorsqu’ils sont utilisés ensemble, `ENTRYPOINT` définit le programme à exécuter et `CMD` les arguments par défaut.Dans la majorité des cas, vous pouvez utiliser l'un ou l'autre uniquement.
### Bonnes pratiques - Utilisez des images légères. Exemples : `python:3.10-slim`, `nginx-stable-alpine`, etc. - Utilisez des versions fixes dans vos dépendances. Évitez les tags `-latest` par exemple. - Minimisez le nombre de couches, par exemple avec plusieurs commandes sur une ligne `RUN` et `&&`. ``` RUN apt-get update -y && apt-get install redis-server ``` - Utilisez `.dockerignore` pour exclure les fichiers inutiles, de la même manière qu'un `.gitignore`. Le contenu du répertoire courant de la machine hôte est envoyé à Docker lors de la construction d'une image. Docker appelle cela le `context`. - Respectez la convention de nommage d'un dockerfile : - Par défaut : `Dockerfile` - Avec un préfixe : `dev.Dockerfile`, `prod.Dockerfile`, `app-v3.Dockerfile` ### La construction de l'image La construction d'une image docker s'effectue avec `docker build`. Le paramètre `-t`, `--tag` indique le nom de l'image et sa version. Le paramètre `-f`, `--file` le nom du fichier dockerfile, par défaut `Dockerfile`. Un répertoire de contexte doit être indiqué, par exemple le répertoire courant avec `.`. ```bash docker build -t mon_appli:1.0.0 -f monappli.Dockerfile . ``` [](https://formation.tfrichet.fr/uploads/images/gallery/2025-09/tZrv72npXnLC5DX7-image.png) [](https://formation.tfrichet.fr/uploads/images/gallery/2025-09/AJw5mu7IRM7XQskp-image.png)Par la suite, une image Docker peut être exportée dans un fichier ou uploadée sur un registre privé par exemple.
# TP : Création d'une image Docker ### Objectif L'objectif est de **construire une image** qui embarque un script Python accessible en web.Aucune connaissance de Python n'est requise.
### Consignes #### 1 - Téléchargement de l'application Téléchargez le fichier zip suivant et dézippez-le. **[🔗 https://formation-tfrichet-assets.s3.fr-par.scw.cloud/docker-tp-2/docker-tp-2.zip](https://formation-tfrichet-assets.s3.fr-par.scw.cloud/docker-tp-2/docker-tp-2.zip)** Vous obtenez un dossier `app`. [](https://formation.tfrichet.fr/uploads/images/gallery/2025-09/OifzVjWzhc98uEVw-image.png) #### 2 - Création du Dockerfile **Créez et buildez** un Dockerfile en respectant les consignes ci-dessous. - L'image de départ est `python:3.10-slim`. - Le répertoire de travail est `/app`. - Pendant la construction de l'image, les commandes doivent être exécutées : ```bash apt-get update && apt-get install -y procps pip install flask ``` - L'application (dossier `app` téléchargé) doit être copiée dans le répertoire de travail de l'image. - L'image écoute sur le port `5000`. - Les commandes suivantes sont exécutées au démarrage d'un conteneur : `python` et `app.py`. - Nommez l'image `tp2`. #### 3 - Exécution d'un conteneur Exécutez un conteneur avec la commande ci-dessous. N'oubliez pas de renseigner votre nom. ```bash docker run -ti --rm -p 5000:5000 -e NAME=VOTRE_NOM_ICI tp2 ``` Rendez-vous sur [http://127.0.0.1:5000](http://127.0.0.1:5000). ### Résultat attenduLe contenu du Dockerfile et la capture d'écran ci-dessous sont attendus pour valider le TP.
[](https://formation.tfrichet.fr/uploads/images/gallery/2025-09/OAQ8Oy4wG8RUSpSK-image.png)