Maîtriser Docker 🐳 : conteneurs, images et bonnes pratiques

Docker est devenu un outil incontournable pour simplifier le déploiement d’applications. Cette formation va me permettre de vous accompagner dans la prise en main de Docker, en me concentrant sur son utilisation pratique pour la gestion des conteneurs. Vous découvrirez comment Docker peut vous aider à isoler vos applications et à les exécuter de manière indépendante, quel que soit l’environnement sous-jacent.

C’est quoi Docker ?

Docker est une plateforme open source qui simplifie le déploiement et la gestion d’applications en utilisant des conteneurs.

Concrètement, un conteneur est une unité légère et portable qui regroupe tout ce dont une application a besoin pour fonctionner : le code, les bibliothèques et les dépendances. Grâce à Docker, ces conteneurs peuvent s’exécuter de manière isolée, quel que soit l’environnement sous-jacent, que ce soit sur votre ordinateur, un serveur ou dans le cloud.

L’avantage principal de Docker est qu’il permet d’éviter les fameux “ça marche chez moi, mais pas ailleurs” en garantissant que votre application tourne de la même façon partout. Cela rend vos déploiements plus rapides, plus flexibles et plus faciles à gérer.

L’histoire de Docker

L’histoire de Docker commence en 2010, lorsque Solomon Hykes, un ingénieur français, commence à travailler sur un projet personnel de virtualisation légère. L’idée était de créer un outil qui simplifierait le processus de développement, de test et de déploiement d’applications en utilisant des conteneurs.

En 2013, Docker a été publié en tant que projet open source, initialement appelé “dotCloud” en référence à la société dotCloud fondée par Solomon Hykes. Docker a rapidement gagné en popularité parmi les développeurs et les administrateurs système.

En juin 2014, Docker 1.0 a été officiellement lancé. C’était un jalon important, marquant la maturité de la technologie de conteneurisation. Docker est devenu un outil standard pour les développeurs et les opérations informatiques.

Concepts fondamentaux de Docker

Avant de se plonger dans l’utilisation pratique de Docker, il est essentiel de bien comprendre ses concepts fondamentaux. Docker repose sur plusieurs notions clés qui permettent de gérer efficacement les applications et leurs environnements. Voici une explication des concepts principaux : images, containers, Dockerfile, volumes et réseaux.

Images Docker

Une image Docker est un package contenant tout ce dont une application a besoin pour fonctionner : le code, les bibliothèques, les dépendances et les configurations système. Une image est immuable, c’est-à-dire qu’elle ne change pas une fois créée. C’est à partir de cette image qu’on va créer des containers.

Les images sont souvent basées sur d’autres images. Par exemple, une image de base comme alpine ou ubuntu peut être utilisée comme point de départ, à laquelle on ajoute des fichiers et des configurations spécifiques.

Containers

Un container est une instance en cours d’exécution d’une image Docker. Il s’agit de l’entité active qui exécute une application. Les containers partagent le noyau du système d’exploitation de l’hôte, ce qui les rend beaucoup plus légers que les machines virtuelles. Cependant, chaque container fonctionne dans son propre environnement isolé en s’appuyant sur les namespaces et les cgroups de Linux.

Un container peut être créé, démarré, arrêté et supprimé. Contrairement aux images, un container peut avoir un état modifiable (par exemple, des fichiers qui changent ou des données qui sont ajoutées pendant l’exécution).

Dockerfile

Le Dockerfile est un fichier texte qui contient une série d’instructions permettant de créer une image Docker. C’est grâce à ce fichier que vous allez pouvoir automatiser la création d’une image, en spécifiant les dépendances, les fichiers à copier, les commandes à exécuter, etc. Chaque ligne du Dockerfile correspond à une étape dans le processus de construction de l’image.

Les couches (Layers)

Un concept fondamental dans Docker est celui des layers (couches). Chaque image Docker est composée de plusieurs couches empilées les unes sur les autres. Chaque couche correspond à une instruction dans le Dockerfile (par exemple, RUN, COPY, ADD). Lorsque Docker construit une image, il exécute chaque instruction du Dockerfile et crée une nouvelle couche à chaque étape. Ces couches sont immutables et cachées, ce qui signifie qu’une fois créées, elles ne changent pas.

L’avantage principal de ce système est que Docker utilise un mécanisme de mise en cache des couches. Si une couche n’a pas changé depuis la dernière construction, Docker va simplement la réutiliser au lieu de la reconstruire. Cela accélère énormément la construction des images, en particulier pour les images complexes.

Chaque couche est stockée comme une différence par rapport à la couche précédente (par exemple, les modifications de fichiers ou les nouveaux fichiers ajoutés). Le dernier ensemble de couches forme une image complète, qui peut être utilisée pour exécuter des containers.

Volumes

Les volumes Docker sont utilisés pour persister des données en dehors du cycle de vie des containers. En effet, lorsque vous supprimez un container, toutes les données qu’il contenait disparaissent. Les volumes permettent de sauvegarder ces données de manière permanente, même si le container est supprimé et recréé.

Docker permet de monter des volumes, c’est-à-dire de connecter une partie du système de fichiers de l’hôte au container. Cela permet aussi de partager des données entre plusieurs containers.

Réseaux

Docker crée un réseau par défaut appelé bridge, qui permet aux containers de communiquer entre eux. Cependant, vous pouvez créer et gérer différents types de réseaux pour mieux contrôler comment les containers interagissent entre eux et avec l’extérieur. Docker propose plusieurs types de réseaux : bridge, host et overlay.

• Le réseau bridge est le réseau par défaut. Il isole chaque container dans son propre espace réseau, mais permet la communication avec l’hôte.
• Le réseau host permet au container d’utiliser directement l’interface réseau de l’hôte, sans isolation.
• Le réseau overlay est utilisé dans des environnements d’orchestration comme Docker Swarm ou Kubernetes et permet de connecter des containers sur différents hôtes.

