Comment déployer un proxy inverse Nginx avec des conteneurs Docker

Tout d'abord, installez la dernière version de Docker Engine et Docker Compose. Nous utiliserons le script d'installation officiel pour Docker 27.1.0+.

curl -fsSL https://get.docker.com -o get-docker.sh
sudo sh get-docker.sh
sudo usermod -aG docker $USER

Installez Docker Compose v2.29.2 :

sudo curl -SL https://github.com/docker/compose/releases/download/v2.29.2/docker-compose-linux-x86_64 -o /usr/local/bin/docker-compose
sudo chmod +x /usr/local/bin/docker-compose

Déconnectez-vous et reconnectez-vous pour appliquer l'appartenance au groupe docker, puis vérifiez l'installation :

docker --version
docker-compose --version

Configurez une structure de répertoires propre pour votre configuration de proxy inverse. Cette organisation facilite la maintenance à mesure que vous ajoutez plus de services.

mkdir -p ~/nginx-proxy/{config,ssl,logs}
cd ~/nginx-proxy

Créez le fichier principal Docker Compose qui orchestrera notre configuration de proxy inverse :

touch docker-compose.yml

Vérifiez la structure :

tree ~/nginx-proxy
# Devrait afficher :
# nginx-proxy/
# ├── config/
# ├── docker-compose.yml
# ├── logs/
# └── ssl/

Créez la configuration principale de Docker Compose en utilisant les dernières images nginxproxy. Cette configuration offre la découverte automatique des services et la gestion des certificats SSL.

version: '3.8'

services:
  nginx-proxy:
    image: nginxproxy/nginx-proxy:1.3.0
    container_name: nginx-proxy
    restart: always
    ports:
      - "80:80"
      - "443:443"
    volumes:
      - certs:/etc/nginx/certs
      - html:/usr/share/nginx/html
      - /var/run/docker.sock:/tmp/docker.sock:ro
      - ./config:/etc/nginx/conf.d
      - ./logs:/var/log/nginx
    environment:
      - DEFAULT_HOST=yourdomain.com
    networks:
      - nginx-reverse-proxy
    labels:
      - "com.github.jrcs.letsencrypt_nginx_proxy_companion.nginx_proxy"

  acme-companion:
    image: nginxproxy/acme-companion:2.5.1
    container_name: nginx-proxy-acme
    restart: always
    depends_on:
      - nginx-proxy
    environment:
      - DEFAULT_EMAIL=your@email.com
      - NGINX_PROXY_CONTAINER=nginx-proxy
    volumes:
      - certs:/etc/nginx/certs
      - html:/usr/share/nginx/html
      - /var/run/docker.sock:/var/run/docker.sock:ro
      - acme:/etc/acme.sh
    networks:
      - nginx-reverse-proxy

networks:
  nginx-reverse-proxy:
    driver: bridge

volumes:
  certs:
  html:
  acme:

Remplacez your@email.com par votre adresse email réelle pour les notifications Let's Encrypt. Démarrez le proxy :

docker-compose up -d

Vérifiez que les deux conteneurs sont en cours d'exécution :

docker-compose ps
# Devrait montrer nginx-proxy et nginx-proxy-acme comme "Up"

Créez une application de test simple pour vérifier que notre proxy inverse fonctionne correctement. Nous utiliserons une application Node.js basique qui affiche le nom d'hôte du conteneur.

Créez un nouveau répertoire pour l'application de test :

mkdir ~/test-app && cd ~/test-app

Créez une application Node.js simple :

// app.js
const express = require('express');
const os = require('os');
const app = express();
const PORT = 3000;

app.get('/', (req, res) => {
  res.json({
    message: 'Hello from reverse proxy!',
    hostname: os.hostname(),
    timestamp: new Date().toISOString(),
    headers: req.headers
  });
});

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

Créez le Dockerfile :

FROM node:18-alpine
WORKDIR /app
RUN npm init -y && npm install express
COPY app.js .
EXPOSE 3000
CMD ["node", "app.js"]

Construisez et testez l'application :

docker build -t test-app .
docker run -d --name test-backend \
  --network nginx-proxy_nginx-reverse-proxy \
  -e VIRTUAL_HOST=app.yourdomain.com \
  -e LETSENCRYPT_HOST=app.yourdomain.com \
  -e VIRTUAL_PORT=3000 \
  test-app

Vérifiez que le backend fonctionne et est connecté au réseau du proxy :

docker logs test-backend
docker network inspect nginx-proxy_nginx-reverse-proxy

Créez des configurations Nginx personnalisées pour des paramètres de proxy avancés tels que les délais d'attente, les tailles de tampon et les en-têtes de sécurité. Cette étape est cruciale pour les déploiements en production.

Créez un fichier de configuration personnalisé dans le répertoire config :

