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.
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.
Pour créer un container :
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.
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.
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é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
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
docker image build - Créé une image depuis un fichier DockerFile
docker image history ID - Affiche l'historique d'une image
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
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
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
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.
docker cp file.txt container:/path/
docker cp container:/path/file.txt .
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
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.
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.
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.
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.
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 build -t <tag_identifier> .
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 <container_id>
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.
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.

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

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


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

Utiliser les Volumes Docker quand :
Les points de montage (Bind Mounts) sont plutôt :