Disponibilité de Docker

Docker est disponible sur les plateformes suivantes :

• Les distributions Linux : Ubuntu, Fedora, RHEL, Centos, Gentoo, ArchLinux, openSUSE, CRUX,…
• Les systèmes de cloud : Amazon EC2, Google Compute Engine et Rackspace.
• Les systèmes d’exploitations Mac Os X et Windows. Sous Windows Docker s’appuie sur une mini VM Linux packagée dans le produit Docker Desktop ↗.

Installation de Docker

L’installation de Docker est la première étape pour commencer à travailler avec des containers. Docker peut être installé sur plusieurs systèmes d’exploitation, tels que Linux, Windows et macOS. Dans cette section, je vais vous guider à travers les étapes pour installer Docker sur chacune de ces plateformes. Nous verrons également comment vérifier que Docker est bien installé et prêt à être utilisé.

Installation de Docker sur Linux (Ubuntu)

Sur Linux, Docker est compatible avec plusieurs distributions, mais ici, je vais me concentrer sur Ubuntu, l’une des distributions les plus populaires. L’installation de Docker sur Ubuntu nécessite quelques étapes pour garantir que vous avez la dernière version disponible.

1. Mettre à jour le système :

   Avant d’installer Docker, il est recommandé de mettre à jour vos paquets pour s’assurer que le système est à jour.

   sudo apt-get update
   sudo apt-get upgrade

2. Installer les paquets nécessaires :

   Docker nécessite certains paquets comme apt-transport-https, ca-certificates, curl et software-properties-common. Installez-les avec la commande suivante :

   sudo apt-get install apt-transport-https ca-certificates curl software-properties-common

3. Ajouter la clé GPG officielle de Docker :

   Cette étape permet de vérifier que les paquets installés proviennent bien des dépôts officiels de Docker.

   curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo gpg --dearmor -o /usr/share/keyrings/docker-archive-keyring.gpg

4. Ajouter le dépôt Docker :

   Ajoutez le dépôt Docker à vos sources pour vous assurer d’installer la dernière version.

   echo "deb [arch=$(dpkg --print-architecture) signed-by=/usr/share/keyrings/docker-archive-keyring.gpg] https://download.docker.com/linux/ubuntu $(lsb_release -cs) stable" | sudo tee /etc/apt/sources.list.d/docker.list > /dev/null

5. Installer Docker :

   Après avoir ajouté le dépôt, mettez à jour vos paquets et installez Docker.

   sudo apt-get update
   sudo apt-get install docker-ce docker-ce-cli containerd.io

6. Permissions utilisateur :

   Par défaut, Docker nécessite des privilèges super-utilisateur (root). Pour éviter de devoir utiliser sudo à chaque commande, ajoutez votre utilisateur au groupe docker.

   sudo usermod -aG docker ${USER}

   Après cette commande, déconnectez-vous puis reconnectez-vous pour appliquer les changements.

Installation de Docker sur Windows

Sur Windows, Docker est installé via Docker Desktop, un outil qui permet d’exécuter Docker de manière native ou avec une machine virtuelle en arrière-plan. Docker Desktop offre une interface graphique simplifiée pour gérer vos containers, mais permet aussi d’utiliser la CLI Docker.

1. Télécharger Docker Desktop :

   Rendez-vous sur le site officiel de Docker pour télécharger Docker Desktop pour Windows : https://www.docker.com/products/docker-desktop ↗.

2. Exécuter l’installateur :

   Lancez le fichier téléchargé et suivez les instructions de l’assistant d’installation. Assurez-vous d’activer la configuration recommandée de WSL 2 (Windows Subsystem for Linux) pour une meilleure performance avec Docker.

3. Redémarrer le système :

   Une fois l’installation terminée, Docker Desktop vous demandera peut-être de redémarrer votre machine.

4. Lancer Docker Desktop :

   Après le redémarrage, lancez Docker Desktop depuis le menu Démarrer. Une fois lancé, vous devriez voir une icône Docker dans la barre des tâches. Si l’icône est verte, cela signifie que Docker est prêt à être utilisé.

Installation de Docker sur macOS avec Colima

Colima est une alternative légère à Docker Desktop sur macOS. Il utilise Lima, un gestionnaire de machines virtuelles et s’intègre avec QEMU pour exécuter des containers de manière efficace, sans nécessiter l’installation de Docker Desktop ni de dépendances lourdes. Colima est apprécié pour sa simplicité, sa compatibilité avec Homebrew et son faible impact sur les ressources système.

Avantages de Colima :

• Léger et rapide : Colima consomme moins de ressources système que Docker Desktop, ce qui le rend idéal pour les machines avec une mémoire ou un CPU limités.
• Facile à installer et à utiliser : Colima s’installe rapidement via Homebrew et ne nécessite pas de configuration lourde.
• Open-source et basé sur des outils existants comme Lima et QEMU.
• Compatibilité Apple Silicon : Colima fonctionne parfaitement sur les Mac équipés de processeurs M1/M2, sans nécessiter de backend complexe.

Voici comment installer et configurer Docker avec Colima sur macOS.

1. Installer Homebrew (si ce n’est pas déjà fait) :

   Homebrew est le gestionnaire de paquets de référence sur macOS. Si vous ne l’avez pas installé, voici la commande pour l’ajouter à votre système :

   /bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh)"

   Ensuite, mettez à jour Homebrew :

   brew update

2. Installer Docker CLI :

   Docker CLI est l’outil en ligne de commande nécessaire pour interagir avec les containers. Colima utilise le Docker CLI, mais sans nécessiter Docker Desktop.

   brew install docker

3. Installer Colima :

   Utilisez Homebrew pour installer Colima, qui va gérer les containers via une machine virtuelle légère.

   brew install colima

