Installation de Docker Engine (Linux)

Méthodes d'installation de Docker Engine sur Linux

L'installation de Docker Engine sur Linux peut être réalisée selon plusieurs approches, chacune présentant des avantages spécifiques selon votre contexte d'utilisation. La méthode privilégiée et recommandée par Docker consiste à utiliser les dépôts officiels maintenus par Docker Inc. Cette approche garantit l'accès aux versions les plus récentes de Docker Engine et simplifie considérablement les futures mises à jour. Docker fournit des dépôts pour les principales distributions Linux, notamment Ubuntu, Debian, Fedora, CentOS et RHEL, assurant ainsi une compatibilité et une stabilité optimales pour ces environnements.

Une alternative consiste à utiliser les packages fournis par les distributions Linux elles-mêmes via leurs dépôts natifs. Bien que cette méthode soit simple et intégrée nativement à votre système, elle présente l'inconvénient majeur de proposer généralement des versions plus anciennes de Docker. Dans certains environnements d'entreprise soumis à des politiques strictes de gestion des logiciels ou dans des situations où la stabilité prime sur les fonctionnalités récentes, cette approche peut néanmoins se révéler préférable. Il est important de noter que le package disponible dans les dépôts natifs s'appelle souvent simplement « docker » et non « docker-ce » (Community Edition), et peut présenter des différences de configuration avec la version officielle.

L'installation manuelle via des packages binaires téléchargés directement depuis le site officiel de Docker représente une troisième option, particulièrement utile dans les environnements sans accès à Internet ou soumis à des restrictions réseau strictes. Cette méthode, bien que plus complexe, offre un contrôle total sur le processus d'installation et s'avère précieuse dans des scénarios d'air-gap (réseaux isolés) ou pour des déploiements automatisés à grande échelle. L'installation manuelle nécessite de télécharger les packages .deb ou .rpm appropriés, puis de les installer avec les outils de gestion de paquets de votre distribution (dpkg ou rpm).

Le script d'installation automatisé fourni par Docker constitue une solution de compromis intéressante, alliant simplicité et accès aux versions récentes. Accessible via la commande curl -fsSL https://get.docker.com -o get-docker.sh suivie de sh get-docker.sh, ce script détecte automatiquement votre distribution, configure les dépôts nécessaires et installe la dernière version stable de Docker Engine. Bien que pratique pour des environnements de développement ou de test, cette méthode n'est généralement pas recommandée pour les déploiements de production, car elle délègue le contrôle du processus d'installation à un script externe, ce qui peut soulever des préoccupations de sécurité et de gouvernance dans des environnements professionnels.

Pour les distributions Linux plus spécialisées ou moins courantes comme Alpine Linux, Arch Linux ou Gentoo, des instructions spécifiques sont généralement disponibles dans la documentation de la distribution. Ces environnements nécessitent souvent une approche plus personnalisée, exploitant les gestionnaires de paquets spécifiques comme apk pour Alpine, pacman pour Arch ou portage pour Gentoo. Dans ces cas, la consultation de la documentation officielle de la distribution constitue la meilleure source d'information pour une installation correctement intégrée à l'écosystème de votre système.

Installation sur Ubuntu et Debian

L'installation de Docker Engine sur Ubuntu commence par la configuration du dépôt officiel de Docker. Initialement, vous devez installer les packages permettant à apt d'utiliser des dépôts via HTTPS et d'autres outils nécessaires. Exécutez la commande suivante : sudo apt-get update && sudo apt-get install ca-certificates curl gnupg lsb-release. Ces packages fournissent les certificats d'autorité, les outils de téléchargement et de vérification cryptographique nécessaires pour sécuriser l'ajout du dépôt Docker.

L'étape suivante consiste à ajouter la clé GPG officielle de Docker, qui permet de vérifier l'authenticité des packages téléchargés. Cette vérification cryptographique est cruciale pour garantir l'intégrité et la provenance des logiciels installés. Exécutez les commandes :

sudo mkdir -p /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

Configurez ensuite le dépôt Docker en créant un fichier de source pour apt. Utilisez la commande suivante, qui détecte automatiquement votre version d'Ubuntu et configure le dépôt approprié :

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

Après avoir configuré le dépôt, mettez à jour la base de données des packages apt et installez Docker Engine, le client CLI, containerd et Docker Compose : sudo apt-get update && sudo apt-get install docker-ce docker-ce-cli containerd.io docker-compose-plugin. Cette commande installe la dernière version stable de Docker. Si vous souhaitez installer une version spécifique, listez d'abord les versions disponibles avec apt-cache madison docker-ce, puis spécifiez la version lors de l'installation, par exemple : sudo apt-get install docker-ce=5:20.10.16~3-0~ubuntu-jammy.

Pour vérifier que l'installation s'est déroulée correctement, exécutez l'image hello-world : sudo docker run hello-world. Ce conteneur minimal télécharge une image de test depuis Docker Hub, l'exécute, affiche un message de confirmation, puis se termine. Si vous voyez le message "Hello from Docker!", cela confirme que votre installation fonctionne correctement. Dans le cas contraire, vérifiez les messages d'erreur qui peuvent fournir des indications sur la cause du problème, généralement liée aux droits d'accès, à la configuration réseau ou au service Docker qui n'est pas démarré.

Sur les systèmes basés sur Debian comme Ubuntu, Docker Engine est configuré pour démarrer automatiquement au boot via systemd. Vous pouvez vérifier l'état du service avec sudo systemctl status docker. Si nécessaire, vous pouvez contrôler manuellement le service avec les commandes standard systemd : sudo systemctl start docker pour démarrer, sudo systemctl stop docker pour arrêter, ou sudo systemctl restart docker pour redémarrer le service après des modifications de configuration.

Installation sur CentOS, RHEL et Fedora

L'installation de Docker Engine sur les distributions basées sur Red Hat comme CentOS, RHEL et Fedora suit une approche similaire à celle d'Ubuntu, mais utilise les outils spécifiques à ces systèmes. Commencez par installer le package yum-utils qui fournit la commande yum-config-manager, utile pour configurer les dépôts : sudo yum install -y yum-utils. Sur les systèmes plus récents utilisant DNF comme gestionnaire de paquets (Fedora récent ou RHEL 8+), la commande reste identique car DNF maintient la compatibilité avec les commandes yum.

