📚 C'est quoi un Dockerfile ? Un Dockerfile est un fichier texte qui contient les instructions pour construire une image Docker personnalisée. Pensez-y comme une recette de cuisine : chaque ligne est une étape (prendre l'image de base, copier des fichiers, configurer des paramètres). À la fin, vous obtenez une image prête à être lancée en container. C'est comme ça qu'on crée des images sur mesure au lieu d'utiliser uniquement celles disponibles sur Docker Hub.

ⓘ Environnement de travail Ce tuto est réalisé dans un environnement de test sous WSL avec VS Code. Docker Desktop doit être installé sur Windows avec l'intégration WSL activée.

📚 Sources & documentation officielle

Créer le répertoire du projet

On crée le dossier et on l'ouvre dans VS Code. Tout sera au même endroit.

# mkdir -p : crée le dossier (et ses parents) sans erreur s'il existe déjà
mkdir -p ~/mon-nginx

# cd : se déplacer dans le dossier du projet
cd ~/mon-nginx

# code . : ouvre le dossier courant dans VS Code
code .

Créer la page web personnalisée

Créez un fichier index.html dans VS Code (clic droit → New File) :

Contenu :

<!DOCTYPE html>
<html lang="fr">
<head>
    <meta charset="UTF-8">
    <title>Mon Nginx Custom</title>
    <style>
        body {
            font-family: Arial, sans-serif;
            display: flex;
            justify-content: center;
            align-items: center;
            min-height: 100vh;
            background: #1a1a2e;
            color: #eee;
            margin: 0;
        }
        .box {
            text-align: center;
            background: #16213e;
            padding: 40px 60px;
            border-radius: 12px;
        }
        h1 { color: #7ecfff; }
    </style>
</head>
<body>
    <div class="box">
        <h1>Mon Image Docker Nginx</h1>
        <p>Cette page est servie par une image Docker personnalisée.</p>
    </div>
</body>
</html>

Écrire le Dockerfile

Créez un fichier Dockerfile (sans extension) dans VS Code, à la racine du projet. Ce fichier contient les instructions pour construire notre image :

# FROM = l'image de base sur laquelle on construit
# nginx:alpine = Nginx version légère (Alpine Linux fait ~5Mo au lieu de ~100Mo)
# C'est comme dire "je pars d'un serveur Nginx déjà installé"
FROM nginx:alpine

# RUN = exécute une commande pendant la construction de l'image
# Ici on supprime la page d'accueil par défaut de Nginx
# pour la remplacer par la nôtre à l'étape suivante
RUN rm -rf /usr/share/nginx/html/*

# COPY = copie un fichier depuis votre ordinateur vers l'image
# On copie notre index.html dans le dossier où Nginx cherche les pages web
COPY index.html /usr/share/nginx/html/index.html

# EXPOSE = documente que cette image utilise le port 80
# C'est informatif : ça ne fait pas réellement de redirection de port
# (ça se fait avec -p au moment du docker run)
EXPOSE 80

# CMD = la commande qui sera lancée au démarrage du container
# L'image Nginx inclut déjà cette commande par défaut, donc pas besoin de la spécifier
# CMD ["nginx", "-g", "daemon off;"]

Explication du Dockerfile

Instruction	Description
`FROM nginx:alpine`	Utilise l'image Nginx légère (Alpine Linux) comme base
`RUN rm -rf ...`	Supprime les fichiers par défaut de Nginx
`COPY`	Copie notre fichier dans le container
`EXPOSE 80`	Documente le port utilisé

Construire l'image (docker build)

# Construit l'image Docker à partir du Dockerfile
# -t mon-nginx:1.0 = donne un nom ("mon-nginx") et un tag/version ("1.0") à l'image
# . = le point dit à Docker "cherche le Dockerfile dans le dossier courant"
docker build -t mon-nginx:1.0 .

Explication

-t mon-nginx:1.0 — Nom et tag de l'image
. — Context de build (répertoire courant contenant le Dockerfile)

Vérifier que l'image existe

# Liste les images Docker et filtre pour ne voir que la nôtre
docker images | grep mon-nginx

Vous devez voir :

mon-nginx   1.0   abc123def456   10 seconds ago   43MB

Lancer le container (docker run)

# Lance un container à partir de notre image personnalisée
# -d = mode détaché (tourne en arrière-plan)
# --name = donne un nom au container (plus facile que l'ID aléatoire)
# -p 8080:80 = redirige le port 8080 de votre PC vers le port 80 du container
# mon-nginx:1.0 = l'image qu'on vient de construire
docker run -d --name mon-nginx-container -p 8080:80 mon-nginx:1.0

Vérifier

# Vérifie que le container tourne (State = Up)
docker ps

# Teste si Nginx répond en envoyant une requête HTTP
# Vous devez voir le HTML de votre page index.html
curl http://localhost:8080

Ouvrez http://localhost:8080 dans votre navigateur — vous devez voir votre page personnalisée.

⚠ Adaptez à votre réseau Depuis WSL, utilisez http://localhost:8080. Depuis un autre poste, remplacez par l'IP de votre machine Windows.

Structure du dossier

mon-nginx/
├── Dockerfile
└── index.html

Commandes utiles

# Affiche les logs du container (les requêtes reçues par Nginx, les erreurs, etc.)
docker logs mon-nginx-container

# Ouvre un shell interactif DANS le container
# -it = mode interactif + terminal
# sh = le shell utilisé (Alpine n'a pas bash, on utilise sh)
# Pour sortir : tapez "exit"
docker exec -it mon-nginx-container sh

# Arrête le container (il existe encore mais ne tourne plus)
docker stop mon-nginx-container

# Supprime le container (libère les ressources)
docker rm mon-nginx-container

# Supprime l'image (le "modèle" du container)
docker rmi mon-nginx:1.0

# Après avoir modifié le Dockerfile ou index.html :
# Reconstruisez avec un nouveau tag (version 2.0)
docker build -t mon-nginx:2.0 .
docker run -d --name mon-nginx-v2 -p 8080:80 mon-nginx:2.0

✔ Résultat Vous avez créé une image Docker personnalisée basée sur Nginx, construit l'image avec docker build et lancé un container avec docker run. Tout le projet est dans un seul dossier, visible dans VS Code.

Créer une image Docker (Nginx)