4. Démarrer Colima avec Docker :

   Une fois Colima installé, vous pouvez le démarrer avec le support Docker. Colima va créer une machine virtuelle qui exécutera Docker en arrière-plan.

   colima start

   Par défaut, Colima configure un environnement Docker avec 2 processeurs et 2 Go de mémoire. Si vous avez besoin de plus de ressources, vous pouvez spécifier ces options lors du démarrage :

   colima start --cpu 4 --memory 4

5. Vérifier que Docker fonctionne avec Colima :

   Vous pouvez maintenant vérifier si Docker fonctionne correctement en exécutant la commande suivante :

   docker --version

   Puis lancez le container de test hello-world pour vérifier que tout fonctionne correctement.

   docker run hello-world

6. Gérer Colima :

   Pour stopper ou redémarrer l’instance Colima (et Docker), utilisez les commandes suivantes :

   • Arrêter Colima (et Docker) :

     colima stop

   • Redémarrer Colima :

     colima restart

   Colima est également capable de gérer les volumes persistants, les réseaux et les partages de fichiers de manière similaire à Docker Desktop.

Vérification du bon fonctionnement de Docker

Quelle que soit la plateforme sur laquelle Docker est installé, il est important de vérifier que tout fonctionne bien. Pour cela, je recommande d’exécuter un container test en lançant un container simple à partir de l’image hello-world. Cette image est conçue pour tester le bon fonctionnement de Docker.

docker run hello-world

Si Docker est bien installé, vous devriez voir un message confirmant que le container s’est lancé correctement.

Découverte de la CLI Docker

La CLI Docker (interface en ligne de commande) est l’outil principal pour interagir avec Docker. Elle permet de gérer les containers, les images, les réseaux et les volumes via des commandes simples. Dans ce chapitre, je vais vous guider à travers les commandes de base de Docker, en vous expliquant comment télécharger des images, créer des containers et gérer vos applications containérisées.

Recherche d’images sur Docker Hub

Docker Hub est le registre officiel où les développeurs et les organisations publient des images Docker prêtes à l’emploi. Vous pouvez y trouver des images de systèmes d’exploitation, de bases de données, de serveurs web et bien plus encore. Avant de télécharger une image, il est souvent utile de rechercher celle qui correspond à vos besoins. Docker CLI vous permet de rechercher des images directement à partir du terminal.

Pour rechercher une image sur Docker Hub, vous pouvez utiliser la commande docker search. Cette commande renvoie une liste d’images correspondant à votre terme de recherche, avec des informations utiles comme la description et le nombre d’étoiles (stars), qui est un indicateur de la popularité et de la fiabilité de l’image.

Exemple : Rechercher une image liée à nginx :

docker search nginx

Vous obtiendrez une sortie ressemblant à ceci :

NAME                              DESCRIPTION                                     STARS     OFFICIAL
nginx                             Official build of Nginx.                        20184     [OK]
nginx/nginx-quic-qns              NGINX QUIC interop                              1
nginx/nginx-prometheus-exporter   NGINX Prometheus Exporter for NGINX and NGIN…   43
nginx/nginx-ingress               NGINX and  NGINX Plus Ingress Controllers fo…   94
nginx/nginx-ingress-operator      NGINX Ingress Operator for NGINX and NGINX P…   2
nginx/unit                        This repository is retired, use the Docker o…   63
nginx/unit-preview                Unit preview features                           0
bitnami/nginx                     Bitnami container image for NGINX               193
rapidfort/nginx                   RapidFort optimized, hardened image for NGINX   15
kasmweb/nginx                     An Nginx image based off nginx:alpine and in…   8
ubuntu/nginx                      Nginx, a high-performance reverse proxy & we…   118

• NAME : Le nom de l’image.
• DESCRIPTION : Une brève description de l’image.
• STARS : Un indicateur de popularité basé sur les utilisateurs qui ont donné une “étoile” à l’image.
• OFFICIAL : Le tag [OK] indique que l’image est officielle, c’est-à-dire maintenue par les créateurs ou les mainteneurs du logiciel.
• AUTOMATED : Ce tag signifie que l’image a été automatiquement générée à partir d’un Dockerfile à l’aide d’une intégration continue (CI).

Il est important de choisir une image bien maintenue, souvent identifiée par un grand nombre d’étoiles et le tag [OFFICIAL], qui garantit que l’image est fournie par l’organisation officielle derrière la technologie.

Télécharger une image Docker (pull)

La commande docker pull est utilisée pour télécharger une image Docker depuis un registre, principalement Docker Hub ↗. Une image contient tout ce qui est nécessaire pour exécuter une application : le code, les bibliothèques et les dépendances. Avant de créer un container, vous devez d’abord récupérer l’image à partir de laquelle ce container sera créé.

Exemple : Pour télécharger l’image officielle de nginx, vous pouvez utiliser la commande suivante :

docker pull nginx
Using default tag: latest
latest: Pulling from library/nginx
92c3b3500be6: Pull complete
ee57511b3c68: Extracting [==============================================>    ]  36.18MB/38.51MB
33791ce134bf: Download complete
cc4f24efc205: Download complete
3cad04a21c99: Download complete
486c5264d3ad: Download complete
b3fd15a82525: Download complete

Cela téléchargera la dernière version de l’image nginx depuis Docker Hub. On remarque le tag : latest. Je vais revenir plus tard sur ce concept.

Lister les images Docker présentes

La commande docker images est essentielle pour gérer les images Docker stockées localement. Elle permet de lister et de consulter ces images ainsi que leurs détails, facilitant ainsi leur gestion.

La syntaxe de la commande est très simple :

docker images

Lorsque vous exécutez cette commande, Docker renvoie une liste des images disponibles sur votre machine locale. Voici un exemple de sortie typique :

