Bye Bye Prof

Docker sous Windows

Introduction à la Technologie des Containers

Avec Docker sur Windows Server 2022



Table des matières

  1. Concepts fondamentaux
  2. Containers vs Machines Virtuelles
  3. Types de containers sous Windows
  4. Introduction à Docker
  5. Installation de Docker sur Windows Server 2022
  6. Images Docker
  7. Gestion des containers
  8. Réseaux Docker
  9. Volumes et persistance des données
  10. Docker Compose
  11. Sécurité et bonnes pratiques
  12. Scénarios d'usage en entreprise
  13. Exercices pratiques
  14. Ressources complémentaires

1. Concepts fondamentaux

Qu'est-ce qu'un container ?

Un container est une unité logicielle légère et portable qui regroupe une application avec toutes ses dépendances (bibliothèques, fichiers de configuration, variables d'environnement) dans un environnement isolé.

Contrairement à une machine virtuelle, un container partage le noyau du système d'exploitation hôte, ce qui le rend beaucoup plus léger et rapide à démarrer.

┌──────────────────────────────────────────────┐
│              APPLICATION                 │
│  ┌───────────┐  ┌───────────┐  ┌─────────┐  │
│  │  App A   │  │  App B   │  │ App C  │  │
│  │          │  │          │  │        │  │
│  │ Libs A   │  │ Libs B   │  │Libs C  │  │
│  └───────────┘  └───────────┘  └─────────┘  │
│         Container Engine (Docker)        │
│              OS Hôte (WS2022)            │
│              Matériel physique           │
└──────────────────────────────────────────────┘

Pourquoi utiliser des containers ?

Avantage Description
Portabilité « Build once, run anywhere » — fonctionne de la même façon partout
Isolation Chaque application est isolée des autres
Légèreté Démarrage en secondes, consommation réduite
Cohérence Même environnement en dev, test et production
Scalabilité Duplication rapide pour absorber la charge
CI/CD Intégration naturelle dans les pipelines DevOps

Terminologie clé


2. Containers vs Machines Virtuelles

Comparaison architecturale

MACHINES VIRTUELLES                    CONTAINERS
┌────────────────────────┐            ┌────────────────────────┐
│  App A  │  App B     │            │  App A  │  App B     │
│─────────│──────────────│            │─────────│──────────────│
│  OS A   │  OS B      │            │  Libs A │  Libs B    │
│─────────│──────────────│            │────────────────────────│
│      Hyperviseur     │            │     Docker Engine    │
│────────────────────────│            │────────────────────────│
│       OS Hôte        │            │       OS Hôte        │
│────────────────────────│            │────────────────────────│
│       Matériel       │            │       Matériel       │
└────────────────────────┘            └────────────────────────┘

Tableau de comparaison

Critère Machines Virtuelles Containers
Taille Go (souvent 10–50 Go) Mo (quelques Mo à quelques centaines de Mo)
Démarrage Minutes Secondes
Isolation Forte (OS complet séparé) Modérée (noyau partagé)
Performance Overhead lié à l'hyperviseur Quasi-native
Portabilité Limitée (format propriétaire) Très haute
Gestion Complexe Simplifiée
Cas d'usage Applications monolithiques Microservices, DevOps

Conseil : Les VMs et les containers ne sont pas opposés — ils sont complémentaires. Il est très courant d'exécuter des containers à l'intérieur de machines virtuelles.


3. Types de containers sous Windows

Windows Server 2022 supporte deux modes d'isolation pour les containers Docker.

3.1 Containers Windows (Process Isolation)

# Exemple : lancer un container Windows en isolation de processus
docker run --isolation=process mcr.microsoft.com/windows/servercore:ltsc2022

3.2 Containers Hyper-V (Hyper-V Isolation)

# Exemple : lancer un container en isolation Hyper-V
docker run --isolation=hyperv mcr.microsoft.com/windows/servercore:ltsc2019

3.3 Containers Linux sous Windows Server 2022

Depuis Windows Server 2022 avec les dernières mises à jour, il est possible d'exécuter des containers Linux via WSL 2 (Windows Subsystem for Linux 2).

Note importante : En environnement de production sur Windows Server 2022, les containers Windows natifs sont généralement préférés pour des raisons de support et de compatibilité.

Choisir le bon type d'isolation

         Besoin d'isolation maximale ?
                    │
             ┌──── OUI ────┐
             │              │
        Hyper-V         Compatible avec
        Isolation        hôte Linux ?
                              │
                    ┌─── OUI ┘
                    │
              Containers Linux
              (WSL2 ou Linux host)
                    │
                NON │
                    │
              Process Isolation
              (Windows natif)

4. Introduction à Docker

Historique et contexte

Docker a été lancé en 2013 par Solomon Hykes chez dotCloud. Il a révolutionné le déploiement logiciel en popularisant la containerisation. Aujourd'hui, Docker est le standard de facto pour la gestion de containers.

Architecture Docker

┌─────────────────────────────────────────────────────────┐
│                    CLIENT DOCKER                        │
│  docker build │ docker pull │ docker run │ docker push  │
└───────────────────────┬─────────────────────────────────┘
                        │  REST API
┌───────────────────────▼─────────────────────────────────┐
│                  DOCKER DAEMON (dockerd)                 │
│                                                         │
│  ┌─────────────┐  ┌──────────────┐  ┌───────────────┐  │
│  │ Containers │  │    Images   │ │    Réseaux    │  │
│  └─────────────┘  └──────────────┘  └───────────────┘  │
│                                                         │
│  ┌──────────────────────────────────────────────────┐   │
│  │              containerd / runc                   │   │
│  └──────────────────────────────────────────────────┘   │
└─────────────────────────────────────────────────────────┘
                        │
┌───────────────────────▼─────────────────────────────────┐
│                 DOCKER REGISTRY                         │
│         Docker Hub | Azure Container Registry           │
│         GitHub Container Registry | Registry privé      │
└─────────────────────────────────────────────────────────┘

Composants principaux


5. Installation de Docker sur Windows Server 2022

Prérequis système

Composant Requis
OS Windows Server 2022 (Standard ou Datacenter)
RAM 4 Go minimum, 8 Go recommandé
Disque 20 Go minimum pour les images
CPU 64 bits, virtualisation activée dans le BIOS
Rôle Hyper-V Requis pour l'isolation Hyper-V
PowerShell 5.1 ou supérieur

Étape 1 : Vérifier la version de Windows

# Vérifier la version exacte de l'OS
Get-WmiObject -Class Win32_OperatingSystem | Select-Object Caption, Version, BuildNumber

# Vérifier si Hyper-V est disponible
Get-WindowsOptionalFeature -Online -FeatureName Microsoft-Hyper-V

Étape 2 : Installer le rôle Containers

# Installer la fonctionnalité Containers (OBLIGATOIRE)
Install-WindowsFeature -Name Containers -Restart

# Optionnel : installer Hyper-V pour l'isolation Hyper-V
Install-WindowsFeature -Name Hyper-V -Restart

Étape 3 : Installer Docker Engine

# Méthode recommandée : via PowerShell Gallery
Install-Module -Name DockerMsftProvider -Repository PSGallery -Force

# Installer Docker
Install-Package -Name docker -ProviderName DockerMsftProvider -Force

# Redémarrer le serveur
Restart-Computer -Force

Étape 4 : Vérifier l'installation

# Vérifier la version de Docker
docker version

# Vérifier que le service Docker est démarré
Get-Service docker

# Tester avec un container de test
docker run mcr.microsoft.com/windows/nanoserver:ltsc2022 cmd /c echo "Hello from Docker!"

Étape 5 : Configurer le démarrage automatique

# Configurer Docker pour démarrer automatiquement
Set-Service -Name docker -StartupType Automatic

# Démarrer le service manuellement si nécessaire
Start-Service docker

Configuration du daemon Docker

Le fichier de configuration se trouve à l'emplacement :
C:\ProgramData\docker\config\daemon.json

{
  "data-root": "D:\\docker-data",
  "log-driver": "json-file",
  "log-opts": {
    "max-size": "10m",
    "max-file": "3"
  },
  "storage-driver": "windowsfilter",
  "dns": ["8.8.8.8", "8.8.4.4"],
  "insecure-registries": [],
  "registry-mirrors": []
}
# Redémarrer Docker après modification de la configuration
Restart-Service docker

Configuration du pare-feu Windows

# Autoriser les communications entre containers
New-NetFirewallRule -Name "Docker NAT" -DisplayName "Docker NAT" `
  -Protocol TCP -Direction Inbound -Action Allow `
  -LocalPort 2375,2376,2377,7946 -Enabled True

# Pour exposer des ports applicatifs (exemple : port 80)
New-NetFirewallRule -Name "Docker HTTP" -DisplayName "Docker HTTP" `
  -Protocol TCP -Direction Inbound -Action Allow `
  -LocalPort 80 -Enabled True

6. Images Docker

Comprendre les images

Une image Docker est composée de couches (layers) empilées et immuables. Chaque instruction dans un Dockerfile crée une nouvelle couche.

┌─────────────────────────┐  ← Couche applicative (votre app)
├─────────────────────────┤  ← Configuration et fichiers statiques
├─────────────────────────┤  ← Dépendances (ex : .NET Runtime)
├─────────────────────────┤  ← OS de base (ex : Windows Nano Server)
└─────────────────────────┘  ← Couche de base (scratch)

Images de base Microsoft recommandées

Image Taille Usage
mcr.microsoft.com/windows/nanoserver:ltsc2022 ~100 Mo Applications .NET légères, apps console
mcr.microsoft.com/windows/servercore:ltsc2022 ~4 Go Apps Windows classiques, IIS, .NET Framework
mcr.microsoft.com/windows/server:ltsc2022 ~5 Go Applications nécessitant l'OS complet
mcr.microsoft.com/dotnet/aspnet:8.0-nanoserver-ltsc2022 ~300 Mo Applications ASP.NET Core
mcr.microsoft.com/dotnet/runtime:8.0-nanoserver-ltsc2022 ~200 Mo Applications .NET 8
# Télécharger une image
docker pull mcr.microsoft.com/windows/servercore:ltsc2022

# Lister les images locales
docker images

# Inspecter une image
docker inspect mcr.microsoft.com/windows/servercore:ltsc2022

# Voir les couches d'une image
docker history mcr.microsoft.com/windows/servercore:ltsc2022

# Supprimer une image
docker rmi mcr.microsoft.com/windows/servercore:ltsc2022

Écrire un Dockerfile

Le Dockerfile est le fichier de recette pour construire une image.

Exemple : Application web IIS simple

# Image de base : Windows Server Core avec IIS
FROM mcr.microsoft.com/windows/servercore/iis:windowsservercore-ltsc2022

# Métadonnées
LABEL maintainer="admin@entreprise.com"
LABEL version="1.0"
LABEL description="Application web d'exemple"

# Supprimer le site par défaut IIS
RUN powershell -command `
    Remove-WebSite -Name 'Default Web Site'

# Créer le répertoire de l'application
RUN powershell -command `
    New-Item -Path 'C:\inetpub\monapp' -Type Directory

# Copier les fichiers de l'application
COPY ./app/ C:/inetpub/monapp/

# Créer le site IIS
RUN powershell -command `
    New-WebSite -Name 'MonApp' -Port 80 `
    -PhysicalPath 'C:\inetpub\monapp' -Force

# Exposer le port 80
EXPOSE 80

# Commande de démarrage
CMD ["C:\\ServiceMonitor.exe", "w3svc"]

Exemple : Application .NET 8

# Étape 1 : Build
FROM mcr.microsoft.com/dotnet/sdk:8.0-nanoserver-ltsc2022 AS build
WORKDIR /src

# Copier et restaurer les dépendances
COPY ["MonApp.csproj", "."]
RUN dotnet restore

# Copier le code source et compiler
COPY . .
RUN dotnet publish -c Release -o /app/publish

# Étape 2 : Runtime (image finale plus légère)
FROM mcr.microsoft.com/dotnet/aspnet:8.0-nanoserver-ltsc2022 AS final
WORKDIR /app

# Copier les fichiers compilés depuis l'étape build
COPY --from=build /app/publish .

# Exposer le port applicatif
EXPOSE 8080

# Point d'entrée de l'application
ENTRYPOINT ["dotnet", "MonApp.dll"]

Instructions Dockerfile principales

Instruction Description Exemple
FROM Image de base FROM mcr.microsoft.com/windows/nanoserver:ltsc2022
RUN Exécuter une commande lors du build RUN powershell -command Install-WindowsFeature Web-Server
COPY Copier des fichiers dans l'image COPY ./app C:/app
ADD Copier + extraire archives ADD app.zip C:/app
WORKDIR Définir le répertoire de travail WORKDIR C:/app
ENV Définir des variables d'environnement ENV APP_ENV=production
EXPOSE Documenter les ports exposés EXPOSE 80 443
ENTRYPOINT Commande principale du container ENTRYPOINT ["dotnet", "app.dll"]
CMD Arguments par défaut CMD ["--configuration", "Release"]
ARG Variables de build ARG VERSION=1.0
LABEL Métadonnées LABEL version="1.0"
VOLUME Déclarer un volume VOLUME C:/data
USER Utilisateur d'exécution USER ContainerUser

Construire et publier une image

# Construire une image
docker build -t monapp:1.0 .

# Construire avec des arguments
docker build --build-arg VERSION=2.0 -t monapp:2.0 .

# Tagger une image
docker tag monapp:1.0 registre.entreprise.com/monapp:1.0

# Se connecter à un registry privé
docker login registre.entreprise.com

# Pousser l'image vers le registry
docker push registre.entreprise.com/monapp:1.0

# Chercher des images sur Docker Hub
docker search iis

7. Gestion des containers

Cycle de vie d'un container

         docker create
              │
              ▼
         ┌─────────┐
         │ CREATED │
         └────┬────┘
              │ docker start
              ▼
         ┌─────────┐◄──────────────────────────┐
         │ RUNNING │                            │
         └────┬────┘                            │
              │                          docker restart
    ┌─────────┼──────────┐                      │
    │         │          │                      │
docker pause  │   docker stop               docker start
    │         │    docker kill                   │
    ▼         │          │                      │
┌────────┐    │     ┌──────────┐                │
│ PAUSED │    │     │ STOPPED  │────────────────┘
└────────┘    │     └────┬─────┘
docker unpause│          │ docker rm
              │          ▼
              │     ┌──────────┐
              │     │ DELETED  │
              └─────►          │
                    └──────────┘

Commandes essentielles

# ── LANCER DES CONTAINERS ──────────────────────────────────

# Lancer un container en mode interactif
docker run -it mcr.microsoft.com/windows/servercore:ltsc2022 powershell

# Lancer en arrière-plan (détaché)
docker run -d --name monserveur iis-monapp:1.0

# Lancer avec mappage de port (hôte:container)
docker run -d -p 8080:80 --name webserver iis-monapp:1.0

# Lancer avec une variable d'environnement
docker run -d -e "ENV=production" -e "DB_HOST=sqlserver" monapp:1.0

# Lancer avec un volume monté
docker run -d -v C:\data:C:\app\data monapp:1.0

# Lancer avec redémarrage automatique
docker run -d --restart always monapp:1.0

# ── SURVEILLER LES CONTAINERS ──────────────────────────────

# Lister les containers en cours d'exécution
docker ps

# Lister tous les containers (y compris arrêtés)
docker ps -a

# Voir les logs d'un container
docker logs monserveur

# Suivre les logs en temps réel
docker logs -f monserveur

# Statistiques de ressources en temps réel
docker stats

# Inspecter un container (configuration complète)
docker inspect monserveur

# Voir les processus dans un container
docker top monserveur

# ── INTERAGIR AVEC LES CONTAINERS ─────────────────────────

# Ouvrir un shell PowerShell dans un container en cours
docker exec -it monserveur powershell

# Exécuter une commande dans un container
docker exec monserveur ipconfig

# Copier un fichier vers/depuis un container
docker cp fichier.txt monserveur:C:\app\
docker cp monserveur:C:\app\logs\app.log C:\logs\

# ── GÉRER LES CONTAINERS ───────────────────────────────────

# Arrêter un container (gracieux, 10s timeout)
docker stop monserveur

# Forcer l'arrêt immédiat
docker kill monserveur

# Redémarrer un container
docker restart monserveur

# Mettre en pause / reprendre
docker pause monserveur
docker unpause monserveur

# Supprimer un container arrêté
docker rm monserveur

# Forcer la suppression d'un container en cours
docker rm -f monserveur

# Supprimer tous les containers arrêtés
docker container prune

# ── NETTOYAGE ──────────────────────────────────────────────

# Supprimer toutes les ressources inutilisées
docker system prune

# Voir l'utilisation de l'espace disque
docker system df

Politiques de redémarrage

Politique Description
no Ne jamais redémarrer (défaut)
always Toujours redémarrer, même après reboot du serveur
on-failure Redémarrer uniquement en cas d'erreur
unless-stopped Redémarrer sauf si arrêté manuellement
# Exemple de politique recommandée pour un service de production
docker run -d --restart unless-stopped --name monservice monapp:1.0

8. Réseaux Docker

Drivers réseau disponibles sous Windows

Driver Description Usage
nat Réseau NAT (défaut sous Windows) Usage général, accès internet
transparent Accès direct au réseau physique Besoin d'IP du réseau LAN
overlay Réseau multi-hôtes Docker Swarm, clusters
l2bridge Bridge niveau 2 Containers avec IP LAN dédiée
none Aucune interface réseau Isolation totale
# Lister les réseaux
docker network ls

# Créer un réseau personnalisé
docker network create --driver nat monreseau

# Inspecter un réseau
docker network inspect monreseau

# Connecter un container à un réseau
docker network connect monreseau moncontainer

# Déconnecter
docker network disconnect monreseau moncontainer

# Supprimer un réseau
docker network rm monreseau

# Lancer un container sur un réseau spécifique
docker run -d --network monreseau --name app1 monapp:1.0

# Les containers sur le même réseau peuvent se communiquer par nom
docker run -d --network monreseau --name app2 monapp2:1.0
# app2 peut appeler app1 via http://app1/...

Exemple : architecture multi-containers en réseau

# Créer un réseau applicatif
docker network create --driver nat reseau-app

# Lancer la base de données
docker run -d `
  --name sqlserver `
  --network reseau-app `
  -e "ACCEPT_EULA=Y" `
  -e "SA_PASSWORD=MonMotDePasse123!" `
  mcr.microsoft.com/mssql/server:2022-latest

# Lancer l'application (peut contacter sqlserver par son nom)
docker run -d `
  --name webapp `
  --network reseau-app `
  -p 8080:80 `
  -e "ConnectionStrings__Default=Server=sqlserver;..." `
  monapp:1.0

9. Volumes et persistance des données

Types de stockage Docker

┌──────────────────────────────────────────────────────┐
│                   CONTAINER                          │
│                                                      │
│  Système de fichiers du container (temporaire)       │
│  ┌──────────────────────────────────────────────┐    │
│  │  C:\app\  C:\Windows\  C:\Users\             │    │
│  └──────────────────────────────────────────────┘    │
│                                                      │
│  ┌──────────┐  ┌──────────────┐  ┌─────────────┐    │
│  │  VOLUME  │  │ BIND MOUNT   │  │  TMPFS      │    │
│  │ (Docker  │  │ (dossier     │  │ (mémoire    │    │
│  │ géré)    │  │  hôte)       │  │  vive)      │    │
│  └────┬─────┘  └──────┬───────┘  └──────┬──────┘    │
└───────│────────────────│─────────────────│───────────┘
        │                │                 │
   C:\ProgramData\   C:\MonDossier\    (RAM)
   docker\volumes\

Volumes nommés (recommandé)

# Créer un volume
docker volume create mes-donnees

# Lister les volumes
docker volume ls

# Inspecter un volume
docker volume inspect mes-donnees

# Utiliser un volume dans un container
docker run -d -v mes-donnees:C:\app\data monapp:1.0

# Supprimer un volume
docker volume rm mes-donnees

# Supprimer les volumes inutilisés
docker volume prune

Bind Mounts (montage de dossier hôte)

# Monter un dossier de l'hôte dans le container
docker run -d `
  -v C:\logs:C:\app\logs `
  -v C:\config:C:\app\config:ro `
  monapp:1.0

# Note : l'option :ro monte en lecture seule

Bonnes pratiques de persistance

# ✅ BON : Utiliser des volumes pour les données persistantes
docker run -d -v sqldata:C:\data monapp-sql:1.0

# ❌ MAUVAIS : Ne pas stocker de données dans le container lui-même
# (les données disparaissent avec le container)

# Sauvegarder un volume
docker run --rm `
  -v mes-donnees:C:\data `
  -v C:\backup:C:\backup `
  mcr.microsoft.com/windows/nanoserver:ltsc2022 `
  cmd /c "xcopy C:\data C:\backup /E /I /H"

10. Docker Compose

Qu'est-ce que Docker Compose ?

Docker Compose permet de définir et gérer des applications multi-containers dans un seul fichier YAML. C'est l'outil idéal pour les environnements de développement et les déploiements simples.

Installation

# Docker Compose est inclus avec Docker Desktop
# Pour Docker Engine seul, télécharger le binaire :
[Net.ServicePointManager]::SecurityProtocol = [Net.SecurityProtocolType]::Tls12
Invoke-WebRequest -Uri "https://github.com/docker/compose/releases/latest/download/docker-compose-windows-x86_64.exe" `
  -OutFile "$env:ProgramFiles\Docker\docker-compose.exe"

Exemple : Stack web complète

docker-compose.yml

version: '3.8'

services:

  # Serveur web IIS
  webapp:
    build:
      context: ./webapp
      dockerfile: Dockerfile
    image: monapp-web:1.0
    container_name: webapp
    ports:
      - "80:80"
      - "443:443"
    environment:
      - ASPNETCORE_ENVIRONMENT=Production
      - ConnectionStrings__Default=Server=sqlserver;Database=madb;...
    depends_on:
      - sqlserver
      - redis
    networks:
      - frontend
      - backend
    restart: unless-stopped
    volumes:
      - app-logs:C:\app\logs

  # SQL Server
  sqlserver:
    image: mcr.microsoft.com/mssql/server:2022-latest
    container_name: sqlserver
    environment:
      - ACCEPT_EULA=Y
      - SA_PASSWORD=MonMotDePasse123!
      - MSSQL_PID=Express
    volumes:
      - sqldata:C:\Program Files\Microsoft SQL Server\MSSQL16.MSSQLSERVER\MSSQL\DATA
    networks:
      - backend
    restart: unless-stopped

  # Cache Redis
  redis:
    image: redis:latest
    container_name: redis
    networks:
      - backend
    restart: unless-stopped

networks:
  frontend:
    driver: nat
  backend:
    driver: nat

volumes:
  sqldata:
  app-logs:

Commandes Docker Compose

# Démarrer tous les services (en arrière-plan)
docker compose up -d

# Démarrer et reconstruire les images
docker compose up -d --build

# Voir les logs de tous les services
docker compose logs

# Voir les logs d'un service spécifique
docker compose logs webapp

# Lister les containers de la stack
docker compose ps

# Arrêter les services
docker compose stop

# Arrêter et supprimer les containers
docker compose down

# Arrêter, supprimer les containers ET les volumes
docker compose down -v

# Mettre à l'échelle un service (3 instances)
docker compose up -d --scale webapp=3

# Exécuter une commande dans un service
docker compose exec webapp powershell

11. Sécurité et bonnes pratiques

Principes de sécurité fondamentaux

1. Minimiser la surface d'attaque

# ✅ Utiliser l'image la plus légère possible
FROM mcr.microsoft.com/windows/nanoserver:ltsc2022

# ❌ Éviter les images volumineuses si non nécessaire
FROM mcr.microsoft.com/windows/server:ltsc2022

2. Ne pas exécuter en tant qu'administrateur

# Créer un utilisateur non-privilégié
RUN net user /add appuser
USER appuser

3. Scanner les images pour les vulnérabilités

# Avec Docker Scout (intégré à Docker)
docker scout cves monapp:1.0

# Ou avec Trivy (outil open-source)
docker run --rm -v //./pipe/docker_engine://./pipe/docker_engine `
  aquasec/trivy image monapp:1.0

4. Gérer les secrets correctement

# ❌ JAMAIS de secrets dans les variables d'environnement en clair
docker run -e "PASSWORD=MonMotDePasse" monapp

# ✅ Utiliser Docker Secrets (avec Swarm) ou des solutions externes
docker secret create db_password password.txt
docker service create --secret db_password monapp

# ✅ Ou utiliser des fichiers de configuration montés
docker run -v C:\secrets:C:\app\secrets:ro monapp

5. Limiter les ressources

# Limiter la mémoire et le CPU
docker run -d `
  --memory="512m" `
  --memory-swap="1g" `
  --cpus="1.5" `
  monapp:1.0

6. Utiliser des images signées et vérifiées

# Activer Docker Content Trust
$env:DOCKER_CONTENT_TRUST = 1

# Toujours utiliser des tags précis (pas :latest en production)
# ✅ Bon
docker pull mcr.microsoft.com/windows/nanoserver:ltsc2022

# ❌ Mauvais en production
docker pull mcr.microsoft.com/windows/nanoserver:latest

Checklist de sécurité

Configuration de la journalisation

# Configurer la rotation des logs dans daemon.json
# C:\ProgramData\docker\config\daemon.json
{
  "log-driver": "json-file",
  "log-opts": {
    "max-size": "10m",
    "max-file": "5"
  }
}

# Voir les logs avec filtres
docker logs --since="2024-01-01" --until="2024-01-31" moncontainer
docker logs --tail=100 moncontainer

12. Scénarios d'usage en entreprise

Scénario 1 : Migration d'une application IIS legacy

# 1. Containeriser l'application existante
# Dockerfile pour app IIS .NET Framework
docker build -t legacy-app:1.0 .

# 2. Tester en local
docker run -d -p 8080:80 --name legacy-test legacy-app:1.0

# 3. Pousser vers le registry d'entreprise
docker tag legacy-app:1.0 acr.azurecr.io/legacy-app:1.0
docker push acr.azurecr.io/legacy-app:1.0

# 4. Déployer en production
docker run -d `
  --name legacy-prod `
  --restart always `
  -p 80:80 `
  -v logs-prod:C:\inetpub\logs `
  acr.azurecr.io/legacy-app:1.0

Scénario 2 : Déploiement multi-environnements

Structure de projet recommandée :

MonProjet/
├── docker-compose.yml          # Base commune
├── docker-compose.dev.yml      # Surcharges développement
├── docker-compose.staging.yml  # Surcharges staging
├── docker-compose.prod.yml     # Surcharges production
├── Dockerfile
└── src/
# Environnement de développement
docker compose -f docker-compose.yml -f docker-compose.dev.yml up -d

# Production
docker compose -f docker-compose.yml -f docker-compose.prod.yml up -d

Scénario 3 : Intégration CI/CD avec containers

# Exemple de pipeline (Azure DevOps)
stages:
  - stage: Build
    jobs:
      - job: BuildAndPush
        steps:
          - script: docker build -t $(image):$(Build.BuildId) .
          - script: docker push $(image):$(Build.BuildId)

  - stage: Deploy
    jobs:
      - job: DeployToServer
        steps:
          - script: |
              docker pull $(image):$(Build.BuildId)
              docker stop monapp || true
              docker rm monapp || true
              docker run -d --name monapp -p 80:80 $(image):$(Build.BuildId)

Scénario 4 : Registre Docker privé en entreprise

# Déployer un registry privé
docker run -d `
  --name registry `
  --restart always `
  -p 5000:5000 `
  -v registry-data:C:\registry-data `
  registry:2

# Configurer le daemon pour accepter le registry interne
# daemon.json
{
  "insecure-registries": ["serveur-registry.entreprise.local:5000"]
}

# Pousser une image vers le registry privé
docker tag monapp:1.0 serveur-registry.entreprise.local:5000/monapp:1.0
docker push serveur-registry.entreprise.local:5000/monapp:1.0

13. Exercices pratiques

Exercice 1 : Premier container Windows

# 1. Télécharger l'image Nano Server
docker pull mcr.microsoft.com/windows/nanoserver:ltsc2022

# 2. Lancer un container interactif
docker run -it mcr.microsoft.com/windows/nanoserver:ltsc2022 cmd

# 3. À l'intérieur du container, explorer :
# > dir
# > hostname
# > ipconfig
# > exit

# 4. Vérifier que le container est arrêté
docker ps -a

Exercice 2 : Construire votre première image

Créer un fichier index.html :

<!DOCTYPE html>
<html>
<head><title>Mon App Docker</title></head>
<body>
  <h1>Hello depuis un container Docker !</h1>
  <p>Windows Server 2022 + Docker</p>
</body>
</html>

Créer le Dockerfile :

FROM mcr.microsoft.com/windows/servercore/iis:windowsservercore-ltsc2022
COPY index.html C:\inetpub\wwwroot\
EXPOSE 80
# Construire l'image
docker build -t mon-premier-site:1.0 .

# Lancer le container
docker run -d -p 8080:80 --name monsite mon-premier-site:1.0

# Tester dans le navigateur : http://localhost:8080
Start-Process "http://localhost:8080"

# Nettoyer
docker stop monsite
docker rm monsite

Exercice 3 : Stack multi-containers avec Compose

Créer une structure :

exercice3/
├── docker-compose.yml
├── web/
│   ├── Dockerfile
│   └── index.html
# docker-compose.yml
version: '3.8'

services:
  web:
    build: ./web
    ports:
      - "8080:80"
    restart: unless-stopped

  adminer:
    image: adminer:latest
    ports:
      - "8081:8080"
    restart: unless-stopped
# Lancer la stack
cd exercice3
docker compose up -d

# Vérifier les services
docker compose ps

# Arrêter
docker compose down

Exercice 4 : Persistance des données

# 1. Créer un volume
docker volume create mes-donnees

# 2. Lancer un container avec ce volume
docker run -d `
  --name test-persistence `
  -v mes-donnees:C:\data `
  mcr.microsoft.com/windows/servercore:ltsc2022 `
  powershell -command "while(`$true) { Start-Sleep 3600 }"

# 3. Créer un fichier dans le volume
docker exec test-persistence `
  powershell -command "Set-Content C:\data\test.txt 'Données persistantes !'"

# 4. Supprimer le container
docker rm -f test-persistence

# 5. Créer un nouveau container et vérifier que les données existent
docker run --rm `
  -v mes-donnees:C:\data `
  mcr.microsoft.com/windows/servercore:ltsc2022 `
  powershell -command "Get-Content C:\data\test.txt"

# ✅ Les données sont préservées !

14. Ressources complémentaires

Documentation officielle

Ressource URL
Documentation Docker https://docs.docker.com
Containers sur Windows https://learn.microsoft.com/fr-fr/virtualization/windowscontainers/
Microsoft Container Registry https://mcr.microsoft.com
Docker Hub https://hub.docker.com

Outils complémentaires recommandés

Outil Description Usage
Docker Desktop Interface graphique pour Docker Développement local
Portainer Interface web de gestion des containers Administration
Lazydocker Interface TUI pour Docker Terminal
Dive Analyser les couches d'une image Optimisation
Trivy Scanner de vulnérabilités Sécurité
Docker Scout Analyse de sécurité intégrée Sécurité

Prochaines étapes recommandées

  1. Docker Swarm — Orchestration native multi-serveurs
  2. Kubernetes — Orchestration avancée à grande échelle
  3. Azure Kubernetes Service (AKS) — Kubernetes managé dans Azure
  4. Azure Container Instances (ACI) — Containers serverless
  5. Windows Admin Center — Gestion des containers via interface graphique
  6. Helm — Gestionnaire de packages Kubernetes

Commandes de référence rapide

# ── IMAGES ─────────────────────────────────────────────────
docker pull IMAGE           # Télécharger une image
docker build -t NOM .       # Construire une image
docker images               # Lister les images
docker rmi IMAGE            # Supprimer une image
docker push IMAGE           # Pousser vers un registry

# ── CONTAINERS ─────────────────────────────────────────────
docker run IMAGE            # Créer et démarrer un container
docker ps                   # Lister les containers actifs
docker ps -a                # Lister tous les containers
docker start NOM            # Démarrer un container
docker stop NOM             # Arrêter un container
docker rm NOM               # Supprimer un container
docker logs NOM             # Voir les logs
docker exec -it NOM cmd     # Shell interactif

# ── RÉSEAUX ────────────────────────────────────────────────
docker network ls           # Lister les réseaux
docker network create NOM   # Créer un réseau
docker network inspect NOM  # Inspecter un réseau

# ── VOLUMES ────────────────────────────────────────────────
docker volume ls            # Lister les volumes
docker volume create NOM    # Créer un volume
docker volume inspect NOM   # Inspecter un volume
docker volume rm NOM        # Supprimer un volume

# ── COMPOSE ────────────────────────────────────────────────
docker compose up -d        # Démarrer la stack
docker compose down         # Arrêter et supprimer
docker compose ps           # État des services
docker compose logs         # Logs de tous les services

# ── SYSTÈME ────────────────────────────────────────────────
docker info                 # Informations système
docker system df            # Espace disque utilisé
docker system prune         # Nettoyage général

*Cours rédigé pour le Cégep Ahuntsic par son excellence Pablo The God