Si vous évoluez dans le monde du développement web, vous avez forcément entendu parler de Docker. Derrière ce nom se cache l'une des technologies les plus transformatrices de ces dix dernières années : une plateforme de conteneurisation qui a profondément changé la façon dont les développeurs construisent, partagent et déploient leurs applications. C'est pourquoi Coda forme ses étudiants aux outils qui font vraiment la différence sur le terrain, et Docker en fait clairement partie. Que vous soyez débutant curieux ou développeur en reconversion, ce guide vous donne toutes les clés pour comprendre et utiliser Docker efficacement, tandis que notre glossaire réunit les termes essentiels pour comprendre Docker, des concepts fondamentaux jusqu'à l'orchestration à grande échelle, en passant par la construction d'images et l'intégration en CI/CD.

‍

Qu'est-ce que Docker et pourquoi l'utiliser ?

Docker est une plateforme open source qui permet d'empaqueter une application et toutes ses dépendances dans une unité standardisée appelée conteneur. Un conteneur fonctionne de manière isolée du reste du système, mais partage le noyau du système d'exploitation de la machine hôte — ce qui le rend bien plus léger qu'une machine virtuelle classique.

Le problème que Docker résout

Vous avez peut-être déjà vécu cette situation : une application fonctionne parfaitement sur votre machine, mais plante au moment du déploiement en production. Ou bien un collègue ne parvient pas à faire tourner votre projet parce que ses versions de Node.js, Python ou PostgreSQL diffèrent des vôtres. C'est ce que les développeurs appellent, non sans humour, le syndrome du "ça marche sur ma machine".

Docker résout ce problème à la racine : en encapsulant l'application avec exactement les versions des outils dont elle a besoin, le conteneur produit un environnement parfaitement reproductible, que ce soit sur un poste de développeur, un serveur de staging ou une infrastructure cloud.

Docker vs machines virtuelles

Une machine virtuelle (VM) émule un système d'exploitation complet, ce qui demande beaucoup de ressources. Docker, lui, partage le noyau Linux de la machine hôte et ne virtualise que ce qui est strictement nécessaire à l'application. Résultat : les conteneurs démarrent en quelques secondes, consomment moins de mémoire et sont bien plus faciles à distribuer. C'est une différence fondamentale que nous abordons dans nos cours d'architecture logicielle.

Le glossaire Docker

Le vocabulaire spécifique à Docker n'est pas toujours simple à appréhender. Nous vous guidons donc à travers les différents concepts dont vous aurez besoin pour naviguer dans cet univers.

Concepts fondamentaux

Conteneurisation

La conteneurisation est une technique qui consiste à empaqueter une application avec toutes ses dépendances (code, runtime, bibliothèques, configuration) dans une unité isolée et portable, exécutable de façon identique quel que soit l'environnement. C'est le principe fondateur derrière Docker, qui en a démocratisé l'usage auprès des développeurs à partir de 2013.

Docker Engine

Docker Engine est le moteur logiciel qui construit et exécute les conteneurs sur une machine. C'est le composant central de Docker, présent aussi bien en ligne de commande sur Linux que dans Docker Desktop sur Windows et macOS. Toutes les commandes docker que l'on tape en terminal s'adressent en réalité à ce moteur.

Image

Une image est un modèle en lecture seule qui contient tout ce qu'il faut pour faire tourner une application : le code, le runtime, les bibliothèques, les variables d'environnement et les fichiers de configuration. On peut la comparer à un moule à gâteau : l'image définit la forme, et chaque conteneur est un gâteau produit à partir de ce moule. Les images sont construites à partir d'un fichier texte appelé Dockerfile.

Conteneur

Un conteneur est une instance en cours d'exécution d'une image. Là où l'image est statique, le conteneur est vivant : il tourne, consomme des ressources et produit des résultats. On peut lancer plusieurs conteneurs à partir d'une même image, ce qui facilite la scalabilité d'une application, une notion déjà abordée dans notre glossaire AWS à propos d'EC2 et d'Auto Scaling.

Dockerfile

Un Dockerfile est un fichier texte qui contient une série d'instructions décrivant comment construire une image, étape par étape. Voici un exemple pour une application Node.js :

dockerfile

FROM node:20-alpine
WORKDIR /app
COPY package*.json ./
RUN npm install
COPY . .
EXPOSE 3000
CMD ["node", "server.js"]

