Le serveur Nginx remplit plusieurs fonctions clés dans l'infrastructure web :

• Masquage et protection des serveurs d'origine exposés.
• Équilibrage de charge pour optimiser l'utilisation des ressources, augmenter le débit global et réduire les temps de réponse en distribuant les requêtes entre plusieurs instances.
• Gestion des connexions HTTPS via un proxy inverse sur le port 443.

Commandes de Base pour Nginx

Pour interagir avec le service Nginx, on se place généralement dans le répertoire d'installation exécutable :

nginx                      # Démarrer le service
nginx -t                   # Valider la syntaxe du fichier de configuration
nginx -s reload            # Recharger la configuration sans interruption
nginx -s stop              # Arrêter le service immédiatement
nginx -s quit              # Terminer proprement le service
ps aux | grep nginx        # Vérifier les processus en cours

Mise en Place du Proxy Inverse

Le proxy inverse agit comme intermédiaire : il reçoit les requêtes des clients internet, les transmet aux serveurs internes, puis retourne les réponses aux clients. Cela permet de dissimuler l'architecture interne et de sécuriser les ressources.

Voici un exemple de configuration pour rediriger le trafic vers un serveur d'applications :

server {
    listen 80;
    server_name mon-domaine.com;
    client_max_body_size 512M;

    # Servir l'application frontend
    location / {
        root /var/www/mon-app/dist;
        index index.html;
        try_files $uri $uri/ /index.html;
    }

    # Relayer les requêtes API vers le backend
    location /service {
        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_pass http://192.168.1.10:3000/api;
    }

    # Fournir des fichiers statiques
    location /assets/ {
        alias /var/www/statique/;
        autoindex on;
    }

    # Bloquer l'accès aux fichiers sensibles
    location ~* \.(log|conf)$ {
        root /var/www/protected;
        deny all;
    }

    # Protection contre le hotlinking
    location ~* \.(png|svg|mp4)$ {
        valid_referers none blocked mon-domaine.com;
        if ($invalid_referer) {
            rewrite ^/ https://mon-domaine.com/blocked.png;
        }
    }

    # Activer le cache pour les ressources statiques
    proxy_cache_path /tmp/nginx_cache levels=1:2 keys_zone=zone_cache:10m max_size=5g inactive=7d use_temp_path=off;
    location ~* \.(css|js|woff2|ico)$ {
        expires 7d;
        add_header Cache-Control "public";
        proxy_cache zone_cache;
        proxy_cache_valid 200 302 7d;
        proxy_cache_key $host$uri$is_args$args;
        proxy_cache_bypass $http_cache_control;
    }

    # Proxyfication des requêtes dynamiques vers un groupe de serveurs
    location ~ \.(php|cgi)$ {
        proxy_pass http://backend_pool;
    }
}

Après avoir sauvegardé ce fichier et redémarré Nginx, accéder à mon-domaine.com équivaut à requêter le serveur d'applications cible.

Hébergement de Multiples Applications Frontend

Consolider plusieurs applications sur un seul port réduit l'exposition réseau. L'approche consiste à utiliser des chemins d'URL distincts.

Configuration Nginx pour deux projets frontend :

server {
    listen 80;
    server_name portail.exemple.com;

    # Première application : accessible à la racine
    location / {
        root /opt/apps/app-principale/build;
        index index.html;
        try_files $uri $uri/ /index.html;
    }
    location /api-principale {
        proxy_set_header Host $host;
        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
        proxy_pass http://127.0.0.1:9001/endpoint;
    }

    # Deuxième application : sous le chemin /outils
    location /outils {
        alias /opt/apps/app-secondaire/dist;
        index index.html;
        try_files $uri $uri/ /outils/index.html;
    }
    location /outils/api-secondaire {
        proxy_set_header Host $host;
        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
        proxy_pass http://127.0.0.1:9002/data;
    }

    error_page 500 502 503 504 /erreur.html;
    location = /erreur.html {
        root /usr/share/nginx/html;
    }
}

Configuration du Proxy Inverse pour HTTPS

Pour sécuriser les communications, on redirgie le trafic HTTP vers HTTPS et on gère le chiffrement SSL/TLS.

server {
    listen 80;
    server_name secure.example.com;
    return 301 https://$host$request_uri;
}

server {
    listen 443 ssl http2;
    server_name secure.example.com;

    ssl_certificate /etc/ssl/certs/site.crt;
    ssl_certificate_key /etc/ssl/private/site.key;
    ssl_session_timeout 10m;
    ssl_protocols TLSv1.2 TLSv1.3;
    ssl_ciphers HIGH:!aNULL:!MD5;
    ssl_prefer_server_ciphers on;

    location / {
        root /var/www/secure-app;
        index index.html;
        try_files $uri $uri/ /index.html;
    }

    error_page 500 502 503 504 /erreur.html;
    location = /erreur.html {
        root /usr/share/nginx/html;
    }
}

Équilibrage de Charge avec Nginx

L'équilibrage de charge distribue les requêtes entrantes antre plusieurs serveurs pour améliorer la disponibilité et les performances. On définit un pool de serveurs en amont et on y redirige le trafic.

Exemple de configuration avec pondération :

upstream serveurs_app {
    server srv1.exemple.com:8080 weight=3;
    server srv2.exemple.com:8080 weight=2;
    server srv3.exemple.com:8080 backup;
}

server {
    listen 80;
    server_name app.exemple.com;
    client_max_body_size 1G;

    location / {
        proxy_pass http://serveurs_app;
        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;
    }
}

Nginx vérifie automatiquement l'état des serveurs cibles ; si un serveur est injoignable, il est exclu temporairement de la rotasion. L'algorithme par défaut (Round Robin) répartit les requêtes de manière cyclique sans configuration supplémentaire.