REPOSITORY          TAG                 IMAGE ID            CREATED             SIZE
docker images
REPOSITORY              TAG       IMAGE ID       CREATED        SIZE
nginx                   alpine    b887aca7aed6   3 weeks ago    47MB
nginx                   latest    195245f0c792   3 weeks ago    193MB
erikvl87/languagetool   latest    6a077d826d4f   4 months ago   581MB

• REPOSITORY : Le nom du dépôt (repository) de l’image. Il s’agit généralement du nom de l’image (comme nginx), mais cela peut aussi inclure le nom d’un utilisateur ou d’une organisation sur Docker Hub (par exemple, mydockerhub/myapp).
• TAG : Le tag est une étiquette qui identifie une version spécifique de l’image. Par défaut, Docker utilise le tag latest si aucun autre tag n’est spécifié, mais des tags peuvent représenter des versions spécifiques, comme 1.0, alpine, ou v2.3.
• IMAGE ID : L’ID unique de l’image. Il s’agit d’une chaîne alphanumérique générée par Docker lors de la création de l’image. Cet ID peut être utilisé pour référencer l’image dans d’autres commandes Docker, comme docker rmi (pour supprimer une image) ou docker run (pour créer un container à partir de cette image).
• CREATED : La date à laquelle l’image a été créée. Cela permet de voir l’ancienneté des images et de déterminer si elles nécessitent une mise à jour.
• SIZE : La taille de l’image sur le disque, indiquée en Mo (MB). Cette information est importante pour gérer l’espace disque, surtout si vous manipulez plusieurs images lourdes.

Si vous souhaitez obtenir plus d’informations sur une image en particulier, comme les couches qui la composent, ses variables d’environnement ou ses volumes. Pour cela, vous pouvez utiliser la commande docker inspect.

Exemple : Inspecter l’image nginx :

docker inspect nginx

Cette commande renvoie un ensemble de données au format JSON, vous fournissant des détails techniques sur l’image.

Créer une image Docker

La commande docker build est utilisée pour créer une image Docker à partir d’un fichier appelé Dockerfile. Le Dockerfile est un script texte qui contient une série d’instructions permettant de définir l’environnement dans lequel une application sera exécutée. Ces instructions peuvent inclure l’installation de logiciels, la copie de fichiers, la définition de variables d’environnement, etc. La commande docker build exécute ces instructions et produit une image Docker immuable.

Attention

L’équipe Docker a récemment annoncé que l’utilisation de la commande docker build dans sa forme actuelle est progressivement dépréciée et sera entièrement remplacée par BuildKit. BuildKit est un nouveau moteur de build plus performant, sécurisé et flexible.

Pourquoi ce changement ? BuildKit offre des avantages considérables par rapport à la commande docker build traditionnelle :

• Une amélioration des performances de build grâce à la construction en parallèle et à une meilleure gestion des caches.
• Une utilisation plus optimisée des ressources (CPU, mémoire).
• Des fonctionnalités avancées comme la prise en charge des builds multi-plateformes et des caches de builds distribués.
• Une plus grande sécurité avec des fonctionnalités comme le build rootless (sans accès root).

Que dois-je faire ? Je recommande vivement d’activer BuildKit dès maintenant et de l’utiliser pour toutes vos constructions d’images Docker. Cela peut être fait en ajoutant la variable d’environnement suivante :

export DOCKER_BUILDKIT=1

Plus d’infos

La syntaxe de base de la commande docker build est la suivante :

docker build [OPTIONS] PATH

• PATH : Le chemin vers le répertoire contenant le Dockerfile. Si le Dockerfile est dans le répertoire courant, vous pouvez utiliser . pour spécifier ce chemin.
• OPTIONS : Des options facultatives pour contrôler le processus de construction (par exemple, spécifier un tag ou optimiser la taille de l’image).

Voici un exemple de Dockerfile simple qui utilise une image de base alpine, copie un fichier dans le container et exécute une commande lors du démarrage :

FROM alpine:3.18.4
RUN apk update && \
    apk upgrade
# Installer Nginx
RUN apk add --no-cache nginx
# Exposer le port 80 pour permettre l'accès HTTP
EXPOSE 80
# Démarrer Nginx
CMD ["nginx", "-g", "daemon off;"]

Si vous ne maitrisez pas le gestionnaire de paquets apk, je vous recommande de lire mon guide sur apk pour mieux comprendre son fonctionnement.

Pour construire une image à partir de ce Dockerfile, placez le fichier Dockerfile dans un répertoire et exécutez la commande suivante :

docker build -t myapp:1.0 .
Sending build context to Docker daemon  2.048kB
Step 1/5 : FROM alpine:3.18.4
 ---> 3cc203321400
Step 2/5 : RUN apk update &&     apk upgrade
 ---> Running in b4c966493073

...
Step 3/5 : RUN apk add --no-cache nginx
 ---> Running in ad860f80fc79
fetch https://dl-cdn.alpinelinux.org/alpine/v3.18/main/aarch64/APKINDEX.tar.gz
fetch https://dl-cdn.alpinelinux.org/alpine/v3.18/community/aarch64/APKINDEX.tar.gz
(1/2) Installing pcre (8.45-r3)
(2/2) Installing nginx (1.24.0-r7)
Executing nginx-1.24.0-r7.pre-install
Executing nginx-1.24.0-r7.post-install
Executing busybox-1.36.1-r7.trigger
OK: 9 MiB in 17 packages
 ---> Removed intermediate container ad860f80fc79
 ---> e691a5e3520c
Step 4/5 : EXPOSE 80
 ---> Running in 5ce84ba92906
 ---> Removed intermediate container 5ce84ba92906
 ---> f28a702b100f
Step 5/5 : CMD ["nginx", "-g", "daemon off;"]
 ---> Running in 8eb7de19291e
 ---> Removed intermediate container 8eb7de19291e
 ---> 1b5538b8380d
