Paramètres de la commande Docker Run

Introduction

Dans cet atelier, nous nous concentrerons exclusivement sur la commande docker run et ses différents paramètres. La commande docker run est fondamentale dans l'utilisation de Docker, car elle nous permet de créer et de démarrer des conteneurs avec des configurations spécifiques.

En maîtrisant les paramètres de cette commande, vous obtiendrez un contrôle accru sur vos applications conteneurisées, améliorant ainsi votre capacité à déployer et à gérer efficacement des conteneurs Docker.

Nous aborderons un large éventail de paramètres, notamment ceux relatifs au nommage, au mode détaché, au mappage de ports, au montage de volumes, aux variables d'environnement, aux contraintes de ressources, et bien plus encore.

Certains de ces paramètres vous sont peut-être déjà familiers, tandis que d'autres seront nouveaux pour vous.

Utilisation basique de Docker Run et nommage des conteneurs

Commençons par les bases de docker run et explorons comment nommer nos conteneurs.

Tout d'abord, lancez un conteneur Nginx standard :

docker run nginx

Cette commande exécute un conteneur Nginx au premier plan. Vous verrez un flux de journaux (logs) s'afficher dans votre terminal. C'est parce que le conteneur s'exécute de manière interactive et vous transmet directement ses sorties.

Pour arrêter ce conteneur, appuyez sur Ctrl+C. Vous remarquerez peut-être que l'arrêt prend quelques secondes : c'est normal, car Docker laisse au conteneur le temps de s'éteindre proprement.

Maintenant, lançons-le en mode détaché et donnons-lui un nom :

docker run -d --name my-nginx nginx

Analysons cette commande :

• docker run : C'est la commande de base pour lancer un conteneur.
• -d : Cette option lance le conteneur en mode détaché (detached), ce qui signifie qu'il s'exécute en arrière-plan. Vous ne verrez aucune sortie dans votre terminal.
• --name my-nginx : Cela attribue le nom "my-nginx" au conteneur. Si vous ne spécifiez pas de nom, Docker en attribuera un de manière aléatoire.
• nginx : C'est le nom de l'image que nous utilisons pour créer le conteneur.

Après avoir exécuté cette commande, vous verrez une longue chaîne de caractères. Il s'agit de l'identifiant (ID) du conteneur. Docker a démarré le conteneur en arrière-plan.

Si vous rencontrez une erreur indiquant que le nom est déjà utilisé, cela signifie qu'un conteneur portant ce nom existe déjà. Vous pouvez soit choisir un autre nom, soit supprimer le conteneur existant (nous apprendrons comment faire dans les prochains ateliers).

Mappage de ports

Le paramètre -p de docker run nous permet de mapper les ports du conteneur vers l'hôte. C'est une étape cruciale pour accéder aux services s'exécutant à l'intérieur du conteneur depuis votre machine physique.

Lancez un conteneur Nginx avec un mappage de port :

docker run -d --name nginx-mapped -p 8080:80 nginx

Analysons les nouveaux éléments de cette commande :

• -p 8080:80 : Cela mappe le port 8080 de votre machine hôte vers le port 80 du conteneur. Le format est toujours port_hôte:port_conteneur.

Par défaut, Nginx écoute sur le port 80 à l'intérieur du conteneur. En le mappant sur le port 8080 de notre hôte, nous pouvons y accéder en allant sur localhost:8080 dans un navigateur web.

Vérifions maintenant que la page d'accueil de Nginx est accessible. Nous utiliserons la commande curl, qui permet d'effectuer des requêtes HTTP en ligne de commande :

curl http://localhost:8080

Vous devriez voir le contenu HTML de la page de bienvenue de Nginx. Si curl n'est pas installé, vous pouvez l'installer avec :

sudo apt-get update && sudo apt-get install -y curl

Si vous ne parvenez toujours pas à accéder à la page, voici quelques points à vérifier :

1. Assurez-vous que le conteneur est bien en cours d'exécution : docker ps | grep nginx-mapped
2. Vérifiez si le port est réellement mappé : docker port nginx-mapped
3. Si vous utilisez un serveur dans le cloud, assurez-vous que le pare-feu autorise le trafic sur le port 8080.

Montage de volumes

Le paramètre -v de docker run permet de monter des volumes, partageant ainsi des données entre l'hôte et le conteneur. C'est extrêmement utile pour rendre les données persistantes ou pour fournir des fichiers de configuration au conteneur.

Commençons par créer une structure de répertoire simple sur notre hôte :

mkdir -p ~/project/nginx-data
echo "<html><body><h1>Hello from mounted volume</h1></body></html>" > ~/project/nginx-data/index.html

Ces commandes effectuent les actions suivantes :

1. Créent un nouveau répertoire nginx-data à l'intérieur du dossier project dans votre répertoire personnel.
2. Créent un fichier HTML simple nommé index.html dans ce nouveau répertoire.

Maintenant, lançons un conteneur Nginx en montant ce répertoire :

