Docker pour les débutants : Un guide pratique des conteneurs

Concepts de base de Docker

Maintenant que vous avez installé Docker, vous êtes peut-être impatient de commencer à exécuter des conteneurs. Mais avant de le faire, il est important de comprendre quelques concepts clés qui constituent la base du fonctionnement de Docker. Ces concepts vous aideront à naviguer dans Docker de manière plus efficace et à éviter les pièges courants des débutants.

Au cœur de Docker se trouvent les images, qui servent de modèles pour les conteneurs; les conteneurs, qui sont les instances en cours d’exécution de ces images; et Docker Hub, un référentiel centralisé pour le partage et la gestion des images.

Explorons chacun de ces concepts en détail.

Images Docker

Les images Docker sont les éléments de base fondamentaux des conteneurs. Elles sont immuables, des modèles en lecture seule contenant tout ce qui est nécessaire pour exécuter une application, y compris le système d’exploitation, le code de l’application, l’environnement d’exécution et les dépendances.

Les images sont construites à l’aide d’un Dockerfile, qui définit les instructions pour créer une image couche par couche.

Les images peuvent être stockées et récupérées depuis des registres de conteneurs tels que Docker Hub.

Voici quelques commandes exemples pour travailler avec les images :

• docker pull nginx : Récupérer la dernière image Nginx depuis Docker Hub.
• docker images : Lister toutes les images disponibles sur la machine locale.
• docker rmi nginx : Supprimer une image de la machine locale.

Conteneurs Docker

Un conteneur Docker est une instance en cours d’exécution d’une image Docker. Les conteneurs fournissent un environnement d’exécution isolé où les applications peuvent s’exécuter sans interférer les unes avec les autres ou avec le système hôte. Chaque conteneur a son propre système de fichiers, son propre réseau et son propre espace de processus, mais partage le noyau de l’hôte.

Les conteneurs suivent un cycle de vie simple impliquant la création, le démarrage, l’arrêt et la suppression. Voici un aperçu des commandes courantes de gestion des conteneurs :

1. Création d’un conteneur : docker create ou docker run
2. Démarrage d’un conteneur : docker start
3. Arrêt d’un conteneur : docker stop
4. Redémarrage d’un conteneur : docker restart
5. Suppression d’un conteneur : docker rm

Voyons un exemple pratique. La commande suivante lance un conteneur Nginx en mode détaché (en cours d’exécution en arrière-plan), en mappant le port 80 à l’intérieur du conteneur sur le port 8080 de la machine hôte :

docker run -d -p 8080:80 nginx

Après avoir exécuté cette commande, Docker tirera l’image Nginx (si elle n’est pas déjà disponible), créera un conteneur et le démarrera.

Pour vérifier tous les conteneurs en cours d’exécution et arrêtés :

docker ps -a

Cela affichera une liste de tous les conteneurs et de détails tels que leur statut et les ports attribués.

Docker Hub

Docker Hub est un service de registre basé sur le cloud pour trouver, stocker et distribuer des images de conteneurs. Les utilisateurs peuvent pousser des images personnalisées vers Docker Hub et les partager publiquement ou en privé.

Voici quelques commandes pour interagir avec Docker Hub :

• docker login : Authentification avec Docker Hub.
• docker push my-image : Mettre en ligne une image personnalisée sur Docker Hub.
• docker search ubuntu : Rechercher des images officielles et communautaires.
• docker pull ubuntu : Télécharger une image Ubuntu depuis Docker Hub.

Nouveau dans la conteneurisation ? Obtenez une base solide avec le cours Concepts de Conteneurisation et de Virtualisation.

Exécution de Votre Premier Conteneur Docker

Maintenant que nous avons couvert les concepts de base de Docker, il est temps de les mettre en pratique ! Commençons par exécuter notre premier conteneur pour vérifier que Docker est correctement installé et fonctionne comme prévu.

Pour tester votre installation Docker, ouvrez PowerShell (Windows) ou Terminal (Mac et Linux) et exécutez :

docker run hello-world

Cela extrait l’image hello-world de DockerHub et l’exécute dans un conteneur.

Exemple d’image Docker hello-world

Maintenant, allons plus loin et exécutons une application du monde réel : un serveur web Nginx. Exécutez la commande suivante :

docker run -d -p 8080:80 nginx

La commande ci-dessus fait ce qui suit :

