Docker expliqué aux développeurs : images, containers, Dockerfile — guide pratique

Docker est la compétence DevOps la plus demandée aux développeurs en 2026. Presque toutes les offres d’emploi back-end la mentionnent. Pourtant, beaucoup de développeurs juniors l’évitent car elle semble complexe. Ce guide vous donne les concepts essentiels et un Dockerfile fonctionnel à partir de zéro.

Pourquoi Docker — le problème qu’il résout

« Ça marche sur ma machine » est la blague la plus vieille du développement. Docker résout ce problème en empaquetant l’application avec tout son environnement : runtime, dépendances, configuration. Un container Docker s’exécute de façon identique sur votre machine, la CI, et le serveur de production.

Image vs Container — la distinction fondamentale

• Image : le blueprint, la recette. Fichier statique qui décrit tout ce qu’il faut pour faire tourner l’application. Comme une classe en POO.
• Container : une instance en cours d’exécution d’une image. Comme un objet instancié depuis une classe.

# Télécharger et lancer un container Nginx
docker run -p 8080:80 nginx
# → l'image nginx est téléchargée, un container démarre, port 80 mappé sur votre port 8080

# Lister les containers en cours
docker ps

# Lister les images téléchargées
docker images

# Arrêter un container
docker stop 

Écrire un Dockerfile

Le Dockerfile décrit comment construire l’image de votre application :

# Dockerfile pour une app Node.js/Next.js

# Image de base — node:20-alpine est légère (~150MB vs ~900MB pour node:20)
FROM node:20-alpine AS base

# Dépendances
FROM base AS deps
WORKDIR /app
COPY package.json package-lock.json ./
RUN npm ci --only=production

# Build
FROM base AS builder
WORKDIR /app
COPY --from=deps /app/node_modules ./node_modules
COPY . .
RUN npm run build

# Image finale — la plus légère possible
FROM base AS runner
WORKDIR /app
ENV NODE_ENV=production

# Copier uniquement ce qui est nécessaire à l'exécution
COPY --from=builder /app/.next/standalone ./
COPY --from=builder /app/.next/static ./.next/static
COPY --from=builder /app/public ./public

EXPOSE 3000
CMD ["node", "server.js"]

Les commandes essentielles

# Construire une image depuis le Dockerfile du répertoire courant
docker build -t mon-app:latest .

# Lancer le container
docker run -p 3000:3000 --env-file .env mon-app:latest

# Mode détaché (background)
docker run -d -p 3000:3000 mon-app:latest

# Voir les logs d'un container
docker logs  -f   # -f pour suivre en temps réel

# Entrer dans un container en cours d'exécution
docker exec -it  sh

# Nettoyer les images et containers inutilisés
docker system prune -a

Le .dockerignore — ne pas oublier

# .dockerignore — fonctionne comme .gitignore
node_modules
.next
.env
.env.local
*.log
.git
README.md
# Sans ce fichier, node_modules (souvent >500MB) serait copié dans l'image

Les bonnes pratiques à retenir

• Multi-stage builds : séparer les étapes build et run pour des images finales légères
• Utilisez des images Alpine : node:20-alpine plutôt que node:20 — 6x plus léger
• Ne mettez jamais de secrets dans l’image : utilisez les variables d’environnement au runtime
• Un processus par container : ne faites pas tourner nginx + node + postgresql dans le même container
• Spécifiez les versions : node:20-alpine pas node:latest — pour la reproductibilité

---

À lire aussi : Docker Compose — DevOps pour débutant — CI/CD avec GitHub Actions