Jour 2 – Conteneurisation avec Docker & Docker Compose

Jour 2 — Conteneurisation avec Docker & Docker Compose
Formation DevOps & SRE · CNSS · 20h–22h · 75% pratique / 25% théorie
Voir les objectifs
Objectifs pédagogiques
Ce que vous allez maîtriser aujourd'hui
À l'issue de cette session de 2 heures, vous serez capables de comprendre les fondements de la conteneurisation, de créer et lancer vos premiers conteneurs Docker, et d'orchestrer plusieurs services avec Docker Compose.
Comprendre Docker
Saisir le concept de conteneurisation et pourquoi il révolutionne le déploiement applicatif.
Lancer un conteneur
Exécuter vos premières commandes Docker et interagir avec des conteneurs en cours d'exécution.
Dockeriser une app
Créer un Dockerfile et construire une image personnalisée pour une application réelle.
Docker Compose
Orchestrer plusieurs services (web, API, base de données) avec un seul fichier de configuration.
🕒 Agenda
Déroulé de la session — 2 heures
Une progression structurée alliant théorie essentielle et ateliers pratiques intensifs, conçue pour maximiser l'apprentissage en conditions réelles.
1
10 min
Rappel Jour 1 & transition Git → Docker
2
20 min
Théorie : concepts clés Docker
3
20 min
Atelier 1 : lancer un conteneur
4
40 min
Atelier 2 : Dockeriser une app CNSS
5
20 min
Docker Compose : théorie + pratique
6
10 min
Conclusion, devoir & Q&A
Le problème classique
"Ça marche sur ma machine…"
Le syndrome bien connu
Un développeur livre son code. Les tests passent localement. Mais en production, tout s'effondre. Versions de librairies différentes, OS incompatibles, variables d'environnement manquantes…
Ce scénario coûte des heures de débogage et fragilise la confiance entre les équipes Dev et Ops.
Les causes fréquentes
Versions de runtimes différentes (Node, Java, Python…)
Dépendances installées manuellement et non documentées
Configurations système spécifiques à chaque machine
Variables d'environnement absentes ou incorrectes
Systèmes d'exploitation hétérogènes (Windows, macOS, Linux)
Sans standardisation, chaque déploiement devient un pari risqué.
La solution Docker
Le conteneur : votre environnement portable
Docker résout le problème de l'environnement en empaquetant l'application avec toutes ses dépendances dans une unité portable et reproductible appelée conteneur. Peu importe où il tourne, le comportement est identique.
"Git gère le code. Docker gère l'environnement."
— Philosophie DevOps fondamentale
🖼️ Image Docker
Le modèle immuable de votre application. Comme une recette de cuisine figée, elle contient tout ce qu'il faut pour créer un conteneur.
📦 Container
L'instance en cours d'exécution d'une image. Léger, isolé, démarrable en secondes — c'est votre application qui tourne.
📄 Dockerfile
Le fichier de recette qui décrit comment construire l'image, étape par étape, de manière déclarative et reproductible.
Architecture
Comment Docker fonctionne
Contrairement à une machine virtuelle qui embarque un système d'exploitation complet, un conteneur Docker partage le noyau du système hôte. Il est donc beaucoup plus léger, plus rapide à démarrer et moins gourmand en ressources.
Cette architecture allégée est ce qui rend Docker si populaire dans les environnements DevOps modernes, permettant de déployer des dizaines de services sur un seul serveur.
Atelier 1
Lancer vos premiers conteneurs
Pas de meilleure façon d'apprendre Docker que de taper les premières commandes. Commençons par le classique hello-world, puis lançons un vrai serveur web Nginx en moins d'une minute.
Étape 1 — Vérifier l'installation
docker run hello-world
Docker télécharge l'image, crée un conteneur, affiche un message de confirmation, puis s'arrête. C'est votre premier conteneur !
Étape 2 — Lancer un serveur Nginx
docker run -p 8080:80 nginx
Le flag -p 8080:80 mappe le port 80 du conteneur sur le port 8080 de votre machine hôte.
Ouvrez votre navigateur sur http://localhost:8080 — Nginx répond ! 🎉
Comprendre le port mapping
La notation -p HOST:CONTAINER est fondamentale :
HOST : le port accessible depuis votre machine
CONTAINER : le port interne dans le conteneur
Commandes utiles
docker ps # Conteneurs actifs
docker ps -a # Tous les conteneurs
docker stop ID # Arrêter un conteneur
docker rm ID # Supprimer un conteneur
docker images # Lister les images
Atelier 2 — Partie 1
Écrire son premier Dockerfile
Un Dockerfile est un fichier texte qui décrit, instruction par instruction, comment construire une image Docker. Il est versionnable avec Git et garantit que n'importe qui peut reconstruire l'image à l'identique.
Structure du Dockerfile
FROM nginx:alpine

COPY . /usr/share/nginx/html

EXPOSE 80
Ce Dockerfile minimaliste fait trois choses :
FROM : part de l'image officielle Nginx (version Alpine, ultra-légère)
COPY : copie vos fichiers HTML dans le dossier servi par Nginx
EXPOSE : documente que le conteneur écoute sur le port 80
Construire et lancer l'image
docker build -t cnss-teledeclaration .

