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.

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.

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.

‍

‍