Ajoutez ensuite le dépôt officiel Docker à votre système. Pour CentOS ou RHEL, utilisez : sudo yum-config-manager --add-repo https://download.docker.com/linux/centos/docker-ce.repo. Pour Fedora, la commande est légèrement différente : sudo yum-config-manager --add-repo https://download.docker.com/linux/fedora/docker-ce.repo. Cette étape configure votre gestionnaire de paquets pour accéder aux packages Docker officiels, assurant l'installation des versions maintenues directement par Docker Inc.

Avant de procéder à l'installation, vous devrez peut-être gérer des conflits potentiels avec des versions antérieures de Docker. Si votre système possède déjà des packages comme docker ou docker-engine installés depuis les dépôts de la distribution, supprimez-les pour éviter des incompatibilités : sudo yum remove docker docker-client docker-client-latest docker-common docker-latest docker-latest-logrotate docker-logrotate docker-engine podman runc. Cette commande n'affecte pas les images, conteneurs ou volumes existants, qui sont préservés dans /var/lib/docker.

Installez maintenant Docker Engine, le client CLI, containerd et Docker Compose avec : sudo yum install docker-ce docker-ce-cli containerd.io docker-compose-plugin. Si plusieurs versions sont disponibles, yum installera la plus récente par défaut. Pour installer une version spécifique, listez d'abord les versions disponibles avec yum list docker-ce --showduplicates | sort -r, puis spécifiez la version exacte dans la commande d'installation, par exemple : sudo yum install docker-ce-20.10.16 docker-ce-cli-20.10.16 containerd.io docker-compose-plugin.

Contrairement à Ubuntu, Docker n'est pas automatiquement démarré après l'installation sur CentOS, RHEL ou Fedora. Vous devez explicitement démarrer le service et le configurer pour qu'il se lance au démarrage : sudo systemctl start docker et sudo systemctl enable docker. La commande enable configure systemd pour démarrer Docker automatiquement à chaque redémarrage du système, une étape essentielle pour les environnements de production.

Pour vérifier l'installation, exécutez comme sur Ubuntu l'image hello-world : sudo docker run hello-world. Si des problèmes surviennent, consultez les journaux système pour plus d'informations : sudo journalctl -u docker. Les erreurs courantes sur les systèmes RHEL/CentOS incluent les conflits avec SELinux ou les pare-feu. Si nécessaire, vous pouvez temporairement désactiver SELinux pour tester avec sudo setenforce 0, mais une configuration correcte maintenant SELinux activé est recommandée pour les environnements de production.

Installations spécifiques pour autres distributions Linux

L'installation de Docker sur Alpine Linux, une distribution minimale particulièrement populaire dans l'écosystème des conteneurs, suit une approche plus directe grâce à son gestionnaire de paquets apk. Commencez par mettre à jour l'index des paquets avec apk update, puis installez Docker via apk add docker. Cette simplicité apparente cache toutefois certaines particularités : par défaut, Alpine utilise OpenRC comme système d'init plutôt que systemd. Pour démarrer Docker et l'activer au démarrage, utilisez rc-service docker start et rc-update add docker boot. Alpine étant souvent utilisé comme base pour les conteneurs eux-mêmes, l'installation de Docker à l'intérieur d'un conteneur Alpine nécessite des considérations supplémentaires concernant les privilèges et l'accès aux fonctionnalités système.

Arch Linux et ses dérivés comme Manjaro offrent Docker via leurs dépôts communautaires. L'installation s'effectue simplement avec sudo pacman -S docker. Une particularité d'Arch est sa philosophie de mise à jour continue (rolling release), ce qui signifie que vous aurez généralement accès aux versions très récentes de Docker sans configuration spéciale. Après l'installation, activez et démarrez le service avec systemd : sudo systemctl enable docker et sudo systemctl start docker. La communauté Arch maintient une documentation détaillée dans l'ArchWiki qui couvre les subtilités spécifiques à cette distribution, notamment concernant les configurations avancées de stockage ou de réseau.

Les distributions immutables comme Fedora CoreOS, Flatcar Container Linux (anciennement CoreOS), ou Bottlerocket AWS présentent une philosophie distincte, étant spécifiquement conçues pour exécuter des conteneurs. Docker y est souvent préinstallé ou disponible via des mécanismes spécialisés. Par exemple, sur Fedora CoreOS, vous utiliseriez des configurations Ignition pour personnaliser l'installation plutôt que d'installer manuellement des packages. Ces systèmes privilégient les mises à jour atomiques et les déploiements déclaratifs, s'alignant parfaitement avec la philosophie DevOps et l'infrastructure comme code. Leur adoption nécessite une compréhension différente de la gestion du cycle de vie des systèmes, mais offre des avantages significatifs en termes de sécurité et de cohérence.

Les environnements cloud Linux comme Amazon Linux 2, Google Compute Engine OS ou Azure Linux nécessitent parfois des considérations spécifiques. Ces distributions optimisées pour leurs plateformes respectives peuvent inclure des versions personnalisées de Docker ou des intégrations spéciales avec les services cloud natifs. Par exemple, Amazon Linux 2 propose Docker via amazon-linux-extras : sudo amazon-linux-extras install docker. Il est généralement recommandé de suivre les guides spécifiques fournis par le fournisseur cloud pour ces environnements, car ils intègrent souvent des optimisations de performance et des configurations de sécurité adaptées à leur infrastructure.

Pour les distributions basées sur Gentoo, qui utilisent un système de paquets sources (portage), l'installation de Docker implique la compilation depuis les sources avec des options personnalisables. Utilisez emerge --ask app-containers/docker pour installer Docker. Cette approche, bien que plus complexe, offre un niveau de personnalisation inégalé, permettant d'optimiser la construction pour votre matériel spécifique ou d'inclure/exclure certaines fonctionnalités selon vos besoins. Comme Gentoo est une distribution hautement personnalisable, consultez la documentation officielle pour les configurations spécifiques, notamment concernant les options USE flags qui contrôlent les fonctionnalités compilées.

Dans les environnements hautement contraints ou spécialisés comme les systèmes embarqués Linux, vous pourriez avoir besoin de compiler Docker depuis les sources. Cette approche avancée commence par cloner le dépôt GitHub officiel, puis à suivre les instructions de compilation. Elle n'est recommandée que pour les utilisateurs expérimentés ayant des besoins très spécifiques ou travaillant sur des architectures non standard. La compilation depuis les sources vous donne un contrôle total sur les fonctionnalités incluses, les optimisations de compilation et la compatibilité avec des environnements atypiques, mais au prix d'une complexité significativement accrue et d'une maintenance plus exigeante.

Configuration post-installation essentielle

