Aller au contenu
DevSecOps Logo DevSecOps Logo DevSecOps
Docs
Blog
Blog

Maitriser les conteneurs Docker

Mise à jour :

logo docker

Docker est devenu un outil incontournable pour simplifier et optimiser le déploiement d’applications. Ce guide 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.

    Terminal window
    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 :

    Terminal window
    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.

    Terminal window
    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.

    Terminal window
    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.

    Terminal window
    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.

    Terminal window
    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 :

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

    Ensuite, mettez à jour Homebrew :

    Terminal window
    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.

    Terminal window
    brew install docker

  3. Installer Colima :

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

    Terminal window
    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.

    Terminal window
    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 :

    Terminal window
    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 :

    Terminal window
    docker --version

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

    Terminal window
    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) :

      Terminal window
      colima stop

    • Redémarrer Colima :

      Terminal window
      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.

Terminal window
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 :

Terminal window
docker search nginx

Vous obtiendrez une sortie ressemblant à ceci :

Terminal window
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 :

Terminal window
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 :

Terminal window
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 :

Terminal window
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 :

Terminal window
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.

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

Terminal window
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;"]

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

Terminal window
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 :

Terminal window
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 :

Terminal window
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é).

    Terminal window
    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.

    Terminal window
    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.

    Terminal window
    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.

    Terminal window
    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.

    Terminal window
    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 :

Terminal window
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 :

Terminal window
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 :

Terminal window
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 :

Terminal window
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.

Terminal window
docker ps -a

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

Terminal window
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é.

Terminal window
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 :

    Terminal window
    docker stop mycontainer

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

  2. Arrêter un container avec son ID :

    Terminal window
    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.

Terminal window
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é :

    Terminal window
    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.

    Terminal window
    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).

    Terminal window
    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 :

Terminal window
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 :

Terminal window
docker rmi nginx:latest

ou

Terminal window
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).

    Terminal window
    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.

    Terminal window
    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).

    Terminal window
    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 :

    Terminal window
    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 :

Terminal window
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.

    Terminal window
    docker system df

    Exemple de sortie :

    Terminal window
    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.

    Terminal window
    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 :

    Terminal window
    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.

      Terminal window
      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.

      Terminal window
      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.

      Terminal window
      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.

    Terminal window
    docker system info

    Exemple de sortie :

    Terminal window
    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.

    Terminal window
    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 :

    Terminal window
    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).

Conclusion

Docker est un outil puissant qui facilite la gestion des containers, rendant le déploiement d’applications plus rapide et plus efficace. Grâce à des commandes simples comme docker run pour démarrer des containers, docker ps pour les lister, ou docker stop et docker rm pour les gérer, Docker permet de contrôler chaque étape du cycle de vie d’un container. De plus, avec des outils comme docker build pour créer des images personnalisées et docker system prune pour nettoyer les ressources inutilisées, il devient facile de maintenir un environnement propre et organisé.

Que vous soyez en développement ou en production, Docker permet d’automatiser, de simplifier et d’optimiser vos processus. En maîtrisant ces commandes de base, vous serez bien équipé pour travailler efficacement avec Docker et profiter pleinement de ses avantages.

Vous pouvez explorer davantage en créant vos propres images Docker personnalisées à l’aide des Dockerfiles, en utilisant Docker Compose pour gérer des applications multi-conteneurs, ou en découvrant des stratégies de déploiement plus avancées avec Docker Swarm ou Kubernetes.

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

Plus d’infos