📚 Pourquoi partir d'Ubuntu ? Partir d'une image ubuntu permet de comprendre comment construire une image depuis zéro : installer les paquets, configurer le service et nettoyer. C'est plus volumineux qu'une image officielle Apache, mais c'est un excellent exercice pédagogique pour maîtriser les Dockerfiles.

ⓘ 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. Toutes les commandes se lancent depuis le terminal WSL dans VS Code (Ctrl + `).

📚 Sources & documentation officielle

Créer le répertoire du projet

On crée le dossier et on l'ouvre dans VS Code :

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

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

# 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) :

<!DOCTYPE html>
<html lang="fr">
<head>
    <meta charset="UTF-8">
    <title>Mon Apache 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: #ff7eb3; }
    </style>
</head>
<body>
    <div class="box">
        <h1>Mon Image Docker Apache</h1>
        <p>Cette page est servie par une image Docker Apache construite depuis Ubuntu.</p>
    </div>
</body>
</html>

Écrire le Dockerfile

Créez un fichier Dockerfile (sans extension) dans VS Code, à la racine du projet :

# FROM = l'image de base sur laquelle on construit
# ubuntu = on part d'un système Ubuntu vierge (pas de serveur web pré-installé)
FROM ubuntu

# RUN = exécute des commandes pendant la construction de l'image
# apt update : met à jour la liste des paquets
# apt install -y apache2 : installe Apache2 (-y = accepte automatiquement)
RUN apt update && apt install -y apache2

# Nettoyage : supprime le cache apt pour réduire la taille de l'image
# Sans cette ligne, l'image serait plus lourde inutilement
RUN apt clean && rm -rf /var/lib/apt/lists/*

# EXPOSE = documente que cette image utilise le port 80
# Informatif uniquement — la redirection réelle se fait avec -p au docker run
EXPOSE 80

# COPY = copie un fichier depuis votre ordinateur vers l'image
# On remplace la page par défaut d'Apache par notre page personnalisée
COPY ./index.html /var/www/html/index.html

# CMD = la commande lancée au démarrage du container
# apachectl -D FOREGROUND = lance Apache au premier plan
# (obligatoire dans Docker, sinon le container s'arrête immédiatement)
CMD ["apachectl", "-D", "FOREGROUND"]

Explication du Dockerfile

Instruction	Description
`FROM ubuntu`	Utilise Ubuntu comme image de base — on installe tout nous-mêmes
`RUN apt update && apt install -y apache2`	Met à jour les paquets et installe Apache2
`RUN apt clean && rm -rf ...`	Nettoie le cache pour réduire la taille de l'image
`EXPOSE 80`	Documente le port utilisé par Apache
`COPY ./index.html ...`	Copie notre page web dans le dossier d'Apache
`CMD ["apachectl", "-D", "FOREGROUND"]`	Lance Apache au premier plan au démarrage du container

ⓘ Pourquoi FOREGROUND ? Docker attend que le processus principal reste actif. Si Apache se lance en arrière-plan (par défaut), Docker pense qu'il n'y a plus rien à faire et arrête le container. L'option -D FOREGROUND force Apache à rester au premier plan.

Construire l'image (docker build)

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

⚠ N'oubliez pas le point (.) à la fin ! Le point indique le contexte de build — le dossier où Docker cherche le Dockerfile et les fichiers à copier. Sans lui, la commande échoue.

Vérifier que l'image existe

# Liste toutes les images Docker présentes sur votre machine
docker images | grep mon-apache

Vous devez voir quelque chose comme :

mon-apache   1.0   abc123def456   10 seconds ago   230MB

ⓘ Taille de l'image L'image fait environ 230 Mo car elle est basée sur Ubuntu. En comparaison, une image httpd:alpine (Apache officiel sur Alpine) fait environ 60 Mo. C'est le compromis d'une image basée sur Ubuntu — plus lourde mais plus familière.

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
# -p 8080:80 = redirige le port 8080 de votre PC vers le port 80 du container
# mon-apache:1.0 = l'image qu'on vient de construire
docker run -d --name mon-apache-container -p 8080:80 mon-apache:1.0

Vérifier

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

# Teste si Apache répond en envoyant une requête HTTP
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-apache/
├── Dockerfile
└── index.html

Commandes utiles

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

# Ouvre un shell interactif DANS le container
# -it = mode interactif + terminal
# bash = le shell (Ubuntu a bash, contrairement à Alpine qui n'a que sh)
# Pour sortir : tapez "exit"
docker exec -it mon-apache-container bash

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

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

# Supprime l'image
docker rmi mon-apache:1.0

# Après avoir modifié le Dockerfile ou index.html :
docker build -t mon-apache:2.0 .
docker run -d --name mon-apache-v2 -p 8080:80 mon-apache:2.0

✔ Résultat Vous avez créé une image Docker personnalisée basée sur Ubuntu avec Apache2, construit l'image avec docker build et lancé un container avec docker run. Vous savez maintenant construire une image depuis zéro en installant vos propres paquets.

Créer une image Docker Apache (Ubuntu)