Chaque instruction a un rôle précis : FROM définit l'image de base, WORKDIR fixe le répertoire de travail dans le conteneur, COPY copie des fichiers depuis la machine hôte, RUN exécute une commande pendant la construction, EXPOSE documente le port utilisé par l'application, et CMD définit la commande exécutée au démarrage du conteneur.

Layer

Docker construit les images par couches successives, appelées layers. Chaque instruction du Dockerfile crée un nouveau layer. Si un layer n'a pas changé depuis la dernière construction, Docker réutilise la version en cache, ce qui accélère considérablement les builds répétés. C'est pour cette raison que l'ordre des instructions dans un Dockerfile a un impact direct sur la rapidité de développement.

Virtualisation et machines virtuelles

Virtualisation

La virtualisation désigne le fait de faire tourner un environnement informatique (système d'exploitation, application) de façon isolée sur une machine physique, sans y avoir un accès direct. Docker est une forme de virtualisation légère, à distinguer de la virtualisation complète que proposent les machines virtuelles.

Machine virtuelle

Une machine virtuelle (VM) émule un système d'exploitation complet au-dessus du système hôte, ce qui demande beaucoup de ressources. Docker, lui, partage le noyau du système hôte et ne virtualise que ce qui est strictement nécessaire à l'application. Résultat : les conteneurs démarrent en quelques secondes, consomment moins de mémoire et sont bien plus faciles à distribuer qu'une VM. C'est une différence fondamentale que nous abordons dans notre Master of Science Architecture & Développement Logiciel.

Noyau partagé

Le noyau partagé (shared kernel) est le mécanisme qui permet à plusieurs conteneurs de fonctionner sur une même machine en utilisant tous le noyau du système d'exploitation hôte, plutôt que d'embarquer chacun leur propre noyau comme le ferait une machine virtuelle. C'est ce principe qui explique la légèreté des conteneurs par rapport aux VM, mais aussi une limite à connaître : un conteneur Linux ne peut pas tourner nativement sur un noyau Windows sans couche d'abstraction supplémentaire.

Stockage et distribution des images

Registre

Un registre (registry) est un service qui permet de stocker et de partager des images Docker. C'est l'équivalent d'un dépôt Git, mais pour des images plutôt que du code source. Les entreprises utilisent souvent des registres privés pour distribuer leurs images en interne de manière sécurisée, en complément ou à la place des registres publics.

Docker Hub

Docker Hub est le registre public officiel de Docker. Il héberge des millions d'images prêtes à l'emploi (serveurs web, bases de données, langages de programmation) que n'importe quel développeur peut télécharger et utiliser directement. C'est généralement le premier endroit où l'on cherche une image de base avant d'en construire une personnalisée.

Tag

Un tag est une étiquette attachée à une image, généralement utilisée pour indiquer sa version (par exemple node:20-alpine, où 20-alpine est le tag). Les tags permettent de figer précisément la version d'une image utilisée dans un projet, évitant les mauvaises surprises liées à une mise à jour automatique non maîtrisée.

Volume

Un volume est un espace de stockage géré par Docker qui permet de conserver des données au-delà du cycle de vie d'un conteneur. Par défaut, tout ce qui se passe à l'intérieur d'un conteneur disparaît quand il est supprimé : un volume permet à une base de données, par exemple, de conserver ses données même si le conteneur qui l'exécute est arrêté ou recréé.

.dockerignore

Le fichier .dockerignore fonctionne comme un .gitignore : il permet d'exclure certains fichiers ou dossiers (comme node_modules, .git, des fichiers de logs) du contexte envoyé à Docker lors de la construction d'une image. Cela allège les images produites et évite de copier accidentellement des données sensibles à l'intérieur.

Réseau

Port mapping

Le port mapping (ou redirection de port) permet de rendre accessible depuis la machine hôte un service qui tourne à l'intérieur d'un conteneur, en associant un port de la machine hôte à un port du conteneur. Par exemple, la commande suivante lance un serveur Nginx et redirige le port 8080 de la machine vers le port 80 du conteneur :

docker run -d -p 8080:80 nginx

Réseau bridge

Le réseau bridge est le mode réseau par défaut de Docker : il crée un réseau virtuel isolé permettant aux conteneurs de communiquer entre eux tout en restant séparés du réseau de la machine hôte, sauf redirection explicite de port. C'est le mode le plus couramment utilisé pour des applications composées de plusieurs conteneurs qui doivent dialoguer entre eux, une configuration réseau que nous détaillons dans notre Bachelor 3 Spécialisation Administrateur Systèmes et Réseaux.

Réseau host

Le réseau host permet à un conteneur de partager directement la pile réseau de la machine hôte, sans isolation réseau ni redirection de port nécessaire. Ce mode offre de meilleures performances réseau, mais réduit l'isolation entre le conteneur et l'hôte, ce qui en fait un choix à réserver à des cas d'usage précis plutôt qu'à un défaut systématique.

Construire une image

Build

Le build est l'opération qui consiste à construire une image à partir d'un Dockerfile. La commande suivante construit une image nommée mon-app-node à partir du Dockerfile présent dans le dossier courant :

docker build -t mon-app-node .

L'option -t permet de nommer l'image construite. Une fois l'image construite, on peut lancer un conteneur avec docker run -p 3000:3000 mon-app-node.

Multi-stage build

Le multi-stage build est une technique qui permet d'utiliser plusieurs étapes FROM dans un même Dockerfile, chacune pouvant servir à une phase différente (compilation, tests, production), pour ne conserver dans l'image finale que le strict nécessaire à l'exécution. Cette technique réduit fortement la taille des images en production, en excluant les outils de compilation ou de test qui n'ont plus d'utilité une fois l'application construite.

Image de base légère

Une image de base légère (comme les variantes Alpine ou Slim des images officielles, par exemple node:20-alpine plutôt que node:20) réduit considérablement la taille des images produites, accélère les téléchargements et diminue la surface d'attaque en termes de sécurité. C'est l'une des optimisations les plus simples et les plus efficaces à adopter dès le début d'un projet.

Cache de build

Le cache de build est le mécanisme qui permet à Docker de réutiliser les layers déjà construits lors d'un build précédent, tant que les instructions et les fichiers concernés n'ont pas changé. Pour en tirer pleinement parti, il est recommandé de placer dans le Dockerfile les instructions les moins susceptibles de changer en premier (comme l'installation des dépendances) et le code source, qui change plus souvent, en dernier.

Orchestration

Docker Compose

Docker Compose est un outil qui permet de définir et de lancer plusieurs conteneurs formant une même application, à partir d'un seul fichier de configuration au format YAML. Une architecture typique inclut par exemple un serveur web et une base de données, chacun décrit comme un service distinct :

yaml

services:
 web:
   build: .
   ports:
     - "3000:3000"
   depends_on:
     - db
 db:
   image: postgres:16
   volumes:
     - postgres_data:/var/lib/postgresql/data
volumes:
 postgres_data:

Une seule commande, docker compose up -d, suffit ensuite pour démarrer l'ensemble des services, et docker compose down pour tout arrêter proprement. C'est l'outil que nous recommandons à nos étudiants du Bachelor Informatique pour standardiser leurs environnements de développement en équipe.

Service

Dans le vocabulaire de Docker Compose, un service désigne un conteneur défini dans le fichier docker-compose.yml, avec sa propre configuration (image, ports, volumes, variables d'environnement). Plusieurs services peuvent communiquer entre eux directement par leur nom, sans configuration réseau supplémentaire, ce qui simplifie grandement la construction d'architectures multi-services, un enjeu que connaît bien tout Lead Développeur amené à concevoir ce type d'architecture.

Docker Swarm

Docker Swarm est l'outil natif de Docker pour orchestrer des conteneurs sur plusieurs machines, en gérant leur répartition, leur mise à l'échelle et leur haute disponibilité. Plus simple à prendre en main que Kubernetes, il reste une option pertinente pour des besoins d'orchestration modérés, sans la complexité d'un outil plus ambitieux.

Kubernetes

Kubernetes, souvent abrégé K8s, est l'orchestrateur de conteneurs le plus utilisé au monde. Là où Docker crée et exécute des conteneurs sur une seule machine, Kubernetes gère le déploiement, la mise à l'échelle et la haute disponibilité de nombreux conteneurs répartis sur plusieurs machines, appelées cluster. Les deux technologies sont complémentaires et souvent utilisées ensemble en production. Sur AWS, cette orchestration s'appuie notamment sur les services ECS et EKS déjà présentés dans notre glossaire AWS.

Sécurité et bonnes pratiques

Gestion des secrets

Les variables sensibles (clés API, mots de passe, tokens) ne doivent jamais apparaître directement dans un Dockerfile ni être intégrées dans une image. La bonne pratique consiste à les injecter au démarrage via des variables d'environnement, ou à passer par des outils dédiés comme Docker Secrets ou des solutions de gestion de secrets comme HashiCorp Vault. C'est un point de vigilance central pour tout administrateur système et réseaux responsable du déploiement d'applications conteneurisées.

Surface d'attaque

La surface d'attaque désigne l'ensemble des points par lesquels un système peut être compromis. En matière de conteneurs, elle augmente avec la quantité de logiciels installés dans l'image : un système d'exploitation complet et de nombreux outils installés offrent davantage de points d'entrée potentiels qu'une image minimale. C'est l'une des raisons pour lesquelles privilégier des images de base légères est aussi une pratique de sécurité, pas seulement une optimisation de performance.

‍

‍

‍Les concepts fondamentaux à maîtriser

Avant de se lancer dans la pratique, il est essentiel de comprendre les briques de base de Docker. Trois notions sont incontournables.

L'image Docker

Une image est un modèle en lecture seule qui contient tout ce qu'il faut pour faire tourner une application : le code, le runtime, les bibliothèques, les variables d'environnement et les fichiers de configuration. On peut la comparer à un moule à gâteau : l'image définit la forme, et chaque conteneur est un gâteau produit à partir de ce moule.

Les images sont construites à partir d'un fichier texte appelé Dockerfile, qui décrit les instructions de construction étape par étape.

Le conteneur

Un conteneur est une instance en cours d'exécution d'une image. Là où l'image est statique, le conteneur est vivant : il tourne, consomme des ressources et produit des résultats. On peut lancer plusieurs conteneurs à partir d'une même image, ce qui facilite la scalabilité d'une application.

Le registre d'images

Les images Docker peuvent être stockées et partagées via des registres. Le plus connu est Docker Hub, le registre public officiel qui héberge des millions d'images prêtes à l'emploi (serveurs web, bases de données, langages de programmation...). Les entreprises utilisent souvent des registres privés pour distribuer leurs images en interne de manière sécurisée.

Installer Docker et lancer votre premier conteneur

La prise en main de Docker est plus rapide qu'on ne le pense. Voici les étapes essentielles.

Installation

Docker est disponible sur Windows, macOS et Linux. La façon la plus simple de l'installer est de télécharger Docker Desktop, une interface graphique qui inclut Docker Engine, Docker Compose et un tableau de bord visuel pour gérer vos conteneurs.

Sur Linux, on peut également installer Docker Engine directement en ligne de commande via le gestionnaire de paquets de la distribution.

Votre première commande Docker

Une fois installé, ouvrez un terminal et lancez :

docker run hello-world

Cette commande demande à Docker de télécharger l'image hello-world depuis Docker Hub (si elle n'est pas déjà présente localement) et de l'exécuter dans un conteneur. Si tout s'est bien passé, vous verrez un message de bienvenue confirmant que Docker fonctionne correctement.

Lancer un serveur web en une ligne

Voici quelque chose de plus concret : lancer un serveur Nginx en une seule commande.

docker run -d -p 8080:80 nginx

• -d : démarre le conteneur en arrière-plan (mode détaché)
• -p 8080:80 : redirige le port 8080 de votre machine vers le port 80 du conteneur

Ouvrez ensuite votre navigateur sur http://localhost:8080 et vous verrez la page d'accueil de Nginx. En quelques secondes, sans rien installer globalement sur votre système.

Créer votre propre image avec un Dockerfile

Pour aller plus loin, vous aurez besoin de créer vos propres images adaptées à vos projets.

Anatomie d'un Dockerfile

Un Dockerfile est un fichier texte qui contient une série d'instructions. Voici un exemple pour une application Node.js :

dockerfile

FROM node:20-alpine

WORKDIR /app

COPY package*.json ./

RUN npm install

COPY . .

EXPOSE 3000

CMD ["node", "server.js"]

Décortiquons chaque instruction :

• FROM : définit l'image de base à partir de laquelle construire (ici, Node.js 20 dans sa version Alpine, très légère)
• WORKDIR : définit le répertoire de travail à l'intérieur du conteneur
• COPY : copie des fichiers depuis votre machine vers le conteneur
• RUN : exécute une commande pendant la construction de l'image (ici, l'installation des dépendances)
• EXPOSE : indique le port sur lequel l'application écoute
• CMD : définit la commande à exécuter au démarrage du conteneur

Construire et lancer l'image

Pour construire l'image à partir du Dockerfile, placez-vous dans le dossier du projet et lancez :

docker build -t mon-app-node .

Le -t permet de nommer l'image. Ensuite, pour lancer un conteneur depuis cette image :

docker run -p 3000:3000 mon-app-node

Votre application est maintenant accessible sur http://localhost:3000.

‍

‍

Docker Compose : orchestrer plusieurs services

Les applications modernes sont rarement composées d'un seul service. Une architecture typique inclut un serveur web, une base de données, un cache Redis... Docker Compose permet de définir et de lancer tous ces services en une seule commande.

Le fichier docker-compose.yml

Docker Compose repose sur un fichier de configuration au format YAML. Voici un exemple avec une application web et une base de données PostgreSQL :

yaml

services:

  web:

    build: .

    ports:

      - "3000:3000"

    depends_on:

      - db

    environment:

      DATABASE_URL: postgres://user:password@db:5432/mydb

‍

  db:

    image: postgres:16

    environment:

      POSTGRES_USER: user

      POSTGRES_PASSWORD: password

      POSTGRES_DB: mydb

    volumes:

      - postgres_data:/var/lib/postgresql/data

‍

volumes:

  postgres_data:

Ce fichier décrit deux services (web et db) qui peuvent communiquer entre eux par leur nom. Le volume postgres_data assure la persistance des données de la base, même si le conteneur est arrêté ou recréé.

Démarrer l'environnement

Une seule commande suffit pour démarrer tous les services :

docker compose up -d

Et pour tout arrêter proprement :

docker compose down

C'est précisément ce type d'outil que nous recommandons à nos étudiants en Bachelor Informatique pour standardiser leurs environnements de développement en équipe.

Les bonnes pratiques Docker à adopter

Maîtriser Docker, c'est aussi savoir l'utiliser intelligemment. Voici les pratiques qui font la différence en conditions réelles.

Utiliser des images de base légères

Préférez les variantes Alpine (par exemple node:20-alpine plutôt que node:20) ou Slim des images officielles. Ces versions allégées réduisent considérablement la taille des images, accélèrent les téléchargements et diminuent la surface d'attaque en termes de sécurité.

Tirer parti du cache des layers

Docker construit les images par couches successives (layers). Chaque instruction du Dockerfile crée un nouveau layer. Si un layer n'a pas changé, Docker réutilise la version en cache, ce qui accélère les builds. Pour en profiter, placez les instructions les moins susceptibles de changer en premier (comme l'installation des dépendances) et le code source à la fin.