cd ~/nginx-proxy/config

Créez proxy.conf avec des paramètres prêts pour la production :

# proxy.conf
client_max_body_size 100M;
proxy_connect_timeout 60s;
proxy_send_timeout 60s;
proxy_read_timeout 60s;
proxy_buffering on;
proxy_buffer_size 8k;
proxy_buffers 8 8k;
proxy_busy_buffers_size 16k;

# En-têtes de sécurité
add_header X-Frame-Options "SAMEORIGIN" always;
add_header X-Content-Type-Options "nosniff" always;
add_header X-XSS-Protection "1; mode=block" always;
add_header Referrer-Policy "strict-origin-when-cross-origin" always;
add_header Content-Security-Policy "default-src 'self'; script-src 'self' 'unsafe-inline'; style-src 'self' 'unsafe-inline';" always;

# Transfert d'IP réelle
set_real_ip_from 172.16.0.0/12;
set_real_ip_from 192.168.0.0/16;
set_real_ip_from 10.0.0.0/8;
real_ip_header X-Forwarded-For;
real_ip_recursive on;

Créez gzip.conf pour la compression :

# gzip.conf
gzip on;
gzip_vary on;
gzip_min_length 1024;
gzip_comp_level 6;
gzip_types
    text/plain
    text/css
    text/xml
    text/javascript
    application/json
    application/javascript
    application/xml+rss
    application/atom+xml
    image/svg+xml;

Redémarrez le proxy pour appliquer la nouvelle configuration :

cd ~/nginx-proxy
docker-compose restart nginx-proxy

Vérifiez que la configuration est chargée sans erreurs :

docker-compose logs nginx-proxy | grep -i error

Monitor SSL certificate status and renewal to prevent unexpected certificate expiration. The ACME companion handles renewal automatically, but monitoring ensures everything works correctly.

Check current certificate status:

docker exec nginx-proxy-acme /app/cert_status

Create a monitoring script to check certificate expiration:

#!/bin/bash
# cert-monitor.sh
DOMAINS=("app.yourdomain.com" "api.yourdomain.com")
WARN_DAYS=30

for domain in "${DOMAINS[@]}"; do
    expiry=$(docker exec nginx-proxy openssl x509 -in "/etc/nginx/certs/${domain}.crt" -noout -enddate 2>/dev/null | cut -d= -f2)
    if [ ! -z "$expiry" ]; then
        expiry_epoch=$(date -d "$expiry" +%s)
        current_epoch=$(date +%s)
        days_until_expiry=$(( (expiry_epoch - current_epoch) / 86400 ))
        
        if [ $days_until_expiry -lt $WARN_DAYS ]; then
            echo "WARNING: Certificate for $domain expires in $days_until_expiry days"
        else
            echo "OK: Certificate for $domain expires in $days_until_expiry days"
        fi
    else
        echo "ERROR: No certificate found for $domain"
    fi
done

Make the script executable and test it:

chmod +x cert-monitor.sh
./cert-monitor.sh

Add to crontab for daily monitoring:

echo "0 9 * * * /home/$(whoami)/nginx-proxy/cert-monitor.sh | logger -t cert-monitor" | crontab -

Verify the ACME companion is working by checking logs:

docker-compose logs acme-companion | tail -20

Démontrez comment ajouter plusieurs services derrière le proxy inverse. Cela montre la véritable puissance de la configuration de proxy automatisée pour l'architecture de microservices.

Créez un deuxième service de test (API backend) :

mkdir ~/api-service && cd ~/api-service

Créez un service API simple :

// api.js
const express = require('express');
const app = express();
const PORT = 4000;

app.get('/health', (req, res) => {
  res.json({ status: 'healthy', service: 'api', version: '1.0.0' });
});

app.get('/users', (req, res) => {
  res.json({
    users: [
      { id: 1, name: 'John Doe' },
      { id: 2, name: 'Jane Smith' }
    ]
  });
});

app.listen(PORT, '0.0.0.0', () => {
  console.log(`API service running on port ${PORT}`);
});

Créez un Dockerfile pour le service API :

FROM node:18-alpine
WORKDIR /app
RUN npm init -y && npm install express
COPY api.js .
EXPOSE 4000
CMD ["node", "api.js"]

Construisez et déployez le service API :

docker build -t api-service .
docker run -d --name api-backend \
  --network nginx-proxy_nginx-reverse-proxy \
  -e VIRTUAL_HOST=api.yourdomain.com \
  -e LETSENCRYPT_HOST=api.yourdomain.com \
  -e VIRTUAL_PORT=4000 \
  api-service

Testez les deux services via le proxy :

curl -H "Host: app.yourdomain.com" http://localhost/
curl -H "Host: api.yourdomain.com" http://localhost/health