docker run -d --name nginx-volume -p 8081:80 -v ~/project/nginx-data:/usr/share/nginx/html nginx

Analysons cette commande :

• docker run : Commande pour lancer un nouveau conteneur.
• -d : Exécute le conteneur en arrière-plan.
• --name nginx-volume : Attribue le nom "nginx-volume" à notre conteneur.
• -p 8081:80 : Mappe le port 8081 de l'hôte vers le port 80 du conteneur.
• -v ~/project/nginx-data:/usr/share/nginx/html : Monte le répertoire nginx-data de notre hôte vers le répertoire /usr/share/nginx/html du conteneur. C'est là que Nginx cherche le contenu à diffuser.
• nginx : L'image utilisée.

Vérifions maintenant que notre page personnalisée est bien diffusée :

curl http://localhost:8081

Vous devriez voir le contenu de votre fichier HTML personnalisé : "Hello from mounted volume!"

Si vous ne voyez pas votre contenu, vérifiez les points suivants :

1. Assurez-vous que le fichier ~/project/nginx-data/index.html existe bien sur votre système hôte.
2. Vérifiez que le conteneur tourne : docker ps | grep nginx-volume
3. Consultez les journaux de Nginx pour d'éventuelles erreurs : docker logs nginx-volume

Cette méthode de montage d'un répertoire hôte dans un conteneur est appelée un "bind mount". C'est un moyen direct de partager des fichiers. Voici quelques points clés à retenir :