docker run -p 8080:80 cnss-teledeclaration
Le flag -t nomme (tag) votre image. Le . indique que le contexte de build est le répertoire courant.
Résultat attendu : votre application est accessible sur http://localhost:8080 depuis n'importe quelle machine disposant de Docker !
Atelier 2 — Partie 2
Cas CNSS : Dockeriser la télé-déclaration
Appliquons Docker à un exemple concret inspiré du portail CNSS. Une application de télé-déclaration typique est constituée d'une page HTML statique servie par Nginx, représentant le frontend de l'application.
01
Créer le fichier index.html
Votre formulaire de télé-déclaration en HTML simple. Pas besoin d'un framework complexe pour commencer.
02
Écrire le Dockerfile
Utiliser FROM nginx:alpine et copier vos fichiers HTML dans le répertoire web de Nginx.
03
Builder l'image
Exécuter docker build -t cnss-teledeclaration . pour créer votre image personnalisée.
04
Lancer le conteneur
Démarrer avec docker run -p 8080:80 cnss-teledeclaration et vérifier dans le navigateur.
Docker Compose
Orchestrer plusieurs services ensemble
Dans la réalité, une application ne se résume pas à un seul service. Le portail CNSS nécessite un frontend, une API backend et une base de données — trois conteneurs qui doivent communiquer entre eux. Docker Compose simplifie radicalement cette gestion.
Le problème sans Compose
Lancer chaque conteneur manuellement
Configurer les réseaux à la main
Gérer les variables d'environnement séparément
Risque d'oublier un service au démarrage
La solution avec Compose
Un seul fichier docker-compose.yml décrit toute l'architecture. Une seule commande lance tout :
docker-compose up
Toute l'équipe partage le même fichier Compose — l'environnement est identique pour tous.
Exemple docker-compose.yml
version: '3'
services:
  web:
    image: nginx
    ports:
      - "8080:80"
  db:
    image: postgres
    environment:
      POSTGRES_PASSWORD: example
Ce fichier définit deux services :
web : serveur Nginx exposé sur le port 8080
db : base PostgreSQL avec mot de passe configuré
Architecture Docker Compose
Visualiser une stack multi-services
Docker Compose orchestre plusieurs conteneurs qui communiquent via un réseau virtuel interne, tout en exposant uniquement les ports nécessaires vers l'extérieur.
Le réseau interne Docker isole les services du monde extérieur. Seuls les ports explicitement mappés sont accessibles depuis l'hôte.
Cas concret CNSS
La télé-déclaration en architecture Docker
Appliquons Docker Compose à l'architecture réelle du portail CNSS. Ce cas concret illustre comment une application d'entreprise complexe peut être entièrement conteneurisée pour simplifier les déploiements et les tests.
🌐 Frontend
Serveur Nginx servant l'interface de télé-déclaration. Accessible sur le port 8080. Fichiers HTML/CSS/JS statiques ou application React buildée.
⚙️ Backend API
Application Java (Spring Boot) ou PHP exposant les endpoints REST pour la logique métier : validation, calcul des cotisations, enregistrement des déclarations.
🗄️ Base de données
Instance PostgreSQL persistante stockant les données des employeurs et leurs déclarations. Volume Docker pour la persistance des données.
Avec Docker Compose, n'importe quel développeur CNSS peut reproduire cet environnement complet en une commande, et tester localement dans des conditions identiques à la production.
✅ Bénéfices concrets
Ce que Docker apporte à la CNSS
L'adoption de Docker dans le contexte du secteur public et de la CNSS en particulier répond à des enjeux opérationnels très concrets, allant bien au-delà du simple confort des développeurs.
Fin du "ça marche chez moi"
L'image Docker embarque l'application ET son environnement. Le même conteneur tourne en développement, en recette et en production — sans surprise.
Environnements reproductibles
Un nouveau développeur rejoint l'équipe ? Il clone le repo, lance docker-compose up et est opérationnel en minutes, sans installer manuellement Java, PostgreSQL ou Node.
Base solide pour CI/CD
Les images Docker s'intègrent nativement dans les pipelines d'intégration continue. C'est le prérequis indispensable que nous approfondirons au Jour 3 de la formation.
Isolation et sécurité
Chaque service tourne dans son propre espace isolé. Une faille ou un crash dans un conteneur n'affecte pas les autres services de l'architecture.
📝 Devoir
Mise en pratique — À faire avant le Jour 3
Pour consolider les acquis de cette session, vous allez appliquer Docker et Docker Compose à une application de votre choix. Cet exercice est conçu pour être réalisable en 30 à 45 minutes.
🎯 Objectif du devoir
Dockeriser une petite application locale et la connecter à une base de données via Docker Compose.
Livrable attendu
Un Dockerfile fonctionnel pour votre app
Un docker-compose.yml avec app + base de données
Screenshot de l'app tournant dans le navigateur
Étapes suggérées
Choisir une petite app (HTML statique, ou l'exemple CNSS du cours)
Écrire le Dockerfile avec FROM nginx:alpine
Tester avec docker build puis docker run
Créer un docker-compose.yml ajoutant PostgreSQL
Lancer avec docker-compose up et vérifier
💡 Conseil : commencez simple. Un index.html servi par Nginx + une base PostgreSQL, c'est déjà une vraie stack !
Conclusion
Récapitulatif & cap sur le Jour 3
Vous avez parcouru en 2 heures l'essentiel de Docker — de la compréhension du problème jusqu'à l'orchestration multi-services. Ces compétences sont le socle de tout pipeline DevOps moderne.
Docker = Standardisation
Empaqueter l'application avec son environnement pour des déploiements cohérents et reproductibles, quel que soit le contexte.
Compose = Orchestration simple
Décrire et lancer une architecture multi-services complète (web + API + DB) avec un seul fichier et une seule commande.
Jour 3 = CI/CD
Fort de ces bases, nous automatiserons les tests et déploiements avec des pipelines d'intégration et livraison continues.
🎉 Bravo pour cette session ! Docker est maintenant dans votre boîte à outils DevOps. À demain pour le Jour 3 — CI/CD avec GitLab ou GitHub Actions !
Made with