Docker pour les débutants : Guide pratique des conteneurs

Concepts de base de Docker

Maintenant que vous avez installé Docker, vous êtes peut-être impatient de vous lancer et de commencer à exécuter des conteneurs. Mais avant cela, il est important de comprendre quelques concepts clés qui sont à la base du travail de Docker. Ces concepts vous aideront à naviguer plus efficacement dans Docker et à éviter les pièges les plus courants pour les débutants.

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

Examinons chacun de ces concepts plus en détail.

Images Docker

Les images Docker sont les éléments fondamentaux des conteneurs. Il s'agit de modèles immuables, en lecture seule, contenant tout ce qui est nécessaire à l'exécution d'une application, y compris le système d'exploitation, le code de l'application, la durée d'exécution et les dépendances.

Les images sont construites à l'aide d'un site Dockerfile, qui définit les instructions de création d'une image couche par couche.

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

Voici quelques exemples de commandes pour travailler avec des images :

• docker pull nginx: Récupérez la dernière image de Nginx depuis Docker Hub.
• docker images: Liste toutes les images disponibles sur la machine locale.
• docker rmi nginx: Supprimez 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é dans lequel les applications peuvent fonctionner sans interférer les unes avec les autres ou avec le système hôte. Chaque conteneur possède son propre système de fichiers, son propre réseau et son propre espace de processus, mais partage le noyau hôte.

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

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

Prenons un exemple concret. La commande suivante exécute un conteneur Nginx en mode détaché (en arrière-plan), en faisant correspondre le port 80 à l'intérieur du conteneur au port 8080 sur la machine hôte :

docker run -d -p 8080:80 nginx

Après avoir exécuté cette commande, Docker récupère l'image de Nginx (si elle n'est pas déjà disponible), crée un conteneur et le démarre.

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

docker ps -a

Vous obtiendrez ainsi une liste de tous les conteneurs et des détails tels que leur statut et les ports qui leur ont été attribués.

Hub Docker

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

Voici quelques commandes pour interagir avec Docker Hub :

• docker login: Authentifiez-vous avec Docker Hub.
• docker push my-image: Téléchargez une image personnalisée sur Docker Hub.
• docker search ubuntu: Recherchez des images officielles et communautaires.
• docker pull ubuntu: Téléchargez une image Ubuntu depuis Docker Hub.

Vous êtes novice en matière de conteneurisation ? Obtenez une base solide avec le cours Containerization and Virtualization Concepts (Concepts de conteneurisation et de virtualisation ).

Exécuter votre premier conteneur Docker

Maintenant que nous avons abordé les concepts fondamentaux de Docker, il est temps de les mettre en pratique ! Commençons par lancer notre premier conteneur pour nous assurer que Docker est installé correctement et qu'il 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 permet d'extraire l'image hello-world de DockerHub et de l'exécuter dans un conteneur.

Exemple d'image Docker hello-world

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

docker run -d -p 8080:80 nginx

La commande ci-dessus permet d'effectuer les opérations suivantes :

• L'option -d permet d'exécuter le conteneur en mode détaché, c'est-à-dire en arrière-plan.
• Le drapeau -p 8080:80 fait correspondre le port 80 à l'intérieur du conteneur au port 8080 sur votre machine locale, ce qui vous permet d'accéder au serveur web.

Une fois la commande exécutée avec succès, ouvrez un navigateur et visitez le site : http://localhost:8080

Accès au serveur web sur localhost:8080

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

Vous verrez également un conteneur s'exécuter dans votre Docker Desktop :

Conteneur Nginx fonctionnant sur le port 8080

Construire votre première image Docker

Jusqu'à présent, nous avons exécuté des images préconstruites à partir de Docker Hub. Mais qu'en est-il si vous avez besoin d'un environnement personnalisé adapté à votre application ? C'est là que la construction de votre propre image Docker entre en jeu.

La création d'une image Docker implique l'écriture d'un Dockerfile, un script qui automatise la construction d'une image. Cela garantit la cohérence et la portabilité dans différents environnements. Une fois l'image construite, elle peut être utilisée comme conteneur pour exécuter des applications dans un environnement isolé. 

Dans cette section, nous allons apprendre les bases de l'écriture d'un fichier Docker, de la construction d'une image personnalisée et de son exécution en tant que conteneur.

Les bases de 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 d'images, garantissant ainsi la cohérence entre les environnements. Chaque instruction dans un site Dockerfile crée une nouvelle couche dans l'image. Voici la décomposition d'un exemple de fichier Docker pour une simple application Python Flask :

# Base image containing Python runtime
FROM python:3.9

# Set the working directory inside the container
WORKDIR /app

# Copy the application files from the host to the container
COPY . /app

# Install the dependencies listed in requirements.txt
RUN pip install -r requirements.txt

# Define the command to run the Flask app when the container starts
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.
• Toutes les données stockées sur /app/data seront conservées même si le conteneur s'arrête ou est supprimé.

