BashIntermédiaire

Déployer avec Docker

18 mars 2026 6 min Bash
Deployer avec Docker

Introduction : Qu’est-ce que Docker ?

Docker est une plateforme qui permet d’empaqueter une application et toutes ses dépendances dans un conteneur. Un conteneur est un environnement isolé et portable qui fonctionne de manière identique sur n’importe quelle machine (Windows, Mac, Linux, serveur cloud).

Pourquoi utiliser Docker ?

  • « Ça marche sur ma machine » : avec Docker, si ça marche chez vous, ça marchera partout
  • Isolation : chaque application tourne dans son propre environnement sans conflit
  • Reproductibilité : création d’images versionnées et partageables
  • Scalabilité : facile de déployer plusieurs instances

Dans ce tutoriel, nous allons dockeriser une application Node.js simple, créer une image Docker, et la déployer localement puis sur un serveur distant.

Prérequis

  • Docker installé : docker.com (Docker Desktop pour Windows/Mac, Docker Engine pour Linux)
  • Vérifiez l’installation : docker --version
  • Une application Node.js basique (on va en créer une ensemble)
  • Notions de terminal/ligne de commande

Étape 1 : Créer une application Node.js simple

Créez un dossier my-docker-app et initialisez un projet Node.js :

mkdir my-docker-app
cd my-docker-app
npm init -y
npm install express

Créez un fichier server.js :

const express = require('express');
const app = express();
const PORT = process.env.PORT || 3000;

app.get('/', (req, res) => {
  res.json({ message: 'Hello from Docker!' });
});

app.listen(PORT, () => {
  console.log(`Server running on port ${PORT}`);
});

Testez localement :

node server.js

Ouvrez http://localhost:3000 : vous devriez voir le JSON.

Étape 2 : Créer un Dockerfile

Le Dockerfile est le blueprint de votre image Docker. Créez un fichier nommé Dockerfile (sans extension) à la racine du projet :

# Image de base : Node.js 18
FROM node:18-alpine

# Définir le répertoire de travail dans le conteneur
WORKDIR /app

# Copier package.json et package-lock.json
COPY package*.json ./

# Installer les dépendances
RUN npm install --production

# Copier tout le code source
COPY . .

# Exposer le port 3000
EXPOSE 3000

# Commande de démarrage
CMD ["node", "server.js"]

Explication ligne par ligne

  • FROM node:18-alpine : image de base légère avec Node.js 18
  • WORKDIR /app : tous les chemins relatifs partiront de /app
  • COPY package*.json ./ : copie les fichiers de dépendances AVANT le code source (cache Docker)
  • RUN npm install --production : installe les dépendances (seulement prod, pas devDependencies)
  • COPY . . : copie tout le reste du code
  • EXPOSE 3000 : documente que le conteneur écoute sur le port 3000
  • CMD ["node", "server.js"] : commande exécutée au démarrage du conteneur

Étape 3 : Créer un .dockerignore

Comme .gitignore, mais pour Docker. Créez un fichier .dockerignore :

node_modules
npm-debug.log
.git
.env
*.md

Cela évite de copier des fichiers inutiles dans l’image (gain de taille et de temps).

Étape 4 : Construire l’image Docker

docker build -t my-docker-app:1.0 .

Explication :

  • docker build : construit une image
  • -t my-docker-app:1.0 : nom et tag de l’image
  • . : contexte de build (dossier actuel)

Le build va :

  1. Télécharger l’image node:18-alpine (si pas déjà en cache)
  2. Copier les fichiers
  3. Installer les dépendances
  4. Créer une image prête à l’emploi

Vérifiez que l’image est créée :

docker images

Étape 5 : Lancer le conteneur

docker run -d -p 3000:3000 --name my-app my-docker-app:1.0

Explication :

  • docker run : lance un conteneur
  • -d : mode détaché (background)
  • -p 3000:3000 : mappe le port 3000 de la machine hôte vers le port 3000 du conteneur
  • --name my-app : donne un nom au conteneur
  • my-docker-app:1.0 : image à utiliser