Successfully built 1b5538b8380d
Successfully tagged myapp:1.0

• -t myapp:1.0 : Cette option permet de taguer l’image avec un nom (myapp) et un tag de version (1.0).
• . : Indique que Docker doit chercher le Dockerfile dans le répertoire courant.

Une fois la construction terminée, vous pouvez vérifier que l’image a été correctement construite en listant les images sur votre machine :

docker images
REPOSITORY              TAG       IMAGE ID       CREATED         SIZE
myapp                   1.0       1b5538b8380d   2 minutes ago   20.3MB

Exécuter des containers

La commande docker run est l’une des plus importantes de Docker, car elle permet de créer et démarrer un container à partir d’une image Docker. Elle est au cœur du fonctionnement des containers, car c’est cette commande qui crée une instance active d’une image. La commande docker run est très puissante et offre de nombreuses options pour personnaliser l’exécution des containers.

La syntaxe de base est la suivante :

docker run [OPTIONS] IMAGE [COMMAND] [ARG...]

• IMAGE : L’image Docker à partir de laquelle le container sera créé (par exemple, nginx, ubuntu:20.04).
• COMMAND (optionnel) : La commande à exécuter à l’intérieur du container une fois démarré (par exemple, /bin/bash).
• ARG… (optionnel) : Les arguments à passer à la commande si nécessaire.

Voici quelques-unes des options les plus couramment utilisées avec docker run :

1. -d : Exécution en arrière-plan (mode détaché) Par défaut, un container s’exécute en mode interactif (en premier plan) dans votre terminal. Si vous souhaitez que le container fonctionne en arrière-plan, utilisez l’option -d (détaché).

   docker run -d myapp:1.0

   Avec cette commande, Docker crée et démarre un container myapp:1.0 qui s’exécute en arrière-plan, sans bloquer votre terminal. Vous pouvez ensuite interagir avec ce container via d’autres commandes.

2. -p : Redirection de ports La redirection de port permet de mapper un port du container à un port de la machine hôte. Par exemple, si une application dans le container écoute sur le port 80, vous pouvez la rendre accessible via le port 8080 de votre machine hôte.

   docker run -d -p 8080:80 myapp:1.0

   Ici :

   • Le port 80 à l’intérieur du container (port par défaut de nginx) est mappé au port 8080 de la machine hôte.
   • Vous pouvez maintenant accéder à nginx via http://localhost:8080 sur votre machine hôte.

3. --name : Nommer un container Par défaut, Docker attribue un nom aléatoire à chaque container. Pour rendre la gestion des containers plus facile, vous pouvez spécifier un nom avec l’option --name.

   docker run -d --name mon_nginx nginx

   Avec cette commande, le container sera nommé mon_nginx, ce qui permet de le gérer plus facilement par la suite (par exemple, avec docker stop mon_nginx ou docker logs mon_nginx).

4. --rm : Supprimer le container après exécution Si vous voulez qu’un container soit supprimé automatiquement après qu’il s’arrête, utilisez l’option --rm. Cela est particulièrement utile pour les containers temporaires ou les tâches ponctuelles.

   docker run --rm ubuntu echo "Hello, World"

   Dans cet exemple, Docker exécute l’image ubuntu avec la commande echo. Dès que la commande se termine, le container est automatiquement supprimé.

5. -it : Mode interactif avec terminal L’option -it est utilisée pour exécuter un container en mode interactif avec accès à un terminal. Cela est utile lorsque vous voulez exécuter des commandes dans le container.

   docker run -it ubuntu /bin/bash

   Dans cet exemple, Docker démarre un container basé sur l’image ubuntu et ouvre un shell bash interactif dans le terminal. Vous pouvez maintenant exécuter des commandes comme si vous étiez connecté directement à une machine Ubuntu.

Gérer les versions d’images

La commande docker tag permet d’ajouter un tag (étiquette) à une image Docker existante. Les tags sont utilisés pour identifier différentes versions d’une même image ou pour référencer une image dans un registre Docker (comme Docker Hub). Ils facilitent la gestion des versions d’images et permettent de distinguer les images selon des environnements ou des fonctionnalités spécifiques (ex : v1.0, latest, prod).

La syntaxe de base de la commande docker tag est :

docker tag SOURCE_IMAGE[:TAG] TARGET_IMAGE[:TAG]

• SOURCE_IMAGE[:TAG] : L’image source que vous voulez taguer. Vous pouvez inclure le tag de l’image source si elle en a un (par exemple, myapp:1.0).
• TARGET_IMAGE[:TAG] : Le nouveau tag que vous voulez attribuer à l’image. Cela peut inclure un nouveau nom de dépôt ou un nouveau tag.

Supposons que vous ayez une image locale appelée myapp avec un tag v1.0. Vous voulez créer un nouveau tag v2.0 pour cette image afin de versionner votre application. Voici comment vous pouvez le faire :

docker tag myapp:1.0 myapp:2.0

Cette commande crée une nouvelle référence à la même image, mais avec le tag v2.0. Vous pouvez vérifier cela en listant les images locales avec docker images :

docker images
REPOSITORY              TAG       IMAGE ID       CREATED          SIZE
myapp                   1.0       1b5538b8380d   18 minutes ago   20.3MB
myapp                   2.0       1b5538b8380d   18 minutes ago   20.3MB

Vous verrez à la fois les tags v1.0 et v2.0 pour l’image myapp, mais ils pointeront tous deux vers le même ID d’image.

Lister les containers avec docker ps

La commande docker ps permet de lister les containers Docker en cours d’exécution ou arrêtés. C’est une commande essentielle pour visualiser les informations importantes sur vos containers actifs, comme leur nom, leur ID, les ports mappés, l’image à partir de laquelle ils sont exécutés, et plus encore. Elle permet également de surveiller l’état des containers dans votre environnement Docker.

