Dockeriser une application Node.js 🟢

Projet d'exemple : API Express

mon-projet/
├── src/
│   ├── routes/
│   │   └── users.js
│   ├── models/
│   │   └── User.js
│   └── server.js
├── package.json
├── package-lock.json
├── .dockerignore
└── Dockerfile

---

Étape 1 : Le Dockerfile

# 1. Image de base
FROM node:18-alpine

# 2. Répertoire de travail
WORKDIR /app

# 3. Copier les dépendances d'abord (cache)
COPY package*.json ./

# 4. Installer les dépendances
RUN npm ci --only=production

# 5. Copier le code source
COPY . .

# 6. Créer un utilisateur non-root
RUN addgroup -S appgroup && adduser -S appuser -G appgroup

# 7. Changer le propriétaire
RUN chown -R appuser:appgroup /app

# 8. Utilisateur non-root
USER appuser

# 9. Port
EXPOSE 3000

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

---

Étape 2 : Le .dockerignore

node_modules
npm-debug.log
.env
.env.local
.git
.gitignore
Dockerfile
docker-compose.yml
README.md
.vscode
coverage
tests

---

Étape 3 : Construire et lancer

# Construire l'image
docker build -t mon-api:1.0 .

# Vérifier la taille
docker images mon-api
# REPOSITORY   TAG    SIZE
# mon-api      1.0    178MB  ← Très léger grâce à Alpine

# Lancer le conteneur
docker run -d \
  --name mon-api \
  -p 3000:3000 \
  -e NODE_ENV=production \
  -e DB_HOST=postgres \
  mon-api:1.0

# Tester
curl http://localhost:3000/api/users

---

Étape 4 : Avec Docker Compose (Node + PostgreSQL)

version: '3.8'

services:
  api:
    build: .
    ports:
      - "3000:3000"
    environment:
      - NODE_ENV=production
      - DB_HOST=postgres
      - DB_PORT=5432
      - DB_NAME=mabase
      - DB_USER=postgres
      - DB_PASSWORD=secret
    depends_on:
      - postgres
    networks:
      - app-network
    restart: unless-stopped

  postgres:
    image: postgres:15-alpine
    environment:
      POSTGRES_DB: mabase
      POSTGRES_USER: postgres
      POSTGRES_PASSWORD: secret
    volumes:
      - pgdata:/var/lib/postgresql/data
    networks:
      - app-network
    restart: unless-stopped

volumes:
  pgdata:

networks:
  app-network:
    driver: bridge

---

Étape 5 : Variables d'environnement

# .env
NODE_ENV=production
DB_HOST=postgres
DB_PORT=5432
DB_NAME=mabase
DB_USER=postgres
DB_PASSWORD=secret
PORT=3000

// src/server.js
const express = require('express');
const { Pool } = require('pg');

const app = express();

const pool = new Pool({
  host: process.env.DB_HOST || 'localhost',
  port: process.env.DB_PORT || 5432,
  database: process.env.DB_NAME || 'mabase',
  user: process.env.DB_USER || 'postgres',
  password: process.env.DB_PASSWORD || 'secret',
});

app.get('/api/users', async (req, res) => {
  const { rows } = await pool.query('SELECT * FROM users');
  res.json(rows);
});

const PORT = process.env.PORT || 3000;
app.listen(PORT, () => {
  console.log(`API en écoute sur le port ${PORT}`);
});

---

Volumes pour le développement

# Monter le code source pour le hot-reload
docker run -d \
  --name mon-api-dev \
  -p 3000:3000 \
  -v $(pwd)/src:/app/src \
  -e NODE_ENV=development \
  mon-api:dev

# Les modifications en temps réel sont reflétées !

---

Multi-stage build pour la production

# Étape 1 : Build
FROM node:18-alpine AS builder
WORKDIR /app
COPY package*.json ./
RUN npm ci
COPY . .
RUN npm run build

# Étape 2 : Production
FROM node:18-alpine
WORKDIR /app
COPY --from=builder /app/dist ./dist
COPY --from=builder /app/node_modules ./node_modules
COPY package*.json ./
EXPOSE 3000
CMD ["node", "dist/server.js"]

---

Exercices 🎯

1. Dockerfile : Écrivez un Dockerfile pour une API Express avec PostgreSQL.
2. Compose : Créez un docker-compose.yml avec l'API et la base de données.
3. Dev : Lancez l'application en mode développement avec montée de volume pour le hot-reload.
4. Production : Construisez une image multi-stage et vérifiez sa taille.

Prochaine leçon : Dockeriser Laravel.