• Le drapeau -d exécute le conteneur en mode détaché, ce qui signifie qu’il s’exécute en arrière-plan.
• Le drapeau -p 8080:80 mappe le port 80 à l’intérieur du conteneur sur le port 8080 de votre machine locale, vous permettant d’accéder au serveur web.

Une fois que la commande s’exécute avec succès, ouvrez un navigateur et visitez : http://localhost:8080

Accès au serveur web à localhost:8080

Vous devriez voir la page d’accueil par défaut de Nginx, confirmant que votre serveur web s’exécute à l’intérieur d’un conteneur !

Vous verrez également un conteneur s’exécutant dans votre Docker Desktop :

Conteneur Nginx s’exécutant sur le port 8080

Construction de votre première image Docker

Jusqu’à présent, nous avons utilisé des images préconstruites provenant de Docker Hub. Mais que faire si vous avez besoin d’un environnement personnalisé adapté à votre application? C’est là qu’intervient la création de votre propre image Docker.

Créer une image Docker implique d’écrire un Dockerfile, un script qui automatise la construction de l’image. Cela garantit la cohérence et la portabilité sur différents environnements. Une fois qu’une image est construite, elle peut être exécutée en tant que conteneur pour exécuter des applications dans un environnement isolé.

Dans cette section, nous allons apprendre les principes fondamentaux de l’écriture d’un Dockerfile, de la construction d’une image personnalisée et de son exécution en tant que conteneur.

Notions de base du Dockerfile

Un Dockerfile est un script contenant une série d’instructions qui définissent comment une image Docker est construite. Il automatise le processus de création de l’image, assurant une cohérence à travers les environnements. Chaque instruction dans un Dockerfile crée une nouvelle couche dans l’image. Voici un exemple de Dockerfile pour une application Python Flask simple :

# Image de base contenant l'exécution de Python
FROM python:3.9

# Définir le répertoire de travail à l'intérieur du conteneur
WORKDIR /app

# Copier les fichiers de l'application de l'hôte vers le conteneur
COPY . /app

# Installer les dépendances répertoriées dans requirements.txt
RUN pip install -r requirements.txt

# Définir la commande pour exécuter l'application Flask lorsque le conteneur démarre
CMD ["python", "app.py"]

Dans la commande ci-dessus :

• -v my-volume:/app/data monte le stockage my-volume dans le répertoire /app/data à l’intérieur du conteneur.
• Toute donnée stockée dans /app/data persistera même si le conteneur s’arrête ou est supprimé.

Décomposition du Dockerfile ci-dessus :

• FROM python:3.9: Spécifie l’image de base avec Python 3.9 pré-installé.
• WORKDIR /app: Définit /app comme répertoire de travail à l’intérieur du conteneur.
• COPY . /app: Copie tous les fichiers du répertoire actuel de l’hôte vers /app dans le conteneur.
• RUN pip install -r requirements.txt: Installe toutes les dépendances requises à l’intérieur du conteneur.
• CMD ["python", "app.py"]: Définit la commande à exécuter lorsque le conteneur démarre.

Construction et exécution de l’image

Une fois que le Dockerfile est défini, vous pouvez construire et exécuter l’image en utilisant les commandes suivantes:

Étape 1: Construire l’image

docker build -t my-flask-app .

La commande ci-dessus:

• Utilise le répertoire actuel (.) comme contexte de construction.
• Lit le Dockerfile et exécute ses instructions.
• Marque (-t) l’image résultante comme mon-application-flask.

Étape 2: Exécuter l’image en tant que conteneur

docker run -d -p 5000:5000 my-flask-app

La commande ci-dessus:

• Exécute le conteneur en mode détaché (-d).
• Mappe le port 5000 à l’intérieur du conteneur sur le port 5000 de l’hôte (-p 5000:5000).

Une fois en cours d’exécution, vous pouvez accéder à l’application Flask en naviguant vers http://localhost:5000 dans un navigateur.

Volumes Docker et Persistance

Par défaut, les données à l’intérieur d’un conteneur Docker sont temporaires—une fois que le conteneur s’arrête ou est supprimé, les données disparaissent. Pour persister les données entre les redémarrages de conteneurs et les partager entre plusieurs conteneurs, Docker fournit des volumes, un mécanisme intégré pour gérer efficacement le stockage persistant.

Contrairement au stockage des données à l’intérieur du système de fichiers du conteneur, les volumes sont gérés séparément par Docker, ce qui les rend plus efficaces, flexibles et plus faciles à sauvegarder.