La gestion des permissions constitue une étape cruciale post-installation pour permettre aux utilisateurs non-root d'exécuter des commandes Docker sans préfixe sudo. Par défaut, le démon Docker s'exécute avec les privilèges root et le socket Unix Docker est accessible uniquement par l'utilisateur root et les membres du groupe docker. Pour ajouter votre utilisateur à ce groupe, exécutez : sudo usermod -aG docker $USER. Cette modification ne prendra effet qu'après vous être déconnecté puis reconnecté, ou après avoir exécuté newgrp docker pour actualiser votre session courante. Il est important de comprendre les implications de sécurité de cette configuration : les membres du groupe docker peuvent effectuer des actions équivalentes à root sur le système hôte via certaines manipulations de conteneurs privilégiés.

La configuration du démarrage automatique de Docker au boot système varie selon le système d'init utilisé par votre distribution. Pour les systèmes utilisant systemd (la majorité des distributions modernes comme Ubuntu, Debian récent, CentOS 7+, Fedora), utilisez sudo systemctl enable docker. Pour les systèmes basés sur System V init, la commande serait sudo chkconfig docker on. Les distributions utilisant OpenRC comme Alpine Linux nécessitent sudo rc-update add docker default. Vérifiez que la configuration a réussi en redémarrant votre système et en confirmant que Docker démarre automatiquement avec docker info ou systemctl status docker.

L'ajustement des paramètres du démon Docker permet d'optimiser son fonctionnement selon vos besoins spécifiques. Ces configurations s'effectuent via le fichier /etc/docker/daemon.json, qu'il faut généralement créer car il n'existe pas par défaut. Par exemple, pour modifier le driver de stockage et définir son emplacement, vous pourriez créer un fichier avec le contenu suivant :

{"storage-driver": "overlay2", "data-root": "/mnt/docker-data"}

La configuration réseau post-installation peut nécessiter des ajustements, particulièrement dans des environnements d'entreprise utilisant des proxys. Si votre système se trouve derrière un proxy HTTP/HTTPS, vous devez configurer Docker pour l'utiliser. Créez ou modifiez le fichier /etc/systemd/system/docker.service.d/http-proxy.conf avec le contenu suivant :

[Service]
Environment="HTTP_PROXY=http://proxy.example.com:8080/"
Environment="HTTPS_PROXY=http://proxy.example.com:8080/"
Environment="NO_PROXY=localhost,127.0.0.1,docker-registry.example.com,.corp"

L'optimisation des limites de ressources système constitue une étape souvent négligée mais importante pour les environnements de production. Docker peut rapidement atteindre les limites par défaut du nombre maximum de fichiers ouverts (nofile) ou de processus (nproc). Augmentez ces limites en créant un fichier /etc/security/limits.d/docker.conf avec :

* soft nofile 1048576
* hard nofile 1048576
root soft nofile 1048576
root hard nofile 1048576
* soft nproc 1048576
* hard nproc 1048576
root soft nproc 1048576
root hard nproc 1048576

L'installation d'outils complémentaires améliore significativement l'expérience d'utilisation de Docker. Docker Compose, bien qu'inclus par défaut dans les installations récentes via le plugin Compose, peut nécessiter une installation séparée sur certains systèmes. Le client ctop (https://github.com/bcicen/ctop) offre une interface interactive pour surveiller les performances des conteneurs en temps réel. Lazydocker fournit une interface TUI (Text User Interface) complète pour gérer Docker. Portainer propose une interface web de gestion Docker légère et puissante, facilement déployable en tant que conteneur. Ces outils facilitent considérablement la gestion quotidienne de vos environnements Docker, particulièrement pour les administrateurs préférant des interfaces plus riches que la ligne de commande.

Vérification et validation de l'installation

La vérification de l'installation Docker commence par l'exécution du conteneur hello-world, un test simple mais efficace pour confirmer le bon fonctionnement de votre environnement Docker : docker run hello-world. Ce test valide plusieurs aspects cruciaux : la capacité du client Docker à communiquer avec le démon, l'aptitude du démon à télécharger une image depuis Docker Hub, la possibilité de créer un conteneur à partir de cette image et de l'exécuter, et finalement la capacité du conteneur à communiquer sa sortie vers votre terminal. Si l'une de ces étapes échoue, le message d'erreur obtenu fournira des indices précieux sur la nature du problème.

L'examen détaillé de la configuration système Docker s'effectue via la commande docker info, qui affiche une mine d'informations sur votre installation : version du client et du serveur, configuration du stockage, pilote de stockage utilisé, nombre d'images et de conteneurs, paramètres réseau, et diverses autres informations relatives à l'état général du système. Cette commande est particulièrement utile pour vérifier que les paramètres configurés dans daemon.json sont correctement appliqués. Examinez notamment les sections concernant le driver de stockage, le répertoire racine des données, et les paramètres de logging pour confirmer que vos personnalisations ont été prises en compte.

La validation des capacités réseau Docker représente une étape essentielle, particulièrement dans des environnements dotés de configurations réseau complexes ou restrictives. Exécutez un conteneur simple avec accès réseau : docker run --rm alpine ping -c 4 google.com. Ce test vérifie que vos conteneurs peuvent résoudre les noms de domaine et accéder à Internet. En cas d'échec, vérifiez les paramètres DNS dans votre configuration Docker et les règles de pare-feu de votre système. Pour tester la connectivité interne entre conteneurs, créez un réseau dédié et lancez deux conteneurs qui communiquent entre eux :

docker network create test-net
docker run -d --name nginx --network test-net nginx
docker run --rm --network test-net alpine ping -c 4 nginx

La vérification des performances de base permet d'identifier d'éventuels goulots d'étranglement avant de déployer des applications réelles. Le benchmark disque constitue un test particulièrement pertinent, car les performances du sous-système de stockage impactent directement la vitesse des opérations Docker : docker run --rm -v /var/lib/docker:/var/lib/docker alpine sh -c "dd if=/dev/zero of=/var/lib/docker/tempfile bs=1M count=1024 oflag=direct". Ce test écrit un fichier de 1 Go directement dans le répertoire de données Docker, mesurant la vitesse d'écriture brute. De même, testez les performances réseau entre conteneurs avec des outils comme iperf, et les capacités CPU avec des benchmarks comme sysbench, tous disponibles sous forme de conteneurs Docker.

