Introduction
Les conteneurs Docker sont les briques fondamentales du déploiement d'applications modernes. Dans cet atelier, nous allons explorer des techniques de gestion avancées qui approfondiront votre compréhension des capacités de Docker. Nous aborderons l'exécution de conteneurs dans différents modes, la gestion de leur cycle de vie, l'inspection des détails techniques, l'utilisation des journaux (logs), l'exécution de commandes à l'intérieur des conteneurs, la copie de fichiers, la configuration des variables d'environnement et la limitation des ressources allouées. À l'issue de cet atelier, vous aurez une vision complète de la manière de manipuler efficacement les conteneurs Docker.
Exécuter des conteneurs dans différents modes
Docker vous permet de lancer des conteneurs selon différents modes pour répondre à divers cas d'utilisation. Nous allons explorer deux modes courants : le mode détaché (arrière-plan) et le mode interactif.
Tout d'abord, lançons un conteneur en mode détaché :
docker run -d --name nginx-detached nginx
Cette commande effectue les actions suivantes :
-d: Lance le conteneur en mode détaché (en arrière-plan).--name nginx-detached: Attribue le nom "nginx-detached" au conteneur.nginx: Spécifie l'image à utiliser (elle sera téléchargée depuis le Docker Hub si elle n'est pas disponible localement).
Vous devriez voir s'afficher une longue chaîne de caractères, qui correspond à l'identifiant (ID) du conteneur.
Vous pouvez vérifier l'état du conteneur en exécutant :
docker ps
Maintenant, lançons un conteneur en mode interactif :
docker run -it --name ubuntu-interactive ubuntu /bin/bash
Cette commande effectue les actions suivantes :
-it: Lance le conteneur en mode interactif avec un pseudo-TTY (terminal).--name ubuntu-interactive: Attribue le nom "ubuntu-interactive" au conteneur.ubuntu: Spécifie l'image à utiliser./bin/bash: La commande à exécuter à l'intérieur du conteneur (dans ce cas, un shell bash).
Vous devriez maintenant être à l'intérieur du conteneur Ubuntu. Vous pouvez quitter le conteneur en tapant exit.
Listons nos conteneurs en cours d'exécution :
docker ps
Vous devriez voir le conteneur nginx-detached en cours d'exécution, mais pas le conteneur ubuntu-interactive (car nous l'avons quitté).
Gérer le cycle de vie des conteneurs
Savoir comment démarrer, arrêter et redémarrer des conteneurs est essentiel pour une gestion efficace.
Commençons par arrêter le conteneur nginx-detached :
docker stop nginx-detached
Vérifions maintenant l'état de nos conteneurs :
docker ps -a
Vous devriez constater que le conteneur nginx-detached est désormais dans l'état "Exited" (quitté).
Redémarrons-le :
docker start nginx-detached
Vérifiez à nouveau l'état :
docker ps
Le conteneur nginx-detached doit maintenant être dans l'état "Up" (en service).
Nous pouvons également redémarrer un conteneur déjà en cours d'exécution :
docker restart nginx-detached
Pour voir l'état actuel de tous nos conteneurs, y compris ceux qui sont arrêtés, utilisez :
docker ps -a
Vous devriez voir les conteneurs nginx-detached et ubuntu-interactive listés avec leur statut respectif.
Supprimons le conteneur ubuntu-interactive qui est arrêté :
docker rm ubuntu-interactive
Et vérifions qu'il a bien été supprimé :
docker ps -a
Le conteneur ubuntu-interactive ne devrait plus apparaître dans la liste.
Inspecter les détails du conteneur
Docker propose des outils puissants pour inspecter les détails de vos conteneurs. Explorons-les.
Pour obtenir des informations détaillées sur un conteneur, utilisez la commande inspect :
docker inspect nginx-detached
Cette commande renvoie un tableau JSON contenant des informations techniques exhaustives. Comme cela peut être dense, utilisons un filtre pour extraire des informations spécifiques.
Pour obtenir l'adresse IP du conteneur :
docker inspect -f '{{range .NetworkSettings.Networks}}{{.IPAddress}}{{end}}' nginx-detached
Pour voir le statut actuel du conteneur :
docker inspect -f '{{.State.Status}}' nginx-detached
Ces commandes utilisent des modèles Go (Go templates) pour filtrer la sortie. L'option -f permet de spécifier le format souhaité.
Vérifions également les mappages de ports :
docker port nginx-detached
Le mappage de ports permet aux conteneurs de communiquer avec le système hôte ou des réseaux externes. Il fait correspondre un port de la machine hôte à un port interne du conteneur. C'est indispensable pour accéder aux services tournant dans les conteneurs depuis l'extérieur de l'environnement Docker.
Si aucun port n'est mappé, cette commande ne produira aucun résultat. Dans notre cas, nous n'avons pas explicitement mappé de ports pour le conteneur nginx-detached, vous ne verrez donc probablement rien.
Pour illustrer le mappage de ports, créons un nouveau conteneur Nginx avec un port spécifique :
docker run -d --name nginx-with-port -p 8080:80 nginx
Cette commande mappe le port 8080 de l'hôte vers le port 80 du conteneur. Maintenant, si nous vérifions les ports :
docker port nginx-with-port
Vous devriez voir un résultat similaire à :
80/tcp -> 0.0.0.0:8080
Cela signifie que le trafic arrivant sur le port 8080 de votre machine hôte sera redirigé vers le port 80 du conteneur, là où Nginx est à l'écoute.
Travailler avec les journaux des conteneurs
Accéder aux journaux (logs) et les comprendre est crucial pour le dépannage et la surveillance de vos applications.
Consultons les journaux de notre conteneur nginx :
docker logs nginx-detached
Cela affiche tous les journaux depuis le démarrage du conteneur. Pour ne voir que les entrées les plus récentes, utilisez l'option --tail :
docker logs --tail 10 nginx-detached
Ceci n'affiche que les 10 dernières lignes.
Pour suivre les journaux en temps réel (comme un tail -f), utilisez l'option -f :
docker logs -f nginx-detached
Le flux continuera d'afficher les nouvelles lignes au fur et à mesure de leur génération. Appuyez sur Ctrl+C pour quitter le flux.
Vous pouvez également afficher l'horodatage des entrées :
docker logs --timestamps nginx-detached
C'est particulièrement utile pour déboguer des problèmes liés au temps.
Exécuter des commandes dans des conteneurs en cours d'exécution
Docker vous permet d'exécuter des commandes à l'intérieur d'un conteneur actif, ce qui est extrêmement pratique pour la maintenance.
Commençons par exécuter une commande simple dans notre conteneur nginx :
docker exec nginx-detached echo "Bonjour depuis l'intérieur du conteneur"
Vous devriez voir le message s'afficher dans votre terminal.
Maintenant, ouvrons un shell interactif à l'intérieur du conteneur :
docker exec -it nginx-detached /bin/bash
Vous êtes maintenant "dans" le conteneur. Explorons un peu :
ls /etc/nginx
cat /etc/nginx/nginx.conf
exit
Ces commandes listent le contenu du répertoire de configuration de Nginx et affichent le fichier de configuration principal. La commande exit vous ramène au shell de votre système hôte.
Copier des fichiers vers et depuis les conteneurs
Docker permet de transférer des fichiers entre votre système hôte et vos conteneurs. C'est utile pour mettre à jour des configurations ou récupérer des fichiers de log.
Tout d'abord, créons un fichier HTML simple sur l'hôte :
echo "<html><body><h1>Bonjour depuis l'hôte</h1></body></html>" > hello.html
Ensuite, copions ce fichier dans notre conteneur nginx :
docker cp hello.html nginx-detached:/usr/share/nginx/html/hello.html
Vérifions que le fichier a bien été copié en exécutant une commande dans le conteneur :
docker exec nginx-detached cat /usr/share/nginx/html/hello.html
Vous devriez voir le contenu du fichier HTML.
Maintenant, copions un fichier du conteneur vers notre hôte :
docker cp nginx-detached:/etc/nginx/nginx.conf ~/project/nginx.conf
Ceci copie le fichier de configuration Nginx du conteneur vers votre répertoire actuel sur l'hôte.
Vérifiez la présence du fichier :
ls -l ~/project/nginx.conf
Le fichier nginx.conf devrait apparaître dans la liste.
Configurer les variables d'environnement dans les conteneurs
Les variables d'environnement sont un moyen privilégié pour configurer les applications tournant dans des conteneurs. Voyons comment les utiliser.
Lançons un nouveau conteneur avec une variable d'environnement :
docker run --name env-test -e MY_VAR="Bonjour l'Environnement" -d ubuntu sleep infinity
Cette commande effectue les actions suivantes :
--name env-test: Nomme le conteneur "env-test".-e MY_VAR="Bonjour l'Environnement": Définit une variable nommée MY_VAR.-d: Lance le conteneur en arrière-plan.ubuntu: Utilise l'image Ubuntu.sleep infinity: Maintient le conteneur en vie indéfiniment.
Vérifions que la variable a bien été prise en compte :
docker exec env-test env | grep MY_VAR
Vous devriez voir MY_VAR=Bonjour l'Environnement dans la sortie.
Nous pouvons aussi définir des variables via un fichier. Créez un fichier nommé env_file avec le contenu suivant.
Vous pouvez utiliser nano ou vim pour créer le fichier :
nano env_file
ANOTHER_VAR=Depuis un fichier
YET_ANOTHER_VAR=Aussi depuis le fichier
Quittez l'éditeur et sauvegardez en appuyant sur Ctrl+X, puis Y, et Entrée.
Lançons un autre conteneur en utilisant ce fichier :
docker run --name env-file-test --env-file env_file -d ubuntu sleep infinity
Vérifiez les variables dans ce nouveau conteneur :
docker exec env-file-test env | grep -E "ANOTHER_VAR|YET_ANOTHER_VAR"
Les deux variables du fichier devraient apparaître.
Limiter les ressources des conteneurs
Docker permet de restreindre les ressources (processeur et mémoire) qu'un conteneur peut consommer. C'est crucial pour garantir la stabilité dans des environnements multi-conteneurs.
Lançons un conteneur avec des limites de mémoire et de CPU :
docker run --name limited-nginx -d --memory=512m --cpus=0.5 nginx
Cette commande effectue les actions suivantes :
--name limited-nginx: Nomme le conteneur "limited-nginx".-d: Mode détaché.--memory=512m: Limite le conteneur à 512 mégaoctets de RAM.--cpus=0.5: Limite le conteneur à l'utilisation de maximum la moitié d'un cœur CPU.nginx: Utilise l'image Nginx.
Vérifions ces limites avec la commande inspect :
docker inspect -f '{{.HostConfig.Memory}}' limited-nginx
docker inspect -f '{{.HostConfig.NanoCpus}}' limited-nginx
La première commande affichera 536870912 (512 Mo en octets), et la seconde affichera 500000000 (0,5 CPU en nano-unités).
Pour observer l'impact de ces limites en temps réel, utilisez la commande stats :
docker stats limited-nginx
Cela affiche un flux de statistiques d'utilisation des ressources. Appuyez sur Ctrl+C pour quitter.
Résumé
Dans cet atelier, nous avons exploré des techniques avancées de gestion de conteneurs avec Docker. Nous avons appris à exécuter des conteneurs dans différents modes, à gérer leur cycle de vie, à inspecter leurs détails techniques, à exploiter les journaux, à exécuter des commandes internes, à copier des fichiers, à configurer l'environnement et à limiter les ressources matérielles. Ces compétences constituent une base solide pour manipuler Docker dans des scénarios complexes.
N'oubliez pas qu'une gestion efficace des conteneurs est la clé pour construire des applications conteneurisées évolutives et faciles à maintenir. Au fil de votre progression avec Docker, ces outils vous seront indispensables pour le débogage, l'optimisation et l'administration de vos environnements.
Continuez à pratiquer ces commandes et à explorer les possibilités de Docker. Plus vous manipulerez les conteneurs, plus vous gagnerez en aisance et en expertise. Bonne conteneurisation !