Dans la section suivante, nous explorerons comment créer et utiliser des volumes Docker pour garantir la persistance des données dans vos conteneurs.

Création et utilisation des volumes Docker

Étape 1 : Créer un volume

Avant d’utiliser un volume, nous devons en créer un. Exécutez la commande suivante :

docker volume create my-volume

Cela crée un volume nommé my-volume, que Docker gérera séparément de tout conteneur spécifique.Étape 2 : Utiliser le volume dans un conteneur

Maintenant, commençons par créer un conteneur et monter le volume à l’intérieur :

docker run -d -v my-volume:/app/data my-app

Dans la commande ci-dessus :

• -v my-volume:/app/data monte le stockage my-volume dans le répertoire /app/data à l’intérieur du conteneur.
• Toutes les données stockées dans /app/data persisteront même si le conteneur s’arrête ou est supprimé.

Docker Compose pour les applications multi-conteneurs

Jusqu’à présent, nous avons travaillé avec des applications à conteneur unique, mais de nombreuses applications du monde réel nécessitent plusieurs conteneurs pour fonctionner ensemble. Par exemple, une application web pourrait avoir besoin d’un serveur backend, d’une base de données et d’une couche de mise en cache, chacun fonctionnant dans son propre conteneur. Gérer ces conteneurs manuellement avec des commandes docker run séparées peut rapidement devenir fastidieux.

C’est là que Docker Compose entre en jeu.

Qu’est-ce que Docker Compose ?

Docker Compose est un outil qui simplifie la gestion des applications multi-conteneurs. Au lieu d’exécuter plusieurs commandes docker run, vous pouvez définir l’ensemble d’une application en utilisant un fichier docker-compose.yml et le déployer avec une seule commande.

Rédiger un fichier Docker Compose

Maintenant, créons un exemple concret : une application Node.js simple qui se connecte à une base de données MongoDB. Au lieu de gérer les deux conteneurs séparément, nous allons les définir dans un fichier docker-compose.yml.

Voici comment nous définissons notre configuration multi-conteneurs dans Docker Compose :

version: '3'
services:
  web:
    build: .
    ports:
      - "3000:3000"
    depends_on:
      - database
  database:
    image: mongo
    volumes:
      - db-data:/data/db
volumes:
  db-data:

Décortiquons le fichier ci-dessus :

• version: '3' : Spécifie la version de Docker Compose.
• services: : Définit les services individuels (conteneurs).
• web: : Définit l’application web Node.js.
• database: : Définit le conteneur de base de données MongoDB.
• volumes: : Crée un volume nommé (db-data) pour la persistance des données MongoDB.

Exécution d’applications multi-conteneurs

Une fois le fichier docker-compose.yml prêt, nous pouvons lancer l’ensemble de l’application avec une seule commande :

docker-compose up -d

La commande précédente démarre à la fois les conteneurs web et de base de données en mode détaché (-d).

Pour arrêter tous les services, utilisez :

docker-compose down

Cela arrête et supprime tous les conteneurs tout en préservant les volumes et les paramètres réseau.

Principes de base du réseau Docker

Jusqu’à présent, nous nous sommes concentrés sur l’exécution des conteneurs et la gestion du stockage, mais que se passe-t-il lorsque les conteneurs ont besoin de communiquer entre eux ? Dans la plupart des applications du monde réel, les conteneurs n’opèrent pas en isolation – ils doivent échanger des données, que ce soit un serveur Web qui communique avec une base de données ou des microservices qui interagissent entre eux.

Docker propose une gamme d’options de réseau pour répondre à différents cas d’utilisation, allant des réseaux internes isolés aux configurations accessibles depuis l’extérieur.

Prêt à perfectionner vos compétences en Docker ? Inscrivez-vous à Docker Intermédiaire pour explorer les constructions multi-étapes, le réseau avancé, et plus encore !

Qu’est-ce que le réseau Docker ?

Le réseau Docker est une fonctionnalité intégrée qui permet aux conteneurs de communiquer entre eux, que ce soit sur le même hôte ou à travers plusieurs hôtes dans un environnement distribué. Il fournit une isolation réseau, une segmentation et des options de connectivité adaptées à différents scénarios de déploiement.

Docker prend en charge plusieurs types de réseaux, chacun répondant à des cas d’utilisation différents :

