Docker

Docker est une plateforme utilisée pour exécuter des applications à l'intérieur de conteneurs (les containers). Un container est une sorte de boîte noire incluant l'application et toutes ses dépendances, assurant que l'application fonctionne de la même façon sur toutes les machines.

Consultez le [https://docs.docker.com](site officiel Docker) pour une documentation approfondie sur le stockage et le réseau dans Docker, et tout ce qui ne sera pas décrit ou pas clair pour vous dans ce document résumé.

Les containers sont disponibles par défaut sur le hub public https://hub.docker.com avec un choix important sur l'ensemble des problématiques informatiques : serveurs web, serveurs linux, serveurs de bases de données et bien d'autres encore.

Structure de Docker

La containerisation est réalisée par l'intermédiaire d'un processus qui isole les éléments de la plateforme matérielle et qui offre un moyen d'exécuter des programmes ou environnements complets en parfaite isolation les uns des autres. Chaque container partage les ressources de la machine hôte pour plus de performances que ne peuvent en donner des VM.

Il se base sur un daemon (sous linux) utilisant les namespaces et les cgroups (Control Groups) de linux pour réaliser cette isolation et offrir le maximum de performances à l'ensemble des containers installés sur la machine.

Les control groups permettent de limiter les ressources utilisées par un processus : RAM, IO, Network, CPU. On peut ainsi s'assurer qu'il n'y aura pas de débordement entre les processus que sont les containers.

Les Namespaces sont une façon de restreindre la vue des containers. En d'autres termes, le processus croit disposer de son propre réseau et de ses fichiers. Plusieurs namespaces existent, combinés par Docker pour le processus lancé. On retrouve :

Docker distingue principalement deux objets :

Plus loin dans le document vous trouverez les commandes principales à utiliser pour manipuler ces deux objets.

Un container Docker

Pour créer un container :

  1. Il faut écrire un fichier Dockerfile, au format YAML. Il contient toutes les instructions pour construire l'image.
  2. Le moteur Docker (Docker Engine) construit l'image en se basant sur le fichier Dockerfile
  3. Vous pouvez ensuite rendre publique cette image (si vous le voulez) en la poussant sur le site Docker Hub

Un container ne contient pas forcément une seule application. C'est même l'inverse qui est généralement rencontré : un serveur web + une application de base de données + une gestion d'API. Chaque partie ayant besoin de parler aux autres.

Pour mettre en place le contenu du DockerFile nous utilisons docker compose qui va lire le fichier DockerFile et créer ce que l'on appelle stack dans Docker.

Mais nous verrons ces éléments plus loin dans le document.

Installer Docker sur Ubuntu Serveur

Commencez par installer Ubuntu en mode serveur en ajoutant un utilisateur non root mais avec les privilèges sudo.

sudo usermod -aG docker <username>

Déconnectez votre session et reconnectez-vous pour valider l'appartenance au nouveau groupe. Si tout se passe bien, les prochaines commandes docker pourront s'exécuter sans les précéder de sudo (une fois l'installation réalisée bien évidemment).

Prévoyez également de disposer d'un compte sur le Docker Hub pour pouvoir pousser vos propres images.

Pour mettre en place Docker, suivre ce lien Docker sur Ubuntu. En voici les différentes étapes :

Mise en place du repository Docker pour Ubuntu

# Add Docker's official GPG key: sudo apt-get update sudo apt-get install ca-certificates curl gnupg sudo install -m 0755 -d /etc/apt/keyrings curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo gpg --dearmor -o /etc/apt/keyrings/docker.gpg sudo chmod a+r /etc/apt/keyrings/docker.gpg # Add the repository to Apt sources: echo \ "deb [arch="$(dpkg --print-architecture)" signed-by=/etc/apt/keyrings/docker.gpg] https://download.docker.com/linux/ubuntu \ "$(. /etc/os-release && echo "$VERSION_CODENAME")" stable" | \ sudo tee /etc/apt/sources.list.d/docker.list > /dev/null sudo apt-get update

Installation des packages Docker

sudo apt-get install docker-ce docker-ce-cli containerd.io docker-buildx-plugin docker-compose-plugin

Pour valider la bonne installation vérifiez l'état du service docker

sudo systemctl status docker

L'affichage devrait ressembler à ceci

● docker.service - Docker Application Container Engine Loaded: loaded (/usr/lib/systemd/system/docker.service; enabled; preset: enabled) Active: active (running) since Sun 2026-11-15 10:29:19 UTC; 29s ago TriggeredBy: ● docker.socket Docs: https://docs.docker.com Main PID: 99750 (dockerd) Tasks: 10 Memory: 31.1M (peak: 31.6M) CPU: 372ms CGroup: /system.slice/docker.service └─99750 /usr/bin/dockerd -H fd:// --containerd=/run/containerd/containerd.sock

L'autre option est de vérifier la version du service docker installé

sudo docker --version # Exemple de sortie selon la version actuelle Docker version 29.9.3, build 5457199

Enfin rien de mieux que d'exécuter le hello wrold façon docker en tirant une image depuis le Docker Hub

sudo docker run hello-world

Vous devriez obtenir un message de sortie vous montrant que, comme l'image HelloWorld n'existe pas, Docker la télécharge depuis le Docker Hub et vous affiche un message de bienvenue...

Unable to find image 'hello-world:latest' locally latest: Pulling from library/hello-world 4f55086f7dd0: Pull complete d5e71e642bf5: Download complete Digest: sha256:cf1b20a0c89a666b6950fecda7ccbc1b1a86520e7c53f908f3a21e79d0d60458 Status: Downloaded newer image for hello-world:latest Hello from Docker! This message shows that your installation appears to be working correctly.

Manipuler Docker

Gestion du service

Commandes de base

Quand on dit que l'on fait un pull d'une image, cela signifie que l'on va télécharger l'image du container depuis le Docker Hub ici https://hub.docker.com/. Comme l'image de nginx n'est pas présente sur le repository local, Docker va le télécharger.

latest: Pulling from library/nginx 6d2e43921e9e: Pull complete 37fb86c2a767: Pull complete 512ac5e7ce8e: Pull complete 1724c05f72c6: Pull complete bbb080c71d50: Pull complete 1962e1ff75b4: Pull complete 7cb4701ce7cd: Pull complete 4582dace95e2: Download complete d2c7e31f04a3: Download complete Digest: sha256:165ddde8751e75a1c907d24ef10d9f6deb08b57e0fe56caf67512486aff76d82 Status: Downloaded newer image for nginx:latest docker.io/library/nginx:latest

Affiche la liste des images téléchargées et disponibles pour générer des containers. On voit que nous avons deux images : la dernière version du hello-world, et l'image nginx qui est présente mais pas démarrée sous la forme d'un container.

i Info → U In Use IMAGE ID DISK USAGE CONTENT SIZE EXTRA hello-world:latest cf1b20a0c89a 25.9kB 9.49kB U nginx:latest 165ddde8751e 243MB 66.8MB

Exécute l'image de nginx:latest sous la forme d'un container. Quand Docker renvoie une valeur, celle-ci prend la forme d'un UID comme 9cf9fcbc45cee9fabab308b9033293131ea259fdcbbbb8ce5885b0bc78ea227b

Affiche l'état des containers qui sont actifs (option a), ou qui ont été récemment actifs (option -a).

CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES 9cf9fcbc45ce nginx:latest "/docker-entrypoint.…" 14 seconds ago Exited (0) 13 seconds ago gifted_morse 015e24308e7e hello-world "/hello" 3 hours ago Exited (0) 3 hours ago relaxed_easley

Si vous regardez bien, vous voyez que l'ID du container créé à partir de l'image nginx:latest correspond bien à la suite hexadécimale renvoyée lors de l'activation du container nginx:latest. On peut voir que les deux containers ne sont pas en exécution car le status est Exited.

Force l'arrêt d'un container en passant son ID en paramètre

Exécute une commande dans un container (ici c'est bash). Vous verrez que vous êtes passé en mode interactif (option -it) car votre prompt va changer pour refléter votre nouveau shell. INFO : sans SSH, l'utilisation d'exec est d'une grande aide.

docker exec -it 9cf9 bash user@9cf9fcbc45ce:/#

A partir de ce moment vous pouvez réaliser des commandes CLI classiques qui s'exécuteront sur le container directement.

Permet de voir quels sont les container actifs (ou ceux qui l'ont été en utilisant l'option -a)

CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES 9cf9fcbc45ce nginx:latest "/docker-entrypoint.…" 4 minutes ago Up 4 minutes 80/tcp vibrant_cerf

Supprime un container de la liste. Si l'opération de suppression du container réussit, Docker répond en affichant le container id fourni.

Supprime une ou plusieurs images.

Prenons l'exemple dans lequel nous avons ces images stockées sur notre disque

i Info → U In Use IMAGE ID DISK USAGE CONTENT SIZE EXTRA hello-world:latest cf1b20a0c89a 25.9kB 9.49kB U nginx:latest 165ddde8751e 243MB 66.8MB

Essayons de supprimer le container hello-world (ID : cf1b...).

docker image rm cf1b Error response from daemon: conflict: unable to delete cf1b20a0c89a (must be forced) - image is being used by stopped container 015e24308e7e

Nous ne pouvons pas supprimer directement l'image car elle est utilisée par un container inactif. Pour nous en assurer :

docker container ls -a CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES 015e24308e7e hello-world "/hello" 4 hours ago Exited (0) 4 hours ago relaxed_easley

Le container avec l'ID qui commence par 015e2 existe bien, est arrêté depuis 4 heures et correspond à l'image mentionnée au début du paragraphe. Pour supprimer l'image, il nous faut donc supprimer ce container inactif :

docker container rm 015 015

On peut donc maintenant supprimer cette image par

docker image rm cf1b Untagged: hello-world:latest Deleted: sha256:cf1b20a0c89a666b6950fecda7ccbc1b1a86520e7c53f908f3a21e79d0d60458

Exécuter des images

Exécute l'image sous la forme d'un container. L'option -d détache le conteneur de son processus parent pour le faire tourner comme un processus indépendant.

docker ps -a CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES e3949f6fd653 nginx:latest "/docker-entrypoint.…" About a minute ago Up About a minute 80/tcp loving_cannon

Exécute le container en mode interactif avec un processus bash. Vous récupérez alors un shell classique pour travailler dans le container.

Exécute la commande dans le container. Par exemple

docker exec 7eff uname -a Linux 7eff03e098b5 6.8.0-149-generic #149-Ubuntu SMP PREEMPT_DYNAMIC Fri Oct 23 13:21:10 UTC 2026 x86_64 GNU/Linux

Exécute le container nginx en lui donnant un nom personnalisé (webserver) et en effectuant une redirection du port 8080 pour le faire pointer vers le port 80 du container. Cela évitera des conflits si le port 80 local est déjà utilisé. Pour accéder au serveur web, utilisez simplement un navigateur situé sur le même LAN que le serveur Docker et utilisez l'URL http://docker-ip:8080

Récupère les statistiques d'usage des différents containers actifs, à la manière de la commande top de Linux.

CONTAINER ID NAME CPU % MEM USAGE / LIMIT MEM % NET I/O BLOCK I/O PIDS 68ae5031c93f webserver 0.00% 3.402MiB / 3.824GiB 0.09% 2.76kB / 2.54kB 0B / 24.6kB 3 7eff03e098b5 sleepy_mendel 0.00% 3.391MiB / 3.824GiB 0.09% 1.6kB / 126B 0B / 32.8kB 3

Stratégie de démarrage

Par défaut un container s'exécute et, sauf contre-ordre, s'arrête lorsque son activité est terminée. Ce comportement peut être modifié par l'option --restart en lui donnant l'une des valeurs suivantes :

Dans l'exemple ci-après un container Redis est exécuté et configuré pour redémarrer automatiquement à moins qu'il ne soit explicitement stoppé ou que Docker soit redémarré.

docker run -dit --restart unless-stopped redis

Pour démarrer, redémarrer ou arrêter un container, voici les commandes prévues (ici le container porte le nom de redis) :

docker start redis # démarrage docker restart redis # redémarrage docker stop redis # arrêt du container

Gestion des images

IMAGE CREATED CREATED BY SIZE COMMENT 165ddde8751e 10 days ago CMD ["nginx" "-g" "daemon off;"] 0B buildkit.dockerfile.v0 <missing> 10 days ago STOPSIGNAL SIGQUIT 0B buildkit.dockerfile.v0 <missing> 10 days ago EXPOSE map[80/tcp:{}] 0B buildkit.dockerfile.v0 <missing> 10 days ago ENTRYPOINT ["/docker-entrypoint.sh"] 0B buildkit.dockerfile.v0 <missing> 10 days ago COPY 30-tune-worker-processes.sh /docker-ent… 16.4kB buildkit.dockerfile.v0 <missing> 10 days ago COPY 20-envsubst-on-templates.sh /docker-ent… 12.3kB buildkit.dockerfile.v0 <missing> 10 days ago COPY 15-local-resolvers.envsh /docker-entryp… 12.3kB buildkit.dockerfile.v0 <missing> 10 days ago COPY 10-listen-on-ipv6-by-default.sh /docker… 12.3kB buildkit.dockerfile.v0 <missing> 10 days ago COPY docker-entrypoint.sh / # buildkit 8.19kB buildkit.dockerfile.v0 <missing> 10 days ago RUN /bin/sh -c set -x && groupadd --syst… 88.8MB buildkit.dockerfile.v0 <missing> 10 days ago ENV DYNPKG_RELEASE=1~trixie 0B buildkit.dockerfile.v0 <missing> 10 days ago ENV PKG_RELEASE=1~trixie 0B buildkit.dockerfile.v0 <missing> 10 days ago ENV ACME_VERSION=0.4.1 0B buildkit.dockerfile.v0 <missing> 10 days ago ENV NJS_RELEASE=1~trixie 0B buildkit.dockerfile.v0 <missing> 10 days ago ENV NJS_VERSION=1.0.2 0B buildkit.dockerfile.v0 <missing> 10 days ago ENV NGINX_VERSION=1.31.8 0B buildkit.dockerfile.v0 <missing> 10 days ago LABEL maintainer=NGINX Docker Maintainers <d… 0B buildkit.dockerfile.v0 <missing> 10 days ago # debian.sh --arch 'amd64' out/ 'trixie' '@1… 87.7MB debuerreotype 0.17

Rechercher des images

Il est possible d'effectuer des recherches d'images directement depuis le Docker Hub. Mais il est possible de faire une recherche également depuis docker directement avec

docker search centos NAME DESCRIPTION STARS OFFICIAL centos DEPRECATED; The official build of CentOS. 7780 [OK] dockette/centos 🐳 CentOS base images (legacy) 1 eclipse/centos CentOS based minimal stack with only git and… 1 corpusops/centos centos corpusops baseimage 0 centos/postgresql-10-centos7 PostgreSQL is an advanced Object-Relational … 21 centos/redis-5-centos8 0 centos/httpd-24-centos8 3 centos/mysql-80-centos8 0 centos/postgresql-10-centos8 0 centos/postgresql-12-centos8 0 centos/mongodb-36-centos7 MongoDB NoSQL database server 12 centos/nginx-112-centos7 Platform for running nginx 1.12 or building … 16 centos/mariadb-103-centos8 2 centos/systemd systemd enabled base container. 114 centos/mysql-57-centos7 MySQL 5.7 SQL database server 94 gmao/centos 0 centos/httpd-24-centos7 Platform for running Apache httpd 2.4 or bui… 46 centos/nginx-18-centos7 Platform for running nginx 1.8 or building n… 14 centos/postgresql-96-centos7 PostgreSQL is an advanced Object-Relational … 45 centos/mariadb-101-centos7 MariaDB 10.1 SQL database server 13 centos/python-35-centos7 Platform for building and running Python 3.5… 39 centos/ruby-22-centos7 Platform for building and running Ruby 2.2 a… 3 centos/redis-32-centos7 Redis in-memory data structure store, used a… 6 centos/nginx-114-centos8 0 centos/mysql-56-centos7 MySQL 5.6 SQL database server 23

Gestion des volumes

Par défaut, n'enregistrez rien dans les containers Docker. Ce n'est pas leur finalité. Ce sont des objets volatiles par principe et vous serez amenés à utiliser des containers qui vont évoluer et se modifier indépendamment de vos actions. Ils sont maintenus par des tiers et rien ne peut garantir que, dans leurs prochaines versions, ils seront toujours identiques.

Pour conserver des données, il faut utiliser des volumes qui eux vous appartiendront et seront stockés dans des emplacements que vous contrôlez. Ces volumes seront accessibles au container de manière transparente, en donnant simplement le chemin où le container doit aller chercher ce volume.

Pour créer un volume, il suffit de déclarer un répertoire sur le serveur docker et de le connecter au répertoire local qui est dans le container. Par exemple, si vous voulez connecter le répertoire /var/www/html de votre serveur Docker au dossier /usr/share/nginx/html, accessible par le container, alors l'appel sera

docker run -d --name webserver -p 8080:80 -v /var/www/html:/usr/share/nginx/html --restart=always nginx:latest

Gestion du réseau

Affiche les réseaux virtuels disponibles sur l'hôte Docker. Il y a par défaut 3 réseaux :

NETWORK ID NAME DRIVER SCOPE ecf3b22675e6 bridge bridge local 4a10dc30f042 host host local c9c90ac4a869 none null local

Renvoie la description du réseau sous la forme d'un fichier JSON.

Création d'un réseau de type bridge avec définition d'un subnet. C'est par ce réseau virtuel que vont dialoguer les différents containers, entre eux, ou pas.

docker network create -d bridge --subnet 10.10.10.0/24 mynet docker run -it -d --name web1 --network mynet nginx docker run -it -d --name web2 --network mynet nginx docker network inspect mynet

Dans cet exemple nous avons créé un réseau nommé mynet et exécuté deux containers à base de nginx, et connectés sur le réseau mynet. L'inspection du réseau montre que les deux serveurs nginx sont sur le même réseau en 10.10.10.2 et 10.10.10.3, la passerelle de ce réseau étant réservée en 10.10.10.1.

[ { "Name": "mynet", "Id": "85d15cab67a2be0baa59ff1aac4aea12c38551a16f46a4322319bd6498288170", "Created": "2026-11-21T16:38:07.142650984Z", "Scope": "local", "Driver": "bridge", "EnableIPv4": true, "EnableIPv6": false, "IPAM": { "Driver": "default", "Options": {}, "Config": [ { "Subnet": "10.10.10.0/24", "Gateway": "10.10.10.1" } ] }, "Internal": false, "Attachable": false, "Ingress": false, "ConfigFrom": { "Network": "" }, "ConfigOnly": false, "Options": {}, "Labels": {}, "Containers": { "4cb6cbd2f20da0ae540f880ae7e4bff1e549ad2f23194778d3b7c44d46dd0fa6": { "Name": "web1", "EndpointID": "e49ee558f20649e4d3223a188cd48834017593c72d464b344cb3ca2c7a65a7af", "MacAddress": "9a:f2:22:f7:e0:42", "IPv4Address": "10.10.10.2/24", "IPv6Address": "" }, "b98d7ea184b0b3ca413c8b9329d50771a292bf2cda8a37e1bce5c425a535a0de": { "Name": "web2", "EndpointID": "54b0253675ec284205631dbe7ff297413ce18639cdacf58d339918170bc9b9b4", "MacAddress": "02:1e:68:40:ae:89", "IPv4Address": "10.10.10.3/24", "IPv6Address": "" } }, "Status": { "IPAM": { "Subnets": { "10.10.10.0/24": { "IPsInUse": 5, "DynamicIPsAvailable": 251 } } } } } ]

Les serveurs peuvent maintenant communiquer, se pinguer, échanger des informations assez simplement.

Copier des fichiers Depuis/Vers un container

Une GUI pour Docker

Docker fonctionne, comme vous avez pu le voir, uniquement en mode console avec la CLI. Mais il y a une solution simple : installer le container nommé Portainer qui va simplifier la gestion des containers.

Créer un dossier portainer pour que Portainer puisse stocker ses éléments persistants et lancez la commande suivante :

docker run -d \ --name portainer \ -p 9000:9000 \ -p 9443:9443 \ -v /var/run/docker.sock:/var/run/docker.sock \ -v /docker/portainer:/data \ --restart=unless-stopped \ portainer/portainer-ce

Héberger son serveur Docker

Pour héberger des services Docker, il faudra préférentiellement disposer d'une IP publique statique, mais une IP dynamique peut convenir. Il faudra ensuite réaliser la redirection vers notre serveur auto-hébergé, les ports qui devront transiter sont les ports 80 et 443, à destination du serveur reverse proxy. C'est ce dernier qui permettra le challenge de Let's Encrypt.

Si on ne passe pas par l'automatisation offerte par le Reverse Proxy, ce sera l'outil Certbot qui sera utilisé pour la génération de certificats. Il est disponible ici : htps://certbot.eff.org. Certbot permet de créer le certificat initial mais également permet de renouveler automatiquement le certificat.

Il faudra juste préciser à CertBot pour quel type de site vous renouvelez le certificat : domaine, sous-domaine, wildcard...

Pour cela, les outils de vérification de certificats comme Let's Encrypt vont lancer des défis à votre site pour déterminer s'il est vraiment ce qu'il prétend être.

  1. Défi HTTP-01

Pour générer un certificat, il faudra que vous déposiez un token qui vous sera transmis par le service de génération de certificats. Ce sera sur l'arborescence correspond à http://votre-domaine/.well-known/acme-challenge/TOKEN

Comme ce défi communique avec un serveur en HTTP, il faut disposer d'un port 80 ouvert et disponible sur Internet pour que le challenge fonctionne.

Avec Let's Encrypt, c'est une fois tous les 3 mois mais ce n'est pas la panacée de laisser ce port 80 ouvert sans protection au monde entier.

  1. Défi DNS-01

Si vous disposez de votre propre nom de domaine et que vous gérez votre zone DNS, alors vous pouvez participer à ce défi qui vous demandera de poser une valeur spécifique dans un champ TXT.

C'est un challenge plus compliqué à mettre en place mais beaucoup sécurisé et surtout qui n'implique pas de devoir ouvrir un port HTTP sur votre routeur. Tout se passe du côté du serveur DNS, avec les temps de propagation à prendre en compte dans ce cas.

  1. Autres défis

Il existe d'autres modes d'authentification des sites et services par SSL comme TLS-SNI-01 ou TLS-ALPN-01 mais ce sont des processus récents mal pris en compte par l'ensemble des navigateurs et services de certificats.

Installer Nginx Proxy Manager sous Docker

Nginx Proxy Manager est un reverse proxy, disponible au format Docker. Il dispose d'une intégration avec Let's Encrypt, ce qui est toujours intéressant pour sécuriser nos accès.

Sur Portainer, créer une nouvelle Stack pour coller le docker compose suivant :

version: '3' services: nginx: image: 'jc21/nginx-proxy-manager:latest' container_name: nginx ports: - '80:80' # ne pas modifier - '81:81' - '443:443' # ne pas modifier restart: unless-stopped environment: DB_MYSQL_HOST: "db" DB_MYSQL_PORT: 3306 DB_MYSQL_USER: "utilisateur" # à modifier DB_MYSQL_PASSWORD: "mdp" # à modifier DB_MYSQL_NAME: "nginx" volumes: - /srv/docker/nginx-proxy-manager/data:/data - /srv/docker/nginx-proxy-manager/letsencrypt:/etc/letsencrypt depends_on: - db db: image: 'jc21/mariadb-aria:latest' container_name: nginx-db restart: unless-stopped environment: MYSQL_ROOT_PASSWORD: 'npm' # à modifier MYSQL_DATABASE: 'nginx' MYSQL_USER: 'utilisateur' # à modifier MYSQL_PASSWORD: 'mdp' # à modifier volumes: - /srv/docker/nginx-proxy-manager/mysql:/var/lib/mysql

Un peu plus bas sur la page, cliquer sur le bouton Deploy the stack.

Une fois la stack déployée vous pourrez vous connecter à nginx proxy manager sur le port 81. Lors de l'installation, les identifiants par défaut sont admin@example.com et changeme. A la connexion, il vous sera demandé de créer une nouvelle identité et de changer le mot de passe par défaut.

Docker pour les DevOps

docker build -t &lt;tag_identifier&gt; .

Sur la base d'un fichier Dockerfile, construit une image qui pourra ensuite être déployée par un container. On identifie le build par un tag pour le retrouver. L'utilisation du '.' n'est pas une erreur. C'est le dossier qui va être transformé en image docker.

docker logs &lt;container_id&gt;

Affiche les logs du container dont l'id est donné.

docker save -o backup.tar myimage

La commande précédente effectue un backup de l'image dont l'ID est donné. Par défaut, la sortie est faite sur STDOUT. L'utilisation de l'option -o permet de rediriger le flux dans le fichier nommé.

docker load < backup.tar

Restaure l'image depuis un backup

docker export -o app_fs.tar app

Exporte le système de fichier du container.

docker system df TYPE TOTAL ACTIVE SIZE RECLAIMABLE Images 1 1 243.4MB 0B (0%) Containers 6 4 434.2kB 90.11kB (20%) Local Volumes 0 0 0B 0B Build Cache 0 0 0B 0B

Affiche l'utilisation du stockage dans Docker

docker system info Client: Docker Engine - Community Version: 29.9.3 Context: default Debug Mode: false Plugins: buildx: Docker Buildx (Docker Inc.) Version: v0.39.0 Path: /usr/libexec/docker/cli-plugins/docker-buildx compose: Docker Compose (Docker Inc.) Version: v5.7.1 Path: /usr/libexec/docker/cli-plugins/docker-compose model: Docker Model Runner (Docker Inc.) Version: v1.2.9 Path: /usr/libexec/docker/cli-plugins/docker-model Server: Containers: 6 Running: 4 Paused: 0 Stopped: 2 Images: 1 Server Version: 29.9.3 Storage Driver: overlayfs driver-type: io.containerd.snapshotter.v1 Logging Driver: json-file Cgroup Driver: systemd Cgroup Version: 2 Plugins: Volume: local Network: bridge host ipvlan macvlan null overlay Log: awslogs fluentd gcplogs gelf journald json-file local splunk syslog CDI spec directories: /etc/cdi /var/run/cdi Swarm: inactive Runtimes: io.containerd.runc.v2 runc Default Runtime: runc Init Binary: docker-init containerd version: b7a25261e029d68978bbf290df0a62fc819b3c51 runc version: v1.5.3-0-g46365c62 init version: de40ad0 Security Options: apparmor Profile: default seccomp Profile: builtin cgroupns Kernel Version: 6.8.0-149-generic Operating System: Ubuntu 24.04.5 LTS OSType: linux Architecture: x86_64 CPUs: 2 Total Memory: 3.824GiB Name: docker02 ID: 891779a5-eec5-4a34-bfd1-0dfc30f4c7d2 Docker Root Dir: /var/lib/docker Debug Mode: false Experimental: false Insecure Registries: 127.0.0.0/8 ::1/128 Live Restore Enabled: false Firewall Backend: iptables EnableUserlandProxy: true UserlandProxyPath: /usr/bin/docker-proxy

Affiche les informations relatives au système qui héberge Docker.

La gestion du stockage dans Docker

Par défaut, les containers Docker sont éphémères, i.e. une fois que le container est supprimé, les données qu'il contient le sont également. Pour résoudre ce problème de persistence de données, Docker utilise des Volumes externes au container, ainsi que des points de montage du système de fichiers, qui seront rattachés au container si jamais celui-ci est restauré ou mis à jour.

Docker Bind Mount

La gestion des Volumes dans Docker

Les volumes Docker sont des répertoires gérés directement par Docker. Ils sont stockés sur la machine hôte et montés dans les containers. Par défaut, le montage est dans /var/lib/docker/volumes

Les avantages de la gestion des volumes par Docker :

Imaginons que nous ayons un fichier Dockerfile incluant cette définition de volumes :

volumes: - mysql_data:/var/lib/mysql

Docker Volumes

Dans une commande Docker, le volume se déclare avec l'option -v

docker run --name=mysql -p 3030:3306 -v myvol1:/var/lib/mysql -d mysql:5.7

Docker Volume Explanations

Le montage dans Docker

Docker Bind Mount

Un point de montage va mapper un dossier de l'höte Docker directement dans un container. Cela permet :

Volumes vs Bind Mounts

Utiliser les Volumes Docker quand :

Les points de montage (Bind Mounts) sont plutôt :