Décomposition du fichier Docker 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 courant de l'hôte vers /app dans le conteneur.
• RUN pip install -r requirements.txt: Installe toutes les dépendances nécessaires dans le conteneur.
• CMD ["python", "app.py"]: Définit la commande à exécuter au démarrage du conteneur.

Construction et exécution de l'image

Une fois le fichier Docker défini, vous pouvez construire et exécuter l'image à l'aide des commandes suivantes :

Étape 1 : Construire l'image

docker build -t my-flask-app .

La commande ci-dessus :

• Utilise le répertoire courant (.) comme contexte de construction.
• Lit le site Dockerfile et exécute ses instructions.
• Tags (-t) l'image résultante est my-flask-app.

Étape 2 : Exécutez 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).
• Le port 5000 à l'intérieur du conteneur est relié au port 5000 de l'hôte (-p 5000:5000).

Une fois lancée, 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 contenues dans un conteneur Docker sont temporaires- lorsque le conteneur s'arrête ou est supprimé, les données disparaissent. Pour conserver 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 dans le système de fichiers du conteneur, les volumes sont gérés séparément par Docker, ce qui les rend plus efficaces, plus flexibles et plus faciles à sauvegarder.

Dans la prochaine section, nous verrons comment créer et utiliser des volumes Docker pour assurer la persistance des données dans vos conteneurs.

Création et utilisation de 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, démarrons un conteneur et montons 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 sur /app/data seront conservées 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 à un seul conteneur, mais de nombreuses applications réelles nécessitent que plusieurs conteneurs fonctionnent ensemble. Par exemple, une application web peut avoir besoin d'un serveur dorsal, d'une base de données et d'une couche de mise en cache, chacun fonctionnant dans son propre conteneur. La gestion manuelle de ces conteneurs à l'aide de commandes docker run distinctes peut rapidement devenir fastidieuse.

C'est là que Docker Compose intervient.

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 une pile d'applications complète à l'aide d'un fichier docker-compose.yml et la déployer à l'aide d'une seule commande.

Écrire un fichier Docker Compose

Créons maintenant un exemple concret : une simple application Node.js qui se connecte à une base de données MongoDB. Au lieu de gérer les deux conteneurs séparément, nous les définirons 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écomposition du 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 que le fichier docker-compose.yml est prêt, nous pouvons lancer l'ensemble de la pile d'applications à l'aide d'une seule commande :

docker-compose up -d

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

Pour arrêter tous les services, utilisez :

docker-compose down

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

Les bases de la mise en 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 doivent communiquer entre eux ? Dans la plupart des applications réelles, les conteneurs ne fonctionnent pas de manière isolée : ils doivent échanger des données, qu'il s'agisse d'un serveur web qui communique avec une base de données ou de microservices qui interagissent les uns avec les autres.

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

Prêt à améliorer vos compétences en matière de Docker ? Inscrivez-vous au cours Docker intermédiaire pour découvrir les constructions en plusieurs étapes, la mise en réseau avancée, et bien plus encore !

Qu'est-ce que la mise en réseau Docker ?

La mise en 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 sur plusieurs hôtes dans un environnement distribué. Il offre des options d'isolation, de segmentation et de connectivité du réseau 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 :

• Bridge (par défaut) : Les conteneurs situés sur le même hôte communiquent par l'intermédiaire d'un réseau virtuel interne. Chaque conteneur reçoit une adresse IP privée au sein du réseau de passerelles, et ils peuvent se joindre les uns les autres par le biais des noms de conteneurs.
• Exemple : docker network create my-bridge-network
• Idéal pour l'exécution de plusieurs conteneurs sur un seul hôte qui doivent communiquer en toute sécurité 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 performances élevées et que vous n'avez pas besoin d'isoler le réseau, par exemple lorsque vous exécutez des agents de surveillance ou des applications à faible latence.
• Superposition: Permet la communication des 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 les déploiements orchestrés comme Docker Swarm, où les services s'étendent sur plusieurs nœuds.
• Macvlan: Attribue une adresse MAC unique à chaque conteneur, le faisant apparaître comme un appareil 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 direct au réseau, par exemple lors de l'intégration de systèmes existants ou de l'interaction avec des réseaux physiques.

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

Nous allons voir comment mettre en place et utiliser un réseau 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é que les conteneurs peuvent rejoindre pour communiquer entre eux.

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

Démarrons maintenant 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

• L'option --network my-custom-network rattache le conteneur au réseau spécifié.
• Le drapeau --name attribue un nom de conteneur unique, ce qui facilite le référencement.