La commande de base pour afficher les containers en cours d’exécution est :

docker ps

Par défaut, docker ps affiche uniquement les containers actifs (c’est-à-dire en cours d’exécution). Pour lister tous les containers (y compris les containers arrêtés), vous devez utiliser l’option -a.

docker ps -a

Voici un exemple de sortie typique de la commande docker ps :

CONTAINER ID   IMAGE                   COMMAND                  CREATED          STATUS                 PORTS                                       NAMES
f1f86db17d2c   myapp:1.0               "nginx -g 'daemon of…"   12 minutes ago   Up 12 minutes          0.0.0.0:8080->80/tcp, [::]:8080->80/tcp     practical_banzai
1c9b8569a9cd   myapp:1.0               "nginx -g 'daemon of…"   23 minutes ago   Up 23 minutes          80/tcp                                      upbeat_gould
4f8dd1f2f176   myapp:1.0               "-d"                     23 minutes ago   Created                80/tcp                                      jovial_allen
07dac3c0d17c   erikvl87/languagetool   "bash start.sh"          6 days ago       Up 2 hours (healthy)   0.0.0.0:8010->8010/tcp, :::8010->8010/tcp   LanguageTool

Explication des colonnes :

• CONTAINER ID : L’ID unique du container. Cet ID est utilisé pour référencer le container dans d’autres commandes Docker (par exemple, docker stop, docker rm, etc.).
• IMAGE : L’image à partir de laquelle le container a été créé. Cela vous indique quelle version de l’application ou du service tourne dans le container (ici, myapp:1.0 et erikvl87/languagetool).
• COMMAND : La commande qui a été exécutée à l’intérieur du container au moment de son lancement. Elle correspond à ce que l’image a défini dans le Dockerfile via la directive CMD ou ENTRYPOINT.
• CREATED : Le moment où le container a été créé.
• STATUS : L’état du container. Cela peut être Up (en cours d’exécution), Exited (arrêté), ou d’autres états (comme Paused si vous avez mis un container en pause).
• PORTS : Les ports mappés entre le container et la machine hôte. Par exemple, 0.0.0.0:8080->80/tcp signifie que le port 8080 de l’hôte est mappé au port 80 du container.
• NAMES : Le nom du container. Docker génère un nom par défaut pour chaque container si vous n’en spécifiez pas un avec l’option --name lors de la création du container.

Gérer les instances de containers

Les commandes docker stop et docker rm sont essentielles pour arrêter et supprimer les containers Docker. Ces deux commandes permettent de gérer le cycle de vie des containers, qu’il s’agisse d’arrêter un container en cours d’exécution ou de supprimer définitivement un container qui n’est plus nécessaire. Voici comment les utiliser de manière efficace.

docker stop

La commande docker stop permet d’arrêter un container en cours d’exécution de manière propre et contrôlée. Lorsqu’un container est arrêté, Docker envoie un signal SIGTERM au processus principal du container pour lui donner la possibilité de terminer correctement ses opérations. Après un certain délai (par défaut 10 secondes), Docker envoie un signal SIGKILL pour forcer l’arrêt si le processus ne s’est pas terminé.

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

• CONTAINER : L’ID ou le nom du container que vous souhaitez arrêter.
• OPTIONS : Les options disponibles incluent notamment la durée du délai avant l’arrêt forcé.

Exemples :

1. Arrêter un container avec son nom :

   docker stop mycontainer

   Cette commande envoie un signal d’arrêt au container nommé mycontainer.

2. Arrêter un container avec son ID :

   docker stop 4c01db0b339c

   Ici, Docker arrête le container dont l’ID est 4c01db0b339c.

docker rm

La commande docker rm permet de supprimer un container qui est arrêté. Une fois supprimé, le container ne peut plus être redémarré ou récupéré, à moins de recréer un container à partir de l’image originale. Cette commande est utile pour nettoyer les containers qui ne sont plus utilisés afin de libérer de l’espace disque.

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

• CONTAINER : L’ID ou le nom du container à supprimer.
• OPTIONS : Les options incluent la suppression forcée des containers actifs avec -f.

Exemples :

1. Supprimer un container arrêté :

   docker rm mycontainer

   Cette commande supprime le container nommé mycontainer. Le container doit être arrêté avant de pouvoir être supprimé.

2. Supprimer plusieurs containers en une seule commande :

   Vous pouvez spécifier plusieurs containers à supprimer en séparant leurs noms ou IDs.

   docker rm container1 container2 container3

3. Supprimer un container actif avec -f :

   Si un container est en cours d’exécution, vous ne pouvez pas le supprimer directement. Il faut soit l’arrêter d’abord avec docker stop, soit utiliser l’option -f pour forcer la suppression (ce qui arrête et supprime le container en une seule étape).

   docker rm -f mycontainer

   Cette commande force l’arrêt et la suppression immédiate de mycontainer.

Supprimer des images

La commande docker rmi est utilisée pour supprimer des images Docker stockées localement sur votre machine. Cela permet de libérer de l’espace disque ou de supprimer des images obsolètes ou non désirées. Contrairement à la suppression de containers (docker rm), qui concerne les instances en cours d’exécution d’une image, docker rmi supprime l’image elle-même, empêchant ainsi la création de nouveaux containers basés sur cette image, à moins qu’elle ne soit re-téléchargée ou reconstruite.

La syntaxe de base pour supprimer une image est la suivante :

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

• IMAGE : L’ID ou le nom de l’image à supprimer. Vous pouvez spécifier plusieurs images à la fois.
• OPTIONS : Des options supplémentaires pour contrôler la suppression.

Exemple simple :

Pour supprimer une image par son ID ou son nom :

docker rmi nginx:latest

ou

docker rmi a9e5b1d98f9c