L'analyse des journaux système après l'installation permet d'identifier des problèmes potentiels non apparents lors des tests basiques. Examinez les logs du démon Docker avec sudo journalctl -u docker sur les systèmes utilisant systemd, ou consultez /var/log/docker.log sur d'autres distributions. Recherchez particulièrement les messages d'erreur ou d'avertissement concernant des problèmes de configuration, des conflits de pilote de stockage, ou des échecs de montage. Ces journaux fournissent souvent des informations précieuses sur des problèmes subtils qui pourraient affecter la stabilité à long terme de votre installation Docker.

La vérification des permissions et des aspects de sécurité constitue une étape souvent négligée mais cruciale. Confirmez que seuls les utilisateurs autorisés appartiennent au groupe docker : getent group docker. Vérifiez les permissions du socket Docker avec ls -la /var/run/docker.sock, qui devrait montrer des permissions 660 (lecture/écriture pour le propriétaire et le groupe). Testez qu'un utilisateur non-root membre du groupe docker peut exécuter des commandes Docker sans sudo. Enfin, exécutez Docker Bench Security, un outil qui analyse votre installation Docker par rapport aux recommandations de sécurité CIS : docker run --net host --pid host --userns host --cap-add audit_control -v /var/lib:/var/lib -v /var/run/docker.sock:/var/run/docker.sock -v /etc:/etc --label docker_bench_security docker/docker-bench-security

Dépannage des problèmes d'installation courants