Les deux app11 and app2 can now communicate using their container names. You can test the connectivity using the ping` command à l'intérieur d'un des conteneurs :

docker exec -it app1 ping app2

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

Inspection des réseaux Docker

Pour vérifier les configurations du 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.

Exposer et publier des ports

Lorsque vous utilisez des conteneurs qui doivent être accessibles à 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 permet de faire correspondre le port 80 à l'intérieur du conteneur au port 8080 sur l'hôte, ce qui rend le service accessible via http://localhost:8080.

Meilleures pratiques pour la mise en réseau de Docker

• Utilisez des réseaux personnalisés: Évitez d'utiliser le réseau de pont par défaut pour les déploiements de production afin de réduire l'accès involontaire entre les conteneurs.
• Exploiter la découverte basée sur le DNS: Au lieu de coder en dur les adresses IP, utilisez les noms de conteneurs pour permettre la découverte dynamique des services.
• Limiter l'exposition externe: Utilisez des pare-feu ou des politiques de réseau pour contrôler l'accès aux services.
• Surveillez le trafic: Utilisez des outils tels que docker network inspect, Wireshark ou Prometheus pour analyser le trafic réseau et détecter les anomalies.
• Optimisez les réseaux superposés: En cas de déploiement dans une configuration distribuée, réglez les réseaux superposés pour réduire la latence en exploitant les options de routage local de l'hôte.

Meilleures pratiques Docker et prochaines étapes

Maintenant que vous avez appris les principes fondamentaux de Docker, il est temps d'améliorer vos compétences et d'adopter les meilleures pratiques qui vous aideront à créer des applications conteneurisées sécurisées, efficaces et faciles à maintenir.

Les meilleures pratiques suivantes vous aideront à rationaliser vos flux de travail Docker et à éviter les pièges les plus 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.
• Veillez à ce que les images soient de petite taille : Réduisez la taille des images en choisissant des images de base minimales (par exemple, python:3.9-slim au lieu de python:3.9). Supprimez les dépendances et les fichiers inutiles afin d'optimiser le stockage et les temps d'extraction.
• Utilisez des constructions en plusieurs étapes : Optimisez les fichiers Docker en séparant les dépendances de construction et d'exécution. Les constructions en plusieurs étapes garantissent que seuls les artefacts nécessaires sont inclus dans l'image finale, ce qui réduit la taille et la surface d'attaque.
• Baliser correctement les images : Utilisez toujours des balises versionnées (par exemple, my-app:v1.0.0) au lieu de latest pour éviter les mises à jour inattendues lors de l'extraction d'images.
• Recherchez les vulnérabilités dans les images : Utilisez des outils d'analyse de sécurité tels que docker scan, Trivy ou Clair pour identifier et corriger les failles de sécurité de vos images avant leur déploiement.
• Gérez les variables d'environnement en toute sécurité : Évitez de stocker des informations d'identification sensibles dans des images. Utilisez des secrets Docker, des variables d'environnement ou des outils de gestion de secrets externes tels que AWS Secrets Manager ou HashiCorp Vault.
• Utilisez les fichiers .dockerignore : Excluez les fichiers inutiles (par exemple, .git, node_modules, venv) afin de réduire la taille du contexte de construction et d'éviter l'inclusion accidentelle de fichiers sensibles dans les images.
• Activer la journalisation et la surveillance : Utilisez des outils tels que Prometheus, Grafana et Fluentd pour les journaux et la surveillance des conteneurs. Inspectez les journaux à l'aide de docker logs et activez la journalisation structurée pour une meilleure observabilité.

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

• Docker Swarm et Kubernetes: Découvrez Docker Swarm (clustering intégrég) et Kubernetes (orchestration de niveau entreprise avec mise à l'échelle automatique et découverte de services) pour une orchestration de niveau production.
• Meilleures pratiques en matière de sécurité des conteneurs: Pour sécuriser les applications conteneurisées, suivez les directives du CIS Docker Benchmark et mettez en place un contrôle d'accès basé sur les rôles (RBAC).
• Pipelines CI/CD avec Docker: Automatisez la création d'images, les analyses de sécurité et les déploiements à l'aide de GitHub Actions, GitLab CI ou Jenkins.
• Développement cloud-natif: 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 bind et les tmpfs.

Conclusion

Docker a révolutionné la façon dont les développeurs construisent, livrent et exécutent les applications, ce qui en fait un outil essentiel pour le développement de logiciels modernes.

Dans ce tutoriel, nous avons abordé les sujets suivants :

• Qu'est-ce que Docker et pourquoi est-ce important ?
• Comment installer et faire fonctionner votre premier conteneur
• Des concepts clés comme les images, les conteneurs et la mise en réseau
• Stockage persistant avec les volumes Docker
• Applications multi-conteneurs avec Docker Compose
• Meilleures pratiques en matière de sécurité, de performances et d'évolutivité

Mais ce n'est que le début ! Si vous souhaitez approfondir votre expertise Docker, vous pouvez suivre un cours d'introduction à Docker pour débutants sur . Pour des connaissances plus approfondies, vous pouvez suivre un cours Docker intermédiaire qui couvre les constructions en plusieurs étapes, les outils de mise en réseau Docker et Docker Compose. Enfin, vous pouvez également poursuivre la certification Docker, consultez le Guide complet de la certification Docker (DCA) pour 2025 si vous êtes intéressé !