Ne jamais stocker de secrets dans les images

Les variables sensibles (clés API, mots de passe, tokens) ne doivent jamais apparaître dans un Dockerfile ou être intégrées dans une image. Utilisez des variables d'environnement injectées au démarrage, ou des outils dédiés comme Docker Secrets ou des solutions de gestion de secrets comme HashiCorp Vault.

Utiliser un fichier .dockerignore

À l'image du .gitignore, le fichier .dockerignore permet d'exclure des fichiers inutiles (dossier node_modules, .git, fichiers de logs...) du contexte de build. Cela allège les images et évite de copier accidentellement des données sensibles.

Docker dans un workflow CI/CD

Docker s'intègre naturellement dans les pipelines d'intégration et de déploiement continus (CI/CD). Dans un workflow typique, chaque push sur le dépôt Git déclenche une série d'étapes automatisées : construction de l'image, exécution des tests dans un conteneur, puis déploiement vers l'environnement cible.

Des plateformes comme GitHub Actions, GitLab CI ou CircleCI offrent des intégrations natives avec Docker. L'image finale est ensuite poussée vers un registre (Docker Hub, AWS ECR, Google Container Registry...) depuis lequel les serveurs de production viennent la récupérer.

Cette approche garantit que chaque déploiement est reproductible et identique, de la machine du développeur à la production. C'est une compétence directement opérationnelle que nous transmettons dans nos formations, notamment dans le Master of Science Architecture & Développement Logiciel de Coda.

‍

Docker est aujourd'hui un standard incontournable dans le monde du développement web et du DevOps. Maîtriser la conteneurisation, c'est gagner en autonomie, en fiabilité et en efficacité — des qualités essentielles sur le marché du travail tech. Chez Coda, nous intégrons Docker dans notre pédagogie parce que nous formons des développeurs prêts à travailler en conditions réelles, pas seulement à écrire du code. Si vous souhaitez aller plus loin et acquérir les compétences techniques qui font la différence, découvrez nos formations en informatique ou téléchargez notre brochure.

‍

‍