Les problèmes de permissions constituent l'une des difficultés les plus fréquemment rencontrées après l'installation de Docker sur Linux. Si vous obtenez des erreurs du type "permission denied while trying to connect to the Docker daemon socket", c'est généralement parce que votre utilisateur n'appartient pas au groupe docker ou que les changements de groupe n'ont pas encore été appliqués à votre session. Vérifiez votre appartenance au groupe avec groups, et si docker n'apparaît pas dans la liste, exécutez sudo usermod -aG docker $USER puis déconnectez-vous et reconnectez-vous complètement (un simple redémarrage de terminal n'est pas suffisant). Si le problème persiste, vérifiez les permissions du socket avec ls -la /var/run/docker.sock et corrigez-les si nécessaire avec sudo chmod 660 /var/run/docker.sock.

Les conflits de réseau représentent une autre catégorie courante de problèmes. Docker crée par défaut un réseau bridge (généralement 172.17.0.0/16) qui peut entrer en conflit avec des réseaux existants dans votre infrastructure. Si vous rencontrez des problèmes de connectivité ou si des conteneurs ne peuvent pas communiquer avec certains réseaux externes, vérifiez s'il existe un chevauchement d'adresses IP. Modifiez la plage d'adresses utilisée par Docker en créant ou modifiant /etc/docker/daemon.json :

{"bip": "192.168.100.1/24"}

Les problèmes de pilote de stockage peuvent se manifester par des erreurs lors de la création de conteneurs ou par des performances dégradées. Docker utilise par défaut le pilote overlay2, qui est recommandé pour la plupart des installations modernes. Cependant, sur certains systèmes plus anciens ou avec des configurations de noyau particulières, ce pilote peut ne pas fonctionner correctement. Vérifiez le pilote actuellement utilisé avec docker info | grep "Storage Driver". Si vous constatez des problèmes, vous pouvez essayer un pilote alternatif comme devicemapper en mode direct-lvm (recommandé pour les performances de production) ou aufs (sur les noyaux plus anciens). Configurez le pilote dans /etc/docker/daemon.json :

{"storage-driver": "devicemapper", "storage-opts": ["dm.directlvm_device=/dev/xvdf", "dm.thinp_percent=95", "dm.thinp_metapercent=1", "dm.thinp_autoextend_threshold=80", "dm.thinp_autoextend_percent=20"]}

Les erreurs liées aux modules noyau manquants peuvent bloquer complètement le démarrage du service Docker. Docker nécessite plusieurs fonctionnalités du noyau Linux, notamment le support des namespaces, cgroups, et des dispositifs de réseau comme le bridge et l'iptables. Si le démon Docker échoue au démarrage avec des messages concernant des fonctionnalités manquantes, vérifiez que votre noyau est suffisamment récent (minimum recommandé : 3.10, idéalement 4.x+) et que les modules nécessaires sont chargés. Exécutez lsmod | grep overlay et lsmod | grep br_netfilter pour vérifier que ces modules essentiels sont chargés. Vous pouvez les charger manuellement avec sudo modprobe overlay et sudo modprobe br_netfilter, puis les ajouter à /etc/modules-load.d/docker.conf pour qu'ils se chargent automatiquement au démarrage.

Les problèmes de DNS constituent une source fréquente de frustration après une installation réussie de Docker. Si vos conteneurs peuvent démarrer mais ne parviennent pas à résoudre les noms de domaine, plusieurs aspects sont à vérifier. D'abord, examinez le fichier /etc/resolv.conf de l'hôte pour confirmer que la résolution de noms fonctionne correctement au niveau du système. Ensuite, vérifiez la configuration DNS de Docker dans /etc/docker/daemon.json :

{"dns": ["8.8.8.8", "8.8.4.4"]}

Les problèmes de proxy HTTP peuvent compliquer l'accès à Docker Hub ou à d'autres registres. Dans les environnements d'entreprise utilisant des proxys, Docker nécessite une configuration spécifique. Créez ou modifiez le fichier /etc/systemd/system/docker.service.d/http-proxy.conf avec le contenu approprié :

[Service]
Environment="HTTP_PROXY=http://proxy.example.com:8080/"
Environment="HTTPS_PROXY=http://proxy.example.com:8080/"
Environment="NO_PROXY=localhost,127.0.0.1,.company.local"

Optimisation des performances post-installation

L'optimisation du sous-système de stockage constitue l'un des ajustements les plus impactants pour améliorer les performances de Docker. Le choix et la configuration du pilote de stockage influencent directement les performances des opérations d'entrée/sortie des conteneurs. Pour la plupart des distributions Linux modernes, overlay2 offre le meilleur équilibre entre performance et fonctionnalités. Sur des systèmes de production critiques, envisagez d'utiliser un volume groupe LVM dédié pour Docker avec le pilote devicemapper configuré en mode direct-lvm :

sudo pvcreate /dev/xvdf
sudo vgcreate docker /dev/xvdf
sudo lvcreate --wipesignatures y -n thinpool -l 95%VG docker
sudo lvcreate --wipesignatures y -n thinpoolmeta -l 1%VG docker

La gestion de la mémoire et des limites de ressources système joue un rôle crucial dans les performances de Docker, particulièrement dans les environnements exécutant de nombreux conteneurs. Par défaut, les conteneurs peuvent consommer autant de mémoire que disponible sur le système hôte, ce qui peut conduire à des situations d'épuisement de ressources (OOM - Out Of Memory). Configurez des limites par défaut dans /etc/docker/daemon.json :

{"default-shm-size": "64M", "default-ulimits": {"nofile": {"Name": "nofile", "Hard": 64000, "Soft": 64000}}, "default-shm-size": "64M"}

fs.file-max=2097152
net.ipv4.ip_forward=1
net.ipv4.tcp_max_syn_backlog=2048
net.core.somaxconn=4096

L'optimisation des performances réseau représente un aspect souvent négligé mais crucial pour les environnements Docker à haute charge. Par défaut, Docker utilise le driver bridge qui, bien que fonctionnel, n'est pas toujours optimal pour les environnements de production à forte charge. Pour les déploiements sur un seul hôte, considérez l'utilisation du mode réseau host (--network host) qui offre des performances supérieures en évitant la translation d'adresse réseau, bien qu'au prix d'un isolement réduit. Pour les déploiements multi-hôtes, évaluez des solutions comme Calico ou Weave qui offrent de meilleures performances et des fonctionnalités avancées de routage et de sécurité. Ajustez également les paramètres réseau du noyau pour optimiser les performances TCP/IP :

net.core.wmem_max=12582912
net.core.rmem_max=12582912
net.ipv4.tcp_rmem= 10240 87380 12582912
net.ipv4.tcp_wmem= 10240 87380 12582912

La mise en cache des images Docker peut considérablement améliorer les temps de déploiement, particulièrement dans les environnements de développement ou les clusters à haute disponibilité. Par défaut, Docker stocke les images dans /var/lib/docker, ce qui peut rapidement saturer la partition racine sur certaines configurations. Envisagez de déplacer le répertoire de données Docker vers un volume dédié avec plus d'espace :

{"data-root": "/path/to/docker-data"}

{"registry-mirrors": ["http://mycorporate-mirror-host:5000"]}

L'optimisation des journaux système constitue une considération importante pour les déploiements à long terme. Par défaut, Docker utilise le driver json-file qui stocke les logs de chaque conteneur dans des fichiers JSON sans rotation automatique, ce qui peut rapidement saturer l'espace disque. Configurez la rotation des logs dans le fichier /etc/docker/daemon.json :

{"log-driver": "json-file", "log-opts": {"max-size": "10m", "max-file": "3"}}

L'optimisation des performances de build Docker peut accélérer considérablement les pipelines CI/CD et améliorer l'expérience des développeurs. Activez BuildKit, le nouveau moteur de build plus performant :

{"features": {"buildkit": true}}

{"builder": {"gc": {"enabled": true, "defaultKeepStorage": "20GB"}}}

Sécurisation de votre installation Docker

La protection du socket Docker constitue l'une des premières mesures de sécurisation à mettre en place après l'installation. Par défaut, le socket Unix de Docker (/var/run/docker.sock) accorde des privilèges root effectifs à quiconque peut y accéder. Limitez strictement l'accès à ce socket en vous assurant que seuls les utilisateurs autorisés appartiennent au groupe docker : sudo usermod -aG docker utilisateur_autorisé. Pour les environnements de production critiques, envisagez d'implémenter une solution d'autorisation plus granulaire comme Docker Authorization Plugin, qui permet de définir des politiques précises sur les actions autorisées. Dans certains contextes de haute sécurité, l'utilisation de socket proxy comme docker-proxy-acl peut offrir un contrôle encore plus fin des accès au démon Docker.

La configuration d'un TLS mutuel pour le démon Docker constitue une mesure de sécurité essentielle pour tout déploiement exposant l'API Docker sur le réseau. Par défaut, le démon Docker écoute uniquement sur un socket Unix local, mais certaines configurations nécessitent une exposition réseau. Dans ce cas, activez impérativement l'authentification TLS mutuelle :

{
  "tls": true,
  "tlscacert": "/etc/docker/ca.pem",
  "tlscert": "/etc/docker/server-cert.pem",
  "tlskey": "/etc/docker/server-key.pem",
  "tlsverify": true
}

La limitation des privilèges des conteneurs représente un aspect fondamental de la sécurisation de Docker. Par défaut, les conteneurs s'exécutent avec des privilèges réduits mais conservent certaines capacités potentiellement dangereuses. Configurez Docker pour appliquer des restrictions plus strictes par défaut dans /etc/docker/daemon.json :

{
  "default-ulimits": {
    "nofile": { "Name": "nofile", "Hard": 64000, "Soft": 64000 },
    "nproc": { "Name": "nproc", "Hard": 1024, "Soft": 1024 }
  },
  "no-new-privileges": true,
  "userns-remap": "default"
}

L'application de profils de sécurité AppArmor ou SELinux renforce significativement l'isolation des conteneurs. Ces mécanismes de contrôle d'accès obligatoire (MAC) restreignent les actions qu'un processus peut effectuer, même s'il s'exécute en tant que root. Sur les distributions basées sur Debian/Ubuntu, assurez-vous qu'AppArmor est correctement configuré : sudo apparmor_status devrait indiquer que le module est chargé et actif. Docker applique automatiquement un profil AppArmor par défaut aux conteneurs, mais vous pouvez utiliser des profils plus restrictifs : docker run --security-opt apparmor=docker-custom-profile .... Sur les systèmes utilisant SELinux comme RHEL/CentOS, vérifiez que SELinux est en mode enforcing (getenforce) et utilisez les options appropriées lors du démarrage des conteneurs : docker run --security-opt label=type:container_t ....

La mise en place d'audits et de surveillance de sécurité constitue une couche défensive essentielle pour détecter les comportements anormaux ou malveillants. Configurez auditd pour surveiller les accès au socket Docker et les modifications des fichiers de configuration :

cat << EOF | sudo tee /etc/audit/rules.d/docker.rules
-w /usr/bin/docker -k docker
-w /var/lib/docker -k docker
-w /etc/docker -k docker
-w /lib/systemd/system/docker.service -k docker
-w /lib/systemd/system/docker.socket -k docker
-w /etc/default/docker -k docker
-w /etc/docker/daemon.json -k docker
-w /usr/bin/docker-containerd -k docker
-w /usr/bin/docker-runc -k docker
EOF
sudo service auditd restart

La mise en oeuvre d'une politique de mise à jour régulière constitue une mesure de sécurité fondamentale souvent négligée. Les vulnérabilités dans le moteur Docker et ses composants sont régulièrement découvertes et corrigées. Configurez des notifications de sécurité pour être alerté des nouvelles vulnérabilités : sudo apt-get install apt-listchanges sur Debian/Ubuntu, ou abonnez-vous aux listes de diffusion de sécurité de votre distribution et de Docker. Mettez en place un processus de mise à jour régulière, idéalement automatisé via des outils comme unattended-upgrades pour les correctifs de sécurité critiques :

sudo apt-get install unattended-upgrades
sudo dpkg-reconfigure -plow unattended-upgrades

Maintenance et bonnes pratiques opérationnelles

La mise en place d'une stratégie de nettoyage automatique constitue une pratique essentielle pour maintenir les performances et la stabilité d'une installation Docker sur le long terme. Sans maintenance régulière, les images non utilisées, les conteneurs arrêtés et les volumes orphelins peuvent rapidement consommer l'espace disque disponible. Implémentez un script de nettoyage périodique à exécuter via cron :

#!/bin/bash
# Supprime tous les conteneurs arrêtés
docker container prune -f
# Supprime toutes les images non utilisées
docker image prune -a --filter "until=24h" -f
# Supprime les volumes non utilisés
docker volume prune -f
# Supprime les réseaux non utilisés
docker network prune -f

La surveillance proactive des ressources Docker représente un élément crucial pour maintenir la stabilité opérationnelle. Configurez des outils de monitoring pour surveiller l'utilisation des ressources du daemon Docker lui-même ainsi que des conteneurs individuels. Pour une solution légère, installez ctop ou docker-stats-monitor qui offrent une vue en temps réel des métriques clés. Pour les environnements de production, configurez Prometheus et Grafana avec l'exportateur Docker :

docker run -d --restart=always -p 9323:9323 --name docker-metrics -v /var/run/docker.sock:/var/run/docker.sock:ro bitnami/mysqld-exporter

{"metrics-addr": "127.0.0.1:9323", "experimental": true}

La mise en oeuvre d'une politique de sauvegarde robuste constitue une pratique fondamentale souvent négligée. Bien que les conteneurs soient conçus pour être éphémères, les volumes Docker contiennent souvent des données critiques qui doivent être sauvegardées régulièrement. Créez un script de sauvegarde pour vos volumes nommés :

#!/bin/bash
BACKUP_DIR="/chemin/vers/backups/$(date +%Y%m%d)"
mkdir -p "$BACKUP_DIR"
for volume in $(docker volume ls -q); do
  echo "Sauvegarde du volume $volume"
  docker run --rm -v $volume:/source:ro -v $BACKUP_DIR:/backup alpine tar -czf /backup/$volume.tar.gz -C /source ./
done

La gestion des registres Docker privés constitue un aspect stratégique pour les environnements d'entreprise. Pour les déploiements importants, la mise en place d'un registry privé améliore les performances de déploiement, renforce la sécurité et réduit la dépendance à Docker Hub. Déployez un registry sécurisé avec authentification et TLS :

mkdir -p /chemin/vers/certs /chemin/vers/auth
openssl req -newkey rsa:4096 -nodes -sha256 -keyout /chemin/vers/certs/domain.key -x509 -days 365 -out /chemin/vers/certs/domain.crt
htpasswd -Bbn utilisateur motdepasse > /chemin/vers/auth/htpasswd
docker run -d -p 5000:5000 --restart=always --name registry \
  -v /chemin/vers/certs:/certs \
  -v /chemin/vers/auth:/auth \
  -e REGISTRY_HTTP_TLS_CERTIFICATE=/certs/domain.crt \
  -e REGISTRY_HTTP_TLS_KEY=/certs/domain.key \
  -e REGISTRY_AUTH=htpasswd \
  -e REGISTRY_AUTH_HTPASSWD_REALM="Registry Realm" \
  -e REGISTRY_AUTH_HTPASSWD_PATH=/auth/htpasswd \
  registry:2

L'automatisation des tâches de maintenance Docker améliore considérablement la fiabilité opérationnelle en éliminant les erreurs humaines et en assurant la cohérence des opérations. Au-delà des scripts cron mentionnés précédemment, envisagez d'implémenter une solution complète d'automatisation comme Ansible, Chef ou Puppet pour gérer la configuration de Docker sur l'ensemble de votre infrastructure. Créez des playbooks ou des recettes pour standardiser les opérations courantes : installation et mise à jour de Docker, configuration des paramètres de sécurité, déploiement de stacks d'applications, et rotation des certifications TLS. Cette approche garantit non seulement la cohérence entre les environnements, mais permet également une documentation implicite des procédures opérationnelles et facilite l'intégration de nouveaux systèmes.

L'adoption de pratiques GitOps pour la gestion de l'infrastructure Docker représente une approche moderne et puissante pour maintenir des environnements cohérents et reproductibles. Stockez toutes vos configurations Docker (daemon.json, compose files, etc.) dans un dépôt Git et utilisez des outils comme Ansible, Terraform ou FluxCD pour appliquer automatiquement ces configurations à votre infrastructure. Cette méthodologie offre plusieurs avantages : traçabilité complète des modifications, possibilité de rollback en cas de problème, revue de code pour les changements d'infrastructure, et tests automatisés avant déploiement. Implémentez des hooks Git pour valider automatiquement les fichiers de configuration avant leur commit :

#!/bin/bash
# .git/hooks/pre-commit
for file in $(git diff --cached --name-only | grep -E '(daemon\.json|docker-compose\.ya?ml)$'); do
  if [[ "$file" =~ docker-compose.ya?ml$ ]]; then
    docker-compose -f "$file" config > /dev/null || exit 1
  elif [[ "$file" =~ daemon\.json$ ]]; then
    jq empty "$file" || exit 1
  fi
done

Intégration avec les outils de surveillance et de journalisation

La mise en place d'une solution de collecte de logs centralisée constitue une pratique fondamentale pour la gestion efficace d'environnements Docker en production. Par défaut, Docker utilise le driver json-file qui stocke les logs localement, ce qui complique la surveillance centralisée et l'analyse des problèmes dans des environnements distribués. Configurez un système comme la stack EFK (Elasticsearch, Fluentd, Kibana) pour centraliser les logs :

{
  "log-driver": "fluentd",
  "log-opts": {
    "fluentd-address": "fluentd-host:24224",
    "fluentd-async": "true",
    "tag": "docker.{{.Name}}"
  }
}

L'intégration avec des systèmes de surveillance de métriques permet une visibilité complète sur les performances et la santé de votre infrastructure Docker. La solution la plus répandue combine Prometheus pour la collecte et le stockage des métriques avec Grafana pour la visualisation. Configurez le daemon Docker pour exposer ses métriques :

{
  "metrics-addr": "0.0.0.0:9323",
  "experimental": true
}

docker run \
  --volume=/:/rootfs:ro \
  --volume=/var/run:/var/run:ro \
  --volume=/sys:/sys:ro \
  --volume=/var/lib/docker/:/var/lib/docker:ro \
  --volume=/dev/disk/:/dev/disk:ro \
  --publish=8080:8080 \
  --detach=true \
  --name=cadvisor \
  google/cadvisor:latest

L'implémentation d'un système d'alerte proactif transforme considérablement la gestion opérationnelle des environnements Docker. Une surveillance passive qui nécessite une vérification manuelle constante n'est pas viable pour des environnements de production. Configurez des alertes basées sur des seuils pour les métriques critiques comme l'utilisation du disque, de la mémoire, et du CPU. Avec Prometheus, utilisez AlertManager pour définir des règles d'alerte et les acheminer vers différents canaux de notification :

groups:
- name: docker_alerts
  rules:
  - alert: HighCpuUsage
    expr: sum(rate(container_cpu_usage_seconds_total{name!=""}[5m])) by (name) * 100 > 80
    for: 5m
    labels:
      severity: warning
    annotations:
      summary: "Conteneur {{ $labels.name }} - utilisation CPU élevée"
      description: "Le conteneur {{ $labels.name }} consomme plus de 80% de CPU depuis 5 minutes."

La mise en place d'une surveillance de sécurité dynamique complète la protection statique de votre environnement Docker. Des outils comme Falco, développé par Sysdig, permettent de détecter en temps réel des comportements anormaux ou malveillants dans vos conteneurs, comme des tentatives d'escalade de privilèges, l'exécution de shells interactifs dans des conteneurs qui n'en nécessitent pas normalement, ou des modifications non autorisées de fichiers système critiques. Installez Falco sur vos hôtes Docker :

curl -s https://falco.org/repo/falcosecurity-packages.asc | apt-key add -
echo "deb https://download.falco.org/packages/deb stable main" | tee -a /etc/apt/sources.list.d/falcosecurity.list
apt-get update -y
apt-get install -y falco

Le traçage distribué (distributed tracing) constitue une dimension essentielle de l'observabilité pour les architectures microservices conteneurisées. Des solutions comme Jaeger ou Zipkin permettent de suivre le parcours complet d'une requête à travers différents services, identifiant les goulots d'étranglement et les points de défaillance. Pour installer Jaeger avec Docker :

docker run -d --name jaeger \
  -e COLLECTOR_ZIPKIN_HOST_PORT=:9411 \
  -p 5775:5775/udp \
  -p 6831:6831/udp \
  -p 6832:6832/udp \
  -p 5778:5778 \
  -p 16686:16686 \
  -p 14268:14268 \
  -p 14250:14250 \
  -p 9411:9411 \
  jaegertracing/all-in-one:latest

L'adoption d'une approche unifiée d'observabilité combinant logs, métriques et traces constitue l'état de l'art pour la surveillance des environnements Docker. Des plateformes comme OpenTelemetry offrent un framework standardisé pour collecter ces trois types de données avec un impact minimal sur les performances. Pour déployer le collecteur OpenTelemetry :

docker run -d --name otel-collector \
  -p 4317:4317 -p 4318:4318 -p 8888:8888 \
  -v $(pwd)/otel-config.yaml:/etc/otel/config.yaml \
  otel/opentelemetry-collector:latest

Docker dans des environnements spécifiques (air-gapped, haute sécurité)

L'installation de Docker dans un environnement air-gapped (sans accès à Internet) présente des défis particuliers qui nécessitent une approche méthodique. Commencez par télécharger tous les packages requis depuis un système connecté : le package docker-ce et ses dépendances, les images Docker essentielles, et éventuellement un registry local. Pour Ubuntu/Debian, utilisez apt-get download après avoir configuré le dépôt Docker :

apt-get update
apt-cache depends docker-ce | grep Depends | cut -d: -f2 | xargs apt-get download
apt-get download docker-ce docker-ce-cli containerd.io

La mise en place d'un registry privé interne constitue une composante essentielle d'une stratégie Docker dans les environnements restrictifs. Ce registry local élimine la dépendance à Docker Hub et autres registries publics, tout en offrant un contrôle total sur les images disponibles dans votre infrastructure. Dans un environnement air-gapped, déployez ce registry avec une configuration TLS autosignée :

# Génération des certificats autosignés
mkdir -p certs
openssl req -newkey rsa:4096 -nodes -sha256 \
  -keyout certs/domain.key -x509 -days 365 -out certs/domain.crt

# Déploiement du registry sécurisé
docker run -d -p 5000:5000 --restart=always --name registry \
  -v "$(pwd)"/certs:/certs \
  -e REGISTRY_HTTP_TLS_CERTIFICATE=/certs/domain.crt \
  -e REGISTRY_HTTP_TLS_KEY=/certs/domain.key \
  -v "$(pwd)"/registry:/var/lib/registry \
  registry:2

L'implémentation de politiques de sécurité renforcées s'impose dans les environnements à haute sensibilité. Au-delà des recommandations standard, envisagez l'utilisation de seccomp (secure computing mode) pour restreindre drastiquement les appels système disponibles pour vos conteneurs. Créez un profil seccomp personnalisé et restrictif :

mkdir -p /etc/docker/seccomp
curl -L https://raw.githubusercontent.com/moby/moby/master/profiles/seccomp/default.json \
  -o /etc/docker/seccomp/restricted-profile.json

La gestion cryptographique des images Docker représente un aspect critique pour les environnements à haute sécurité. Docker Content Trust (DCT) fournit une infrastructure à clé publique pour la signature et la vérification cryptographique des images. Activez DCT globalement en définissant export DOCKER_CONTENT_TRUST=1 dans le profil des utilisateurs ou en le configurant par défaut dans daemon.json : {"content-trust": {"trust-pinning": {"disable-content-trust": false}}}. Pour une sécurité renforcée, implémentez une rotation régulière des clés de signature et stockez les clés racine sur des supports physiques sécurisés comme des tokens FIDO/U2F. Cette approche garantit l'intégrité et l'authenticité des images déployées dans votre infrastructure, prévenant efficacement les attaques de type supply-chain.

L'audit complet et continu des actions Docker constitue une exigence fondamentale dans les environnements hautement régulés comme la finance ou la santé. Configurez le système d'audit Linux pour surveiller toutes les opérations Docker pertinentes :

# Configuration de règles d'audit complètes pour Docker
cat << EOF | tee /etc/audit/rules.d/docker.rules
# Audit Docker daemon binary accesses
-w /usr/bin/dockerd -p rwxa -k docker
-w /usr/bin/docker -p rwxa -k docker

# Audit Docker configuration changes
-w /etc/docker/ -p rwxa -k docker-config
-w /etc/default/docker -p rwxa -k docker-config

# Audit Docker data directory
-w /var/lib/docker/ -p rwxa -k docker-data

# Audit Docker socket
-w /var/run/docker.sock -p rwxa -k docker-socket

# Audit containerd components
-w /usr/bin/containerd -p rwxa -k containerd
-w /usr/bin/containerd-shim -p rwxa -k containerd
-w /usr/bin/runc -p rwxa -k runc
EOF

# Reload audit rules
auditctl -R /etc/audit/rules.d/docker.rules

L'isolation physique des différents environnements Docker représente une mesure de sécurité supplémentaire pour les infrastructures sensibles. Au lieu de séparer les environnements de développement, test et production uniquement par des namespaces logiques ou des réseaux virtuels, implémentez une ségrégation physique complète avec des serveurs dédiés, des réseaux distincts et des contrôles d'accès granulaires. Cette approche limite drastiquement les risques de propagation latérale en cas de compromission d'un environnement. Complétez cette isolation par des procédures strictes de promotion du code et des images entre environnements, incluant des validations multiples, des scans de sécurité automatisés et des signatures cryptographiques à chaque transition. Cette défense en profondeur, bien que plus coûteuse, offre des garanties de sécurité essentielles pour les systèmes critiques.

Automatisation complète de l'installation et de la configuration

L'infrastructure as code (IaC) représente l'approche moderne pour automatiser entièrement le déploiement et la configuration de Docker sur plusieurs serveurs. Ansible, avec sa nature agentless et son approche déclarative, s'avère particulièrement adapté pour cette tâche. Créez un playbook Ansible complet pour installer Docker de manière cohérente :

---
- name: Install Docker Engine
  hosts: docker_hosts
  become: true
  vars:
    docker_users: ["user1", "user2"]
    docker_daemon_config:
      storage-driver: "overlay2"
      log-driver: "json-file"
      log-opts:
        max-size: "10m"
        max-file: "3"
      metrics-addr: "0.0.0.0:9323"
      experimental: true

  tasks:
    - name: Install prerequisites
      apt:
        name:
          - apt-transport-https
          - ca-certificates
          - curl
          - gnupg-agent
          - software-properties-common
        state: present
        update_cache: yes

    - name: Add Docker GPG apt key
      apt_key:
        url: https://download.docker.com/linux/{{ ansible_distribution | lower }}/gpg
        state: present

    - name: Add Docker repository
      apt_repository:
        repo: "deb [arch=amd64] https://download.docker.com/linux/{{ ansible_distribution | lower }} {{ ansible_distribution_release }} stable"
        state: present

    - name: Install Docker Engine
      apt:
        name:
          - docker-ce
          - docker-ce-cli
          - containerd.io
        state: present
        update_cache: yes

    - name: Configure Docker daemon
      copy:
        content: "{{ docker_daemon_config | to_nice_json }}"
        dest: /etc/docker/daemon.json
        owner: root
        group: root
        mode: '0644'
      notify: restart docker

    - name: Ensure Docker service is enabled and started
      systemd:
        name: docker
        state: started
        enabled: yes

    - name: Add users to Docker group
      user:
        name: "{{ item }}"
        groups: docker
        append: yes
      with_items: "{{ docker_users }}"

  handlers:
    - name: restart docker
      systemd:
        name: docker
        state: restarted

Terraform permet d'automatiser le provisionnement de l'infrastructure sous-jacente avant d'installer Docker. Combiné avec des providers de cloud comme AWS, Azure ou Google Cloud, il offre une approche complète pour créer des environnements Docker entièrement automatisés. Voici un exemple de configuration Terraform pour provisionner des instances EC2 sur AWS et installer Docker via un script de démarrage :

provider "aws" {
  region = "eu-west-1"
}

resource "aws_security_group" "docker_sg" {
  name        = "docker-security-group"
  description = "Allow SSH and Docker API ports"

  ingress {
    from_port   = 22
    to_port     = 22
    protocol    = "tcp"
    cidr_blocks = ["10.0.0.0/8"]
  }

  ingress {
    from_port   = 2376
    to_port     = 2376
    protocol    = "tcp"
    cidr_blocks = ["10.0.0.0/8"]
  }

  egress {
    from_port   = 0
    to_port     = 0
    protocol    = "-1"
    cidr_blocks = ["0.0.0.0/0"]
  }
}

resource "aws_instance" "docker_host" {
  ami           = "ami-0123456789abcdef0"
  instance_type = "t3.medium"
  key_name      = "docker-key"
  security_groups = [aws_security_group.docker_sg.name]

  root_block_device {
    volume_size = 50
  }

  user_data = <<-EOF
              #!/bin/bash
              apt-get update
              apt-get install -y apt-transport-https ca-certificates curl gnupg lsb-release
              curl -fsSL https://download.docker.com/linux/ubuntu/gpg | gpg --dearmor -o /usr/share/keyrings/docker-archive-keyring.gpg
              echo "deb [arch=amd64 signed-by=/usr/share/keyrings/docker-archive-keyring.gpg] https://download.docker.com/linux/ubuntu $(lsb_release -cs) stable" > /etc/apt/sources.list.d/docker.list
              apt-get update
              apt-get install -y docker-ce docker-ce-cli containerd.io
              systemctl enable docker
              systemctl start docker
              EOF

  tags = {
    Name = "docker-host"
  }
}

Chef offre une approche puissante pour gérer la configuration Docker avec une granularité fine et une grande flexibilité. Créez une recette Chef dédiée à l'installation et à la configuration de Docker :

# Cookbook: docker# Recipe: default.rb# Add Docker repositoryapt_repository 'docker' do  uri 'https://download.docker.com/linux/ubuntu'  distribution node['lsb']['codename']  components ['stable']  arch 'amd64'  key 'https://download.docker.com/linux/ubuntu/gpg'  action :addend# Install Docker packa
◄ Précédent Suivant ►