Vérifiez que les certificats SSL ont été générés automatiquement :

docker exec nginx-proxy ls -la /etc/nginx/certs/ | grep -E "(app|api).yourdomain.com"

Configurez l'équilibrage de charge pour les services à haute disponibilité et implémentez des vérifications de santé pour garantir que le trafic ne va qu'aux backends sains.

Créez un service équilibré en charge avec plusieurs instances :

cd ~/nginx-proxy

Ajoutez une configuration de service équilibré en charge à votre docker-compose.yml :

  web-app-1:
    image: test-app
    container_name: web-app-1
    environment:
      - VIRTUAL_HOST=lb.yourdomain.com
      - LETSENCRYPT_HOST=lb.yourdomain.com
      - VIRTUAL_PORT=3000
    networks:
      - nginx-reverse-proxy
    restart: unless-stopped

  web-app-2:
    image: test-app
    container_name: web-app-2
    environment:
      - VIRTUAL_HOST=lb.yourdomain.com
      - LETSENCRYPT_HOST=lb.yourdomain.com
      - VIRTUAL_PORT=3000
    networks:
      - nginx-reverse-proxy
    restart: unless-stopped

Créez une configuration upstream personnalisée pour les vérifications de santé :

# config/lb.yourdomain.com_location
location /health {
    access_log off;
    return 200 "healthy\n";
    add_header Content-Type text/plain;
}

location / {
    proxy_pass http://lb.yourdomain.com;
    proxy_set_header Host $host;
    proxy_set_header X-Real-IP $remote_addr;
    proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
    proxy_set_header X-Forwarded-Proto $scheme;
    
    # Paramètres de vérification de santé
    proxy_next_upstream error timeout invalid_header http_500 http_502 http_503;
    proxy_connect_timeout 5s;
    proxy_send_timeout 10s;
    proxy_read_timeout 10s;
}

Déployez les services équilibrés en charge :

docker-compose up -d web-app-1 web-app-2

Testez l'équilibrage de charge en effectuant plusieurs requêtes :

for i in {1..6}; do
  curl -s -H "Host: lb.yourdomain.com" http://localhost/ | jq .hostname
done

Vous devriez voir les requêtes réparties entre différents noms d'hôte de conteneur, confirmant que l'équilibrage de charge fonctionne.

Configurez une surveillance et une journalisation complètes pour votre proxy inverse afin de suivre les performances, les erreurs et les événements de sécurité.

Créez un format de journal Nginx personnalisé pour une meilleure surveillance :

# config/log_format.conf
log_format proxy_log '$remote_addr - $remote_user [$time_local] '
                     '"$request" $status $body_bytes_sent '
                     '"$http_referer" "$http_user_agent" '
                     '$request_time $upstream_response_time '
                     '$upstream_addr $upstream_status';

access_log /var/log/nginx/access.log proxy_log;

Créez une configuration de rotation des journaux :

# /etc/logrotate.d/nginx-proxy
~/nginx-proxy/logs/*.log {
    daily
    missingok
    rotate 52
    compress
    delaycompress
    notifempty
    create 644 root root
    postrotate
        docker exec nginx-proxy nginx -s reload
    endscript
}

Configurez un script de surveillance simple :

#!/bin/bash
# monitor-proxy.sh
LOG_FILE="~/nginx-proxy/logs/access.log"
ERROR_THRESHOLD=10
TIME_WINDOW="1 minute ago"

# Vérifiez les taux d'erreur élevés
ERROR_COUNT=$(grep -c " 5[0-9][0-9] " $LOG_FILE | tail -100)
if [ $ERROR_COUNT -gt $ERROR_THRESHOLD ]; then
    echo "TAUX D'ERREUR ÉLEVÉ : $ERROR_COUNT erreurs 5xx détectées"
fi

# Vérifiez la santé du proxy
docker-compose ps | grep -q "Up" || echo "ALERTE : Les conteneurs proxy ne fonctionnent pas"

# Vérifiez l'espace disque pour les journaux
DISK_USAGE=$(df ~/nginx-proxy/logs | tail -1 | awk '{print $5}' | sed 's/%//')
if [ $DISK_USAGE -gt 80 ]; then
    echo "AVERTISSEMENT : Utilisation du disque des journaux à ${DISK_USAGE}%"
fi

# Vérifiez l'expiration des certificats
./cert-monitor.sh

Rendez le script de surveillance exécutable et ajoutez-le à cron :

chmod +x monitor-proxy.sh
echo "*/5 * * * * /home/$(whoami)/nginx-proxy/monitor-proxy.sh" | crontab -

Testez la configuration complète en vérifiant tous les services :

docker-compose ps
docker-compose logs --tail=50
curl -I https://app.yourdomain.com
curl -I https://api.yourdomain.com