Dans cet exemple, Docker supprime l’image nginx:latest ou l’image avec l’ID a9e5b1d98f9c.

Options courantes de docker rmi

1. -f : Forcer la suppression d’une image

   Si une image est utilisée par un container (en cours d’exécution ou arrêté), Docker ne vous permettra pas de la supprimer par défaut. Pour forcer la suppression d’une image, utilisez l’option -f (force).

   docker rmi -f nginx:latest

   Cela force Docker à supprimer l’image nginx:latest, même si des containers en dépendent. Attention : cela peut avoir des conséquences si vous avez des containers actifs basés sur cette image.

2. Supprimer plusieurs images en une seule commande

   Vous pouvez spécifier plusieurs images à supprimer en une seule ligne de commande. Utilisez simplement les noms ou IDs des images, séparés par des espaces.

   docker rmi nginx:latest redis:alpine ubuntu:20.04

   Dans cet exemple, Docker supprimera les images nginx:latest, redis:alpine et ubuntu:20.04.

3. Supprimer toutes les images inutilisées

   Si vous avez accumulé beaucoup d’images inutilisées et souhaitez faire du ménage, vous pouvez utiliser la commande docker image prune pour supprimer toutes les images dangling (c’est-à-dire les images sans tag ou non utilisées).

   docker image prune

   Cette commande supprime toutes les images qui ne sont pas utilisées par des containers en cours d’exécution et qui ne sont pas taguées. Pour forcer la suppression de toutes les images inutilisées sans confirmation, utilisez l’option -f :

   docker image prune -f

Gérer les ressources Docker avec docker system

La commande docker system est une commande puissante qui permet de gérer les ressources globales de Docker, telles que les containers, images, volumes et réseaux. Elle regroupe plusieurs sous-commandes qui permettent de nettoyer, surveiller et optimiser l’utilisation des ressources sur votre système Docker.

La syntaxe de base de docker system est :

docker system [COMMAND]

Voici un aperçu des sous-commandes principales disponibles avec docker system.

1. docker system df : Vérifier l’utilisation des ressources Docker

   La commande docker system df vous permet de vérifier l’espace disque utilisé par Docker, ainsi que l’espace occupé par les images, containers, volumes et réseaux.

   docker system df

   Exemple de sortie :

   TYPE            TOTAL     ACTIVE    SIZE      RECLAIMABLE
   Images          15        3         2.35GB    1.2GB (51%)
   Containers      10        2         500MB     300MB (60%)
   Local Volumes   5         5         1.5GB     0B (0%)
   Build Cache     0         0         0B        0B

   Explication des colonnes :

   • TYPE : Le type de ressource (images, containers, volumes, etc.).
   • TOTAL : Le nombre total d’éléments pour chaque type.
   • ACTIVE : Le nombre d’éléments actuellement utilisés.
   • SIZE : L’espace disque total occupé par chaque type.
   • RECLAIMABLE : L’espace disque qui peut être récupéré (réutilisé ou libéré).

   Cela permet d’identifier rapidement quelles ressources consomment le plus d’espace et peuvent être nettoyées.

2. docker system prune : Nettoyer les ressources inutilisées

   La commande docker system prune est utilisée pour supprimer toutes les ressources inutilisées (images non utilisées, containers arrêtés, volumes orphelins, réseaux non utilisés). C’est une manière efficace de nettoyer votre environnement Docker et de libérer de l’espace disque.

   docker system prune

   Cela supprime :

   • Les containers arrêtés.
   • Les images dangling (images sans tag ou inutilisées).
   • Les réseaux non utilisés.
   • Les volumes non utilisés.

   Exemple de sortie :

   WARNING! This will remove:
   - all stopped containers
   - all dangling images
   - all unused networks
   Are you sure you want to continue? [y/N] y
   Deleted Containers:
   a9e5b1d98f9c
   f670fd9a76f5
   
   Deleted Images:
   untagged: ubuntu:latest
   deleted: sha256:7e0aa2d69a15
   
   Deleted Networks:
   my-network
   
   Total reclaimed space: 2.3GB

   • -a : Supprimer toutes les images inutilisées

     Si vous voulez également supprimer les images qui ne sont pas associées à un container actif (et pas seulement les images dangling), utilisez l’option -a avec docker system prune.

     docker system prune -a

     Cela supprime toutes les images inutilisées, même si elles sont taguées mais non utilisées par un container actif.

   • -f : Forcer la suppression sans confirmation

     Si vous souhaitez automatiser le processus de nettoyage, vous pouvez ajouter l’option -f pour ne pas avoir à confirmer la suppression manuellement.

     docker system prune -f

   • --volumes : Nettoyer aussi les volumes

     Par défaut, docker system prune ne supprime pas les volumes inutilisés. Si vous voulez également supprimer les volumes orphelins, ajoutez l’option --volumes.

     docker system prune --volumes

     Attention : Cette option supprime définitivement tous les volumes non utilisés, ce qui peut entraîner la perte de données si des volumes importants ne sont pas attachés à des containers.

3. docker system info : Informations système sur Docker

   La commande docker system info fournit des informations détaillées sur l’installation de Docker, notamment les versions, les paramètres de configuration et l’état de votre système Docker.

   docker system info

   Exemple de sortie :

   Containers: 5
   Running: 2
   Paused: 0
   Stopped: 3
   Images: 15
   Server Version: 20.10.8
   Storage Driver: overlay2
   ...

   Vous pouvez voir des informations comme :

   • Le nombre total de containers (en cours d’exécution, en pause, ou arrêtés).
   • Le nombre d’images locales.
   • La version de Docker installée.
   • Le driver de stockage utilisé.
   • Des informations sur le réseau, les volumes et d’autres composants.