1. Le chemin du répertoire hôte doit être un chemin absolu.
2. Si le répertoire hôte n'existe pas, Docker le créera automatiquement.
3. Toute modification apportée aux fichiers dans ce répertoire (que ce soit sur l'hôte ou dans le conteneur) sera immédiatement visible des deux côtés.
4. Attention aux permissions : le conteneur s'exécute par défaut en tant que root, ce qui pourrait créer des fichiers que votre utilisateur hôte ne pourra pas modifier.

En utilisant cette méthode, nous évitons l'erreur "not a directory" car nous montons un répertoire complet et non un fichier unique. Cette approche vous offre plus de flexibilité pour ajouter, supprimer ou modifier des fichiers sans avoir à recréer le conteneur.

Variables d'environnement

Le paramètre -e de docker run permet de définir des variables d'environnement dans le conteneur. C'est très utile pour configurer l'application s'exécutant dans le conteneur sans avoir à modifier son code source.

Lancez un conteneur avec des variables d'environnement :

docker run -d --name nginx-env -e NGINX_HOST=mywebsite.com -e NGINX_PORT=80 nginx

Analysons les nouveaux éléments :

• -e NGINX_HOST=mywebsite.com : Définit une variable d'environnement nommée NGINX_HOST avec la valeur mywebsite.com.
• -e NGINX_PORT=80 : Définit une autre variable NGINX_PORT avec la valeur 80.

Les variables d'environnement sont des paires clé-valeur accessibles par les processus s'exécutant à l'intérieur du conteneur. De nombreuses images Docker sont conçues pour utiliser des variables d'environnement spécifiques pour leur configuration.

Vous pouvez vérifier la présence de ces variables :

docker exec nginx-env env | grep NGINX_

Cette commande effectue les actions suivantes :

• docker exec nginx-env : Demande à Docker d'exécuter une commande dans le conteneur nginx-env en cours d'exécution.
• env : Cette commande affiche toutes les variables d'environnement.
• | grep NGINX_ : Filtre la sortie pour ne montrer que les lignes contenant "NGINX_".

Vous devriez voir vos deux variables d'environnement listées.

Si vous ne les voyez pas, vérifiez :

1. Le conteneur est-il en cours d'exécution ? Vérifiez avec docker ps | grep nginx-env
2. Avez-vous correctement orthographié les noms des variables dans votre commande docker run ?

Contraintes de ressources

Docker vous permet de définir des limites de ressources sur les conteneurs via divers paramètres de docker run. C'est essentiel pour garantir les performances et la stabilité de votre système hôte, surtout lorsque vous exécutez plusieurs conteneurs simultanément.

Lancez un conteneur avec des limites de mémoire et de processeur (CPU) :

docker run -d --name nginx-limited --memory 256m --cpus 0.5 nginx

Analysons les nouveaux éléments :

• --memory 256m : Limite le conteneur à 256 mégaoctets de mémoire vive. Le 'm' signifie mégaoctets. Vous pourriez aussi utiliser 'g' pour gigaoctets.
• --cpus 0.5 : Limite le conteneur à l'utilisation d'au plus la moitié d'un cœur de processeur.

Ces limites empêchent le conteneur de consommer plus de ressources que spécifié, évitant ainsi qu'un seul conteneur ne monopolise toutes les ressources de l'hôte.

Vous pouvez vérifier que ces limites ont été correctement appliquées :

docker inspect -f '{{.HostConfig.Memory}}' nginx-limited
docker inspect -f '{{.HostConfig.NanoCpus}}' nginx-limited

La première commande devrait afficher 268435456 (256 Mo en octets), et la seconde devrait afficher 500000000 (0,5 CPU en nano-unités).

Si vous voyez des valeurs différentes, vérifiez à nouveau votre commande docker run.

Note : Définir des limites de ressources trop basses peut entraîner des performances médiocres, voire le plantage du conteneur. Si vous rencontrez des problèmes, essayez d'augmenter ces limites.

Paramètres réseau

Le paramètre --network de docker run permet de connecter un conteneur à un réseau spécifique. C'est utile pour la communication entre conteneurs et pour isoler des groupes de conteneurs.

Tout d'abord, créez un réseau de type "bridge" personnalisé :

docker network create my-custom-network

Cela crée un nouveau réseau nommé my-custom-network. Les réseaux "bridge" sont le type de réseau le plus courant dans Docker.

Maintenant, lancez un conteneur connecté à ce réseau :

docker run -d --name nginx-networked --network my-custom-network nginx

L'option --network my-custom-network connecte le conteneur au réseau que nous venons de créer.

Les conteneurs situés sur le même réseau peuvent communiquer entre eux en utilisant leurs noms de conteneur comme noms d'hôte (hostnames). Cela facilite grandement la liaison entre différents services.

Si vous obtenez une erreur indiquant que le réseau n'existe pas, assurez-vous d'avoir correctement exécuté la commande docker network create.

Politiques de redémarrage

Le paramètre --restart de docker run permet de spécifier une politique de redémarrage pour le conteneur. C'est utile pour s'assurer que vos conteneurs restent opérationnels, même s'ils plantent ou si le service Docker redémarre.

Lancez un conteneur avec une politique de redémarrage :

docker run -d --name nginx-restart --restart unless-stopped nginx

L'option --restart unless-stopped définit la politique sur "sauf si arrêté", ce qui signifie que le conteneur redémarrera automatiquement à moins qu'il n'ait été explicitement arrêté par l'utilisateur.

Les autres politiques de redémarrage incluent :

• no : La valeur par défaut. Ne redémarre pas automatiquement le conteneur.
• on-failure : Redémarre uniquement si le conteneur s'arrête avec un code d'erreur (non nul).
• always : Redémarre toujours le conteneur, quel que soit le code de sortie.

Vous pouvez vérifier la politique de redémarrage appliquée :

docker inspect -f '{{.HostConfig.RestartPolicy.Name}}' nginx-restart

Cela devrait afficher unless-stopped.

Si vous ne voyez pas le résultat attendu, vérifiez la syntaxe de votre commande docker run.

Répertoire de travail et commande personnalisée

Dans cette étape, nous allons explorer comment définir un répertoire de travail à l'intérieur d'un conteneur et comment exécuter des commandes personnalisées au démarrage.

Le paramètre -w de docker run définit le répertoire de travail (working directory) à l'intérieur du conteneur, et vous pouvez spécifier une commande à exécuter juste après le nom de l'image.

Combinons ces concepts :

docker run -d --name nginx-custom -w /app nginx sh -c "mkdir -p /app && touch newfile.txt && nginx -g 'daemon off;'"

Analysons cette commande complexe :

• -d : Lance le conteneur en arrière-plan.
• --name nginx-custom : Nomme le conteneur "nginx-custom".
• -w /app : Définit le répertoire de travail interne sur /app.
• nginx : Le nom de l'image à utiliser.
• sh -c "..." : Exécute une commande via le shell.
  • mkdir -p /app : Crée le répertoire /app s'il n'existe pas.
  • && : Enchaîne la commande suivante si la précédente réussit.
  • touch newfile.txt : Crée un fichier vide nommé newfile.txt.
  • && : Enchaîne la commande suivante.
  • nginx -g 'daemon off;' : Démarre Nginx au premier plan pour maintenir le conteneur actif.

Vérifions maintenant que le conteneur tourne et que le fichier a été créé :

docker ps | grep nginx-custom
docker exec nginx-custom ls -l /app/newfile.txt

La première commande devrait confirmer que le conteneur est actif, et la seconde devrait lister les détails du fichier newfile.txt dans le répertoire /app du conteneur.

Résumé

Dans cet atelier, nous avons exploré en profondeur la commande docker run et ses multiples paramètres. Nous avons abordé :

1. Le lancement et le nommage de base des conteneurs.
2. Le mappage de ports pour accéder aux services depuis l'hôte.
3. Le montage de volumes pour le partage et la persistance des données.
4. La configuration via les variables d'environnement.
5. L'application de contraintes de ressources (mémoire et CPU).
6. La gestion du réseau pour la communication entre conteneurs.
7. Les politiques de redémarrage pour garantir la fiabilité.
8. La définition du répertoire de travail et des commandes de démarrage.

Ces paramètres de docker run constituent des outils puissants pour configurer et gérer vos conteneurs Docker. En maîtrisant ces options, vous pouvez créer des déploiements plus sophistiqués et adaptés à vos besoins, tout en contrôlant finement l'interaction des conteneurs avec le système hôte et leur comportement dans divers scénarios.