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 │
└──────────────────────────────────────────────┘
| 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 |
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 │
└────────────────────────┘ └────────────────────────┘
| 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.
Windows Server 2022 supporte deux modes d'isolation pour les containers Docker.
# Exemple : lancer un container Windows en isolation de processus
docker run --isolation=process mcr.microsoft.com/windows/servercore:ltsc2022
# Exemple : lancer un container en isolation Hyper-V
docker run --isolation=hyperv mcr.microsoft.com/windows/servercore:ltsc2019
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é.
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)
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.
┌─────────────────────────────────────────────────────────┐
│ 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é │
└─────────────────────────────────────────────────────────┘
docker)dockerd) : Service en arrière-plan qui gère les containers| 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 |
# 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
# 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
# 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
# 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!"
# Configurer Docker pour démarrer automatiquement
Set-Service -Name docker -StartupType Automatic
# Démarrer le service manuellement si nécessaire
Start-Service 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
# 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
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)
| 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
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="[email protected]"
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"]
| 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 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
docker create
│
▼
┌─────────┐
│ CREATED │
└────┬────┘
│ docker start
▼
┌─────────┐◄──────────────────────────┐
│ RUNNING │ │
└────┬────┘ │
│ docker restart
┌─────────┼──────────┐ │
│ │ │ │
docker pause │ docker stop docker start
│ │ docker kill │
▼ │ │ │
┌────────┐ │ ┌──────────┐ │
│ PAUSED │ │ │ STOPPED │────────────────┘
└────────┘ │ └────┬─────┘
docker unpause│ │ docker rm
│ ▼
│ ┌──────────┐
│ │ DELETED │
└─────► │
└──────────┘
# ── 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
| 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
| 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/...
# 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
┌──────────────────────────────────────────────────────┐
│ 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\
# 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
# 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
# ✅ 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"
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.
# 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"
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:
# 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
# ✅ 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
# Créer un utilisateur non-privilégié
RUN net user /add appuser
USER appuser
# 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
# ❌ 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
# Limiter la mémoire et le CPU
docker run -d `
--memory="512m" `
--memory-swap="1g" `
--cpus="1.5" `
monapp:1.0
# 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
:latest en production)# 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
# 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
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
# 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)
# 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
# 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
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
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
# 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 !
| 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 |
| 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é |
# ── 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