• Pont (par défaut) : Les conteneurs sur le même hôte communiquent à travers un réseau virtuel interne. Chaque conteneur obtient sa propre adresse IP privée au sein du réseau de pont, et ils peuvent se joindre via les noms des conteneurs.
• Exemple : docker network create mon-reseau-pont
• Idéal pour exécuter plusieurs conteneurs sur un seul hôte qui doivent communiquer de manière sécurisée sans exposer les services à l’extérieur.
• Hôte: Les conteneurs partagent la pile réseau de l’hôte et utilisent directement l’adresse IP et les ports de l’hôte.
• Exemple: docker run --network host nginx
• Utile lorsque vous avez besoin de hautes performances et que vous n’avez pas besoin d’isolation réseau, comme l’exécution d’agents de surveillance ou d’applications à faible latence.
• Superposition: Permet la communication entre conteneurs sur différents hôtes en créant un réseau distribué.
• Exemple : docker network create --driver overlay my-overlay-network
• Conçu pour des déploiements orchestrés comme Docker Swarm, où les services s’étendent sur plusieurs nœuds.
• Macvlan: Assigner une adresse MAC unique à chaque conteneur, le faisant apparaître comme un périphérique physique sur le réseau.
• Exemple: docker network create -d macvlan --subnet=192.168.1.0/24 my-macvlan
• Utilisé lorsque les conteneurs ont besoin d’un accès réseau direct, par exemple lors de l’intégration de systèmes hérités ou de l’interaction avec des réseaux physiques.

Exécution de conteneurs sur des réseaux personnalisés

Explorons comment configurer et utiliser un réseau de pont personnalisé pour la communication entre les conteneurs.

Étape 1: Créer un réseau personnalisé

Avant d’exécuter des conteneurs, nous devons d’abord créer un réseau dédié:

docker network create my-custom-network

Cette commande crée un réseau isolé auquel les conteneurs peuvent se joindre pour communiquer entre eux.

Étape 2 : Exécuter des conteneurs sur le réseau

Maintenant, démarrons deux conteneurs et connectons-les à notre réseau nouvellement créé :

docker run -d --network my-custom-network --name app1 my-app
docker run -d --network my-custom-network --name app2 my-app

• Le drapeau --network my-custom-network attache le conteneur au réseau spécifié.
• Le drapeau --name attribue un nom unique au conteneur, facilitant ainsi les références.