4. docker system events : Surveiller les événements Docker en temps réel

   La commande docker system events vous permet de surveiller en temps réel les événements qui se produisent sur votre système Docker. Cela inclut les événements liés aux containers, aux images, aux volumes et aux réseaux.

   docker system events

   Cette commande continue d’afficher les événements au fur et à mesure qu’ils se produisent, ce qui en fait un outil précieux pour le diagnostic et le suivi des actions dans un environnement Docker.

   Exemple de sortie d’événements :

   2021-09-12T12:00:10.123456789Z container start 7c99e03b2bf4 (image=nginx, name=mynginx)
   2021-09-12T12:02:20.987654321Z network create my-network (id=7df1bfc4a128)
   2021-09-12T12:03:30.654321789Z container stop 7c99e03b2bf4 (image=nginx, name=mynginx)

   Vous pouvez également filtrer les événements avec des options pour ne voir que ceux liés à des types de ressources spécifiques (par exemple, containers ou réseaux).

Contrôle de connaissances

Pourquoi ce contrôle ?

Cet contrôle va vous permettre de valider vos connaissances sur le sujet abordé dans le guide. Il comporte des QCM, des questions vrai/faux et des réponses ouvertes à un mot.

🕒 Le chronomètre commence dès que vous cliquez sur Démarrer le test. Vous devrez terminer l’examen avant la fin du temps imparti.

🎯 Pour réussir, vous devez obtenir au moins 80% de bonnes réponses.

💡 Je ne fournis pas directement les réponses aux questions. Cependant, si certaines sont complexes, des pistes d’explication pourront être proposées dans le guide ou après l’examen.

Bonne chance ! 🚀

Démarrer le test

Temps restant :

Conclusion

Docker, c’est bien plus qu’un simple outil de conteneurisation. C’est un accélérateur de productivité, un booster de déploiement et un garant de portabilité pour vos applications. En le maîtrisant, vous gagnez en efficacité, en fiabilité et en souplesse, que ce soit pour tester une app en local, déployer en production, ou automatiser votre infrastructure.

Vous avez maintenant toutes les clés pour :

• Créer et gérer des conteneurs légers et isolés
• Construire des images optimisées et versionnées
• Nettoyer, inspecter et maintenir un environnement propre avec les bonnes commandes

Et surtout, intégrer Docker dans vos workflows DevOps.

Et ce n’est que le début ! Combinez Docker avec Docker Compose, Docker-Swarm, Kubernetes, ou encore Ansible et Terraform pour aller encore plus loin dans l’automatisation et l’orchestration.

Sur ce site, vous trouverez d’autres documentations ou billets de blog, permettant de progresser dans l’utilisation de Docker :

• Les volumes Docker
• Optimiser la taille des images Docker
• Scanner les vulnérabilités de vos containers, filesystems et …
• Tester votre image avec dockle
• Analyser vos Dockeriile avec Hadolint
• Pour que vos secrets le restent
• Sécuriser son utilisation
• Configurer correctement Docker
• Comment valider des images docker avec container-structure-test

FAQ - Questions Fréquemment Posées

Qu’est‑ce qu’un moteur de conteneurs (container engine) ?

Un moteur de conteneurs est un logiciel qui permet de créer, déployer et gérer des conteneurs isolés, en assurant la création d’images, le démarrage et l’arrêt des conteneurs, l’isolation des ressources et la gestion réseau et sécurité.

Quels sont les principaux moteurs de conteneurs et leurs particularités ?

Les principaux moteurs sont Docker (le plus utilisé avec un vaste écosystème), Podman (sans démon pour plus de sécurité), LXC ou Incus (conteneurs système complets), CRI‑O (léger et compatible Kubernetes) et containerd (runtime performant utilisé aussi par Kubernetes).

Quelles sont les bonnes pratiques pour configurer Docker en production ?

Créer une partition dédiée pour /var/lib/docker, désactiver la communication inter‑conteneurs (icc false), désactiver l’élévation de privilège dans les conteneurs et activer l’audit des fichiers Docker.

Comment sécuriser des déploiements Docker en production ?

Utiliser des images certifiées et Docker Content Trust, limiter les conteneurs privilégiés, appliquer AppArmor ou SELinux, mettre en place des IDS/WAF pour surveiller les journaux, et protéger l’accès au démon Docker.

Quels types de volumes Docker et plugins utiliser pour persister les données ?

Utiliser les volumes standards pour la persistance, tmpfs pour les fichiers temporaires, bind mounts ou volumes NFS pour partage hôte‑conteneur, ou plugins comme SSHFS pour stockages distants.

Quelle est la différence entre une image et un conteneur ?

Une image Docker est un modèle statique et immuable qui contient tout le nécessaire pour exécuter une application, tandis qu’un conteneur est une instance en cours d’exécution de cette image avec son propre système de fichiers et environnement.

Comment fonctionne le système de réseau Docker ?

Docker propose plusieurs modes réseau : bridge (par défaut), host (utilise l’hôte directement), overlay (réseau multi-hôtes) et macvlan. Chaque mode offre des niveaux d’isolation et d’accessibilité différents.

Pourquoi utiliser Docker Compose ?

Docker Compose permet de définir et de gérer des applications multi-conteneurs à l’aide d’un fichier YAML. Il simplifie le déploiement, le scaling et le cycle de vie d’une stack de services.

Quelle est la différence entre Docker et Kubernetes ?

Docker gère la création et l’exécution de conteneurs sur un seul hôte, alors que Kubernetes orchestre plusieurs conteneurs répartis sur un cluster, avec des fonctions d’auto-scaling, de redondance et de gestion d’état.

Qu’est-ce qu’un Dockerfile et comment l’utiliser ?

Un Dockerfile est un script texte contenant les instructions nécessaires à la création d’une image Docker. Il est utilisé avec la commande docker build pour générer une image personnalisée.

Plus d’infos

• Documentation Officiel : docker.com ↗