Testez :

curl http://localhost:3000

Vous devriez voir le JSON {"message":"Hello from Docker!"}.

Étape 6 : Gérer les conteneurs

Voir les conteneurs en cours d’exécution

docker ps

Voir tous les conteneurs (y compris stoppés)

docker ps -a

Voir les logs d’un conteneur

docker logs my-app

Arrêter un conteneur

docker stop my-app

Redémarrer un conteneur

docker start my-app

Supprimer un conteneur

docker rm my-app

Supprimer une image

docker rmi my-docker-app:1.0

Étape 7 : Docker Compose (multi-conteneurs)

Si votre app a besoin d’une base de données, créez un fichier docker-compose.yml :

version: '3.8'

services:
  app:
    build: .
    ports:
      - "3000:3000"
    environment:
      - NODE_ENV=production
      - DATABASE_URL=postgres://user:password@db:5432/mydb
    depends_on:
      - db

  db:
    image: postgres:15-alpine
    environment:
      - POSTGRES_USER=user
      - POSTGRES_PASSWORD=password
      - POSTGRES_DB=mydb
    volumes:
      - db_data:/var/lib/postgresql/data

volumes:
  db_data:

Lancer avec Docker Compose :

docker-compose up -d

Arrêter tout :

docker-compose down

Étape 8 : Déployer sur un serveur distant

Option 1 : Docker Hub (registry public)

  1. Créez un compte sur hub.docker.com
  2. Connectez-vous : docker login
  3. Taggez votre image : 
    docker tag my-docker-app:1.0 votreusername/my-docker-app:1.0
  4. Poussez l’image : 
    docker push votreusername/my-docker-app:1.0
  5. Sur votre serveur distant, récupérez l’image : 
    docker pull votreusername/my-docker-app:1.0
docker run -d -p 3000:3000 votreusername/my-docker-app:1.0

Option 2 : Transfert direct via SSH

# Sauvegarder l'image en tar
docker save my-docker-app:1.0 > my-app.tar

# Transférer sur le serveur
scp my-app.tar user@serveur:/tmp/

# Sur le serveur, charger l'image
ssh user@serveur
docker load < /tmp/my-app.tar
docker run -d -p 3000:3000 my-docker-app:1.0

Erreurs courantes

❌ Cannot connect to the Docker daemon

Cause : Docker Desktop n'est pas lancé, ou Docker Engine non démarré.

Solution : Lancez Docker Desktop (Windows/Mac) ou sudo systemctl start docker (Linux).

❌ Port already in use

Cause : Le port 3000 est déjà utilisé par un autre processus.

Solution : Utilisez un autre port : -p 3001:3000 ou tuez le processus existant.

❌ Image not found

Cause : Nom ou tag d'image incorrect.

Solution : Vérifiez avec docker images et utilisez le nom exact.

Résultat attendu

À la fin de ce tutoriel, vous savez :

  • ✅ Créer un Dockerfile
  • ✅ Construire une image Docker
  • ✅ Lancer et gérer des conteneurs
  • ✅ Utiliser Docker Compose pour multi-conteneurs
  • ✅ Déployer une image sur un serveur distant

Prochaines étapes

  1. Orchestration : Kubernetes pour gérer des centaines de conteneurs
  2. CI/CD : automatiser le build et le déploiement (GitHub Actions, GitLab CI)
  3. Sécurité : scanner les images (Trivy), utiliser des images non-root
  4. Optimisation : multi-stage builds pour réduire la taille des images

Conclusion

Docker a révolutionné le déploiement d'applications. Fini les "ça marche sur ma machine", fini les dépendances conflictuelles. Avec Docker, vous packagez tout dans un conteneur portable et reproductible. C'est LE standard de l'industrie, maîtrisez-le et vous serez prêt pour le DevOps moderne ! 🐳