Les conteneurs app11 et app2 peuvent maintenant communiquer en utilisant leurs noms de conteneur. Vous pouvez tester la connectivité en utilisant la commande ping` à l’intérieur de l’un des conteneurs :

docker exec -it app1 ping app2

Si tout est configuré correctement, vous verrez une réponse confirmant que les conteneurs peuvent communiquer.

Inspection des réseaux Docker

Pour vérifier les configurations réseau et les conteneurs connectés, utilisez :

docker network inspect my-custom-network

Cette commande fournit des détails sur le réseau, y compris les plages IP, les conteneurs connectés et les configurations.

Exposition et publication de ports

Lors de l’exécution de conteneurs qui doivent être accessibles depuis l’extérieur, vous pouvez exposer des ports spécifiques.

Par exemple, pour exécuter un serveur web Nginx et l’exposer sur le port 8080 de votre machine locale, utilisez :

docker run -d -p 8080:80 nginx

Cela mappe le port 80 à l’intérieur du conteneur sur le port 8080 de l’hôte, rendant le service accessible via http://localhost:8080.

Pratiques recommandées pour le réseau Docker

• Utiliser des réseaux personnalisés : Évitez d’utiliser le réseau bridge par défaut pour les déploiements en production afin de réduire les accès non intentionnels entre les conteneurs.
• Tirer parti de la découverte basée sur le DNS: Au lieu de coder en dur des adresses IP, utilisez les noms des conteneurs pour permettre une découverte de service dynamique.
• Restreindre l’exposition externe: Utilisez des pare-feu ou des politiques réseau pour contrôler l’accès au service.
• Surveiller le trafic: Utilisez des outils tels que docker network inspect, Wireshark ou Prometheus pour analyser le trafic réseau et détecter les anomalies.
• Optimiser les réseaux superposés: Si vous déployez dans une configuration distribuée, ajustez les réseaux superposés pour réduire la latence en exploitant les options de routage locales à l’hôte.

Docker Best Practices and Next Steps

Maintenant que vous avez appris les bases de Docker, il est temps d’améliorer vos compétences et d’adopter les meilleures pratiques qui vous aideront à construire des applications conteneurisées sécurisées, efficaces et maintenables.

Les meilleures pratiques suivantes vous aideront à rationaliser vos flux de travail Docker et à éviter les pièges courants.

• Utilisez des images de base officielles: Préférez toujours les images de base officielles et bien entretenues pour garantir la sécurité et la stabilité. Les images officielles sont optimisées, régulièrement mises à jour et moins susceptibles de contenir des vulnérabilités.
• Gardez les images petites: Réduisez la taille de l’image en choisissant des images de base minimales (par exemple, python:3.9-slim au lieu de python:3.9). Supprimez les dépendances et fichiers inutiles pour optimiser le stockage et les temps de téléchargement.
• Utilisez des constructions multi-étapes: Optimisez les Dockerfiles en séparant les dépendances de construction et d’exécution. Les constructions multi-étapes garantissent que seuls les artefacts nécessaires sont inclus dans l’image finale, réduisant la taille et la surface d’attaque.
• Étiquetez correctement les images : Utilisez toujours des balises versionnées (par exemple, mon-app:v1.0.0) au lieu de dernier pour éviter les mises à jour inattendues lors de la récupération des images.
• Numérisez les images pour les vulnérabilités : Utilisez des outils de balayage de sécurité comme docker scan, Trivy ou Clair pour identifier et remédier aux vulnérabilités de sécurité dans vos images avant le déploiement.
• Gérez les variables d’environnement de manière sécurisée : Évitez de stocker des informations d’identification sensibles à l’intérieur des images. Utilisez des secrets Docker, des variables d’environnement ou des outils externes de gestion des secrets comme AWS Secrets Manager ou HashiCorp Vault.
• Utilisez des fichiers .dockerignore : Excluez les fichiers inutiles (par exemple .git, node_modules, venv) pour réduire la taille du contexte de construction et éviter l’inclusion accidentelle de fichiers sensibles dans les images.
• Activez le journalisation et la surveillance : Utilisez des outils tels que Prometheus, Grafana et Fluentd pour les journaux et la surveillance des conteneurs. Inspectez les journaux en utilisant docker logs et activez la journalisation structurée pour une meilleure observabilité.

Une fois que vous maîtrisez les bases de Docker, il existe de nombreux sujets avancés à explorer. Voici quelques domaines qui méritent d’être approfondis :

• Docker Swarm & Kubernetes: Explore Docker Swarm (clusterisation intégrée) et Kubernetes (orchestration de qualité professionnelle avec mise à l’échelle automatique et découverte de services) pour une orchestration de qualité professionnelle.
• Pratiques de sécurité des conteneurs: Pour sécuriser les applications conteneurisées, suivez les directives du CIS Docker Benchmark et mettez en œuvre le Contrôle d’Accès Basé sur les Rôles (RBAC).
• Des pipelines CI/CD avec Docker: Automatisez la construction d’images, les analyses de sécurité et les déploiements en utilisant GitHub Actions, GitLab CI ou Jenkins.
• Développement cloud-native: Exploitez Docker avec des plateformes cloud comme AWS ECS, Azure Container Instances et Google Cloud Run pour des déploiements évolutifs et gérés.
• Stratégies de persistance des données: Pour une gestion optimale du stockage, comprenez les différences entre les volumes Docker, les montages de type bind et tmpfs.

Conclusion

Docker a révolutionné la façon dont les développeurs construisent, expédient et exécutent des applications, en en faisant un outil essentiel pour le développement logiciel moderne.

Dans ce tutoriel, nous avons couvert :

• Ce qu’est Docker et pourquoi c’est important
• Comment installer et exécuter votre premier conteneur
• Les concepts clés tels que les images, les conteneurs et le réseau
• Stockage persistant avec les volumes Docker
• Applications multi-conteneurs avec Docker Compose
• Meilleures pratiques en matière de sécurité, de performance et de scalabilité

Mais ce n’est que le début! Si vous souhaitez approfondir vos compétences en Docker, vous pouvez suivre un cours d’introduction au Docker pour débutants. Pour des connaissances plus approfondies, vous pouvez suivre un cours intermédiaire sur Docker qui couvre les constructions multi-étapes, les outils de réseau Docker et Docker Compose. Enfin, vous pouvez également obtenir une certification Docker, consultez Le guide complet de certification Docker (DCA) pour 2025 si vous êtes intéressé!