Maîtriser Nginx : Installation, Configuration et Haute Disponibilité

Nginx (prononcé "angine-x") est un serveur web HTTP et proxy inverse réputé pour ses performances exceptionnelles, sa faible consommation de mémoire et sa grande capacité de gestion des connexions concurrentes. Il est également capable de servir des protocoles IMAP/POP3/SMTP. Conçu pour l'optimisation des performances, Nginx peut gérer des dizaines de milliers de connexions simultanées, et sa capacité de redéploiement à chaud permet d'appliquer des modifications de configuration sans interruption de service.

Concepts Fondamentaux de Nginx

Proxy Inverse

Un proxy inverse agit comme un intermédiaire entre les clients et les serveurs web, dissimulant l'adresse IP réelle des serveurs derrière lui et distribuant les requêtes. Il expose uniquement l'adresse du serveur proxy au monde extérieur, masquant ainsi l'infrastructure backend. Contrairement à un proxy direct qui agit pour le client, un proxy inverse agit pour le serveur, améliorant la sécurité, la performance et la gestion du trafic.

Équilibrage de Charge (Load Balancing)

L'équilibrage de charge consiste à répartir les requêtes entrantes entre plusieurs serveurs pour optimiser l'utilisation des ressources, maximiser le débit, minimiser le temps de réponse et éviter la surcharge d'un serveur unique. Nginx est un excellent outil pour implémenter diverses stratégies d'équilibrage de charge, garantissant ainsi la robustesse et la scalabilité des applications.

Séparation des Contanus Statiques et Dynamiques

Cette technique permet de servir les fichiers statiques (images, CSS, JavaScript) directement par Nginx, qui est très efficace pour cela, tandis que les requêtes pour le contenu dynamique sont transmises à des serveurs d'applications dédiés (comme Tomcat, PHP-FPM). Cela réduit la charge sur les serveurs d'applications et améliore significativement les temps de réponse pour les utilisateurs.

Installation et Configuration Initiale de Nginx

Installation des Dépendances

Pour compiler Nginx, plusieurs dépendances sont nécessaires. La plupart peuvent être installées via le gestionnaire de paquets de votre système Linux (ici, un système basé sur Yum).


sudo yum install -y gcc zlib zlib-devel pcre-devel openssl openssl-devel

Installation de Nginx

Une fois les dépendances installées, téléchargez les sources de Nginx depuis le site officiel (http://nginx.org/). L'exemple utilise une version courante, par exemple 1.20.1 :


wget http://nginx.org/download/nginx-1.20.1.tar.gz
tar -zxvf nginx-1.20.1.tar.gz
cd nginx-1.20.1
./configure --prefix=/usr/local/nginx --with-http_ssl_module --with-http_stub_status_module
make
sudo make install

Après l'installation, Nginx sera généralement situé dans le répertoire /usr/local/nginx.

Commandes Courantes de Nginx

Les scripts de gestion de Nginx se trouvent dans /usr/local/nginx/sbin.

  • Démarrer Nginx :

    sudo /usr/local/nginx/sbin/nginx
  1. Vérifier le statut des processus Nginx :

   ps -ef | grep nginx
  1. Arrêter Nginx en douceur :

   sudo /usr/local/nginx/sbin/nginx -s stop
  1. Recharger la configuration (sans redémarrer le service) :

   sudo /usr/local/nginx/sbin/nginx -s reload
  1. Afficher la version de Nginx :

   /usr/local/nginx/sbin/nginx -v

Assurez-vous que le pare-feu du système est configuré pour autoriser le trafic sur les ports nécessaires (par exemple, le port 80 pour HTTP) :


sudo firewall-cmd --add-port=80/tcp --permanent
sudo firewall-cmd --reload

Structure du Fichier de Configuration Nginx

Le fichier de configuration principal est /usr/local/nginx/conf/nginx.conf. Il est organisé en plusieurs blocs hiérarchiques :

  • Bloc Global (main) : Contient des directives qui affectent le fonctionnement général de Nginx, comme worker_processes, qui définit le nombre de processus de travail.
  • Bloc events : Configure les paramètres de connexion réseau, notamment worker_connections, qui spécifie le nombre maximal de connexions simultanées qu'un processus de travail peut gérer.
  • Bloc http : Ce bloc englobe la plupart des configurations liées aux serveurs web (proxy, cache, logs). Il peut contenir des directives HTTP globales et un ou plusieurs blocs server.
    • Bloc server : Chaque bloc server définit un hôte virtuel, permettant de gérer différentes applications ou sites web sur une même instance Nginx. Il inclut des directives telles que listen (port d'écoute) et server_name (nom de domaine).
    • Bloc location : Situé à l'intérieur d'un bloc server, un bloc location détermine comment Nginx doit traiter les requêtes en fonction de leur URI. C'est ici que sont configurés le proxy inverse, la gestion des fichiers statiques, la redirection, et d'autres fonctionnalités spécifiques.

Configuration de Nginx pour le Proxy Inverse

Pour illustrer un proxy inverse, nous allons configurer Nginx pour rediriger les requêtes de www.monappli.com vers un serveur Tomcat local écoutant sur le port 8080.

Premièrement, assurez-vous que Tomcat est installé et démarré, et que son port 8080 est ouvert sur le pare-feu :


# Exemple de démarrage de Tomcat (supposé installé dans /usr/local/tomcat)
/usr/local/tomcat/bin/startup.sh
sudo firewall-cmd --add-port=8080/tcp --permanent
sudo firewall-cmd --reload

Pour simuler la résolution DNS, ajoutez une entrée à votre fichier /etc/hosts sur votre machine locale (client) :


192.168.1.101 www.monappli.com

Modifiez le fichier /usr/local/nginx/conf/nginx.conf pour inclure le bloc server suivant :


http {
    # ... autres configurations HTTP globales ...

    server {
        listen 80;
        server_name www.monappli.com;

        location / {
            proxy_pass http://localhost:8080; # Ou l'IP de votre serveur Tomcat
            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;
        }
    }
}

Après la modification, rechargez Nginx : sudo /usr/local/nginx/sbin/nginx -s reload. Vous devriez maintenant pouvoir accéder à votre application Tomcat via http://www.monappli.com.

Équilibrage de Charge avec Nginx

Nginx excelle dans la distribution des requêtes entre plusieurs serveurs d'applications. Voici un exemple d'équilibrage de charge avec la stratégie de pondération (weight) et ip_hash.


http {
    # Définition d'un groupe de serveurs backend
    upstream backend_servers {
        server 192.168.1.10:8080 weight=5; # Reçoit 5 fois plus de requêtes
        server 192.168.1.11:8080 weight=3; # Reçoit 3 fois plus de requêtes
        server 192.168.1.12:8080;          # Poids par défaut de 1
    }

    server {
        listen 80;
        server_name www.balance.com;

        location / {
            proxy_pass http://backend_servers;
            proxy_set_header Host $host;
            proxy_set_header X-Real-IP $remote_addr;
            proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
        }
    }
}

Pour une persistance de session basée sur l'IP client (utile si les serveurs backend ne partagent pas les sessions), utilisez la directive ip_hash :


upstream backend_servers_iphash {
    ip_hash;
    server 192.168.1.10:8080;
    server 192.168.1.11:8080;
}

server {
    listen 80;
    server_name www.iphash.com;

    location / {
        proxy_pass http://backend_servers_iphash;
        # ... autres en-têtes proxy ...
    }
}

D'autres stratégies courantes incluent least_conn (requêtes vers le serveur avec le moins de connexions actives) et round-robin (par défaut, répartition égale des requêtes).

Séparation des Contenus Statiques et Dynamiques

Pour optimiser les performances, Nginx peut servir directement les fichiers statiques (images, CSS, JavaScript) avec une grande efficacité, tandis que les requêtes pour le contenu dynamique sont transférées à un serveur d'applications.


server {
    listen 80;
    server_name www.separation.com;

    # Servir les fichiers statiques directement depuis un répertoire
    location ~* \.(jpg|jpeg|gif|png|ico|css|js|html)$ {
        root /var/www/static; # Chemin absolu vers les fichiers statiques
        expires 30d;          # Mettre en cache les ressources statiques pendant 30 jours
        log_not_found off;    # Ne pas logguer les erreurs 404 pour les statiques
    }

    # Transférer les requêtes dynamiques au serveur d'applications
    location / {
        proxy_pass http://localhost:8080; # Ou l'adresse de votre serveur d'applications
        proxy_set_header Host $host;
        proxy_set_header X-Real-IP $remote_addr;
        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
    }
}

Mise en Place d'un Cluster Nginx Haute Disponibilité avec Keepalived

Pour assurer la continuité de service, nous pouvons configurer un cluster Nginx en haute disponibilité à l'aide de Keepalived. Ce setup implique deux serveurs (maître et esclave) partageant une adresse IP virtuelle (VIP).

Prérequis

  • Deux machines Linux (par exemple, 192.168.17.129 pour le maître, 192.168.17.131 pour l'esclave).
  • Nginx installé et configuré sur les deux serveurs.
  • Keepalived installé sur les deux serveurs.

Installation de Keepalived

Installez Keepalived sur les deux serveurs :


sudo yum install -y keepalived

Le fichier de configuration principal de Keepalived est /etc/keepalived/keepalived.conf.

Configuration de Keepalived (Maître et Esclave)

Modifiez le fichier /etc/keepalived/keepalived.conf sur les deux serveurs.

Configuration du Serveur Maître (ex: 192.168.17.129)


global_defs {
    router_id NGINX_MASTER # Identifiant unique du routeur pour le maître
}

# Script pour vérifier le statut de Nginx
vrrp_script chk_nginx {
    script "/etc/keepalived/check_nginx.sh" # Chemin vers le script de vérification
    interval 2                                # Exécution toutes les 2 secondes
    weight 50                                 # Augmente la priorité si le script réussit
}

vrrp_instance VI_1 {
    state MASTER                            # Rôle : Maître
    interface ens33                         # Interface réseau à surveiller (à adapter)
    virtual_router_id 51                    # ID de routeur virtuel (doit être identique sur maître et backup)
    priority 100                            # Priorité plus élevée pour le maître
    advert_int 1                            # Intervalle d'envoi des annonces VRRP (1 seconde)
    authentication {
        auth_type PASS
        auth_pass mysecretpass              # Mot de passe pour l'authentification VRRP
    }
    virtual_ipaddress {
        192.168.17.50/24                    # Adresse IP virtuelle flottante
    }
    track_script {
        chk_nginx                           # Associer le script de vérification de Nginx
    }
}

Configuration du Serveur Esclave (ex: 192.168.17.131)


global_defs {
    router_id NGINX_BACKUP # Identifiant unique du routeur pour l'esclave
}

vrrp_script chk_nginx {
    script "/etc/keepalived/check_nginx.sh"
    interval 2
    weight 50
}

vrrp_instance VI_1 {
    state BACKUP                            # Rôle : Esclave
    interface ens33                         # Interface réseau à surveiller (à adapter)
    virtual_router_id 51                    # ID de routeur virtuel (doit être identique)
    priority 90                             # Priorité plus basse pour l'esclave
    advert_int 1
    authentication {
        auth_type PASS
        auth_pass mysecretpass
    }
    virtual_ipaddress {
        192.168.17.50/24                    # Adresse IP virtuelle flottante
    }
    track_script {
        chk_nginx
    }
}

Création du Script de Vérification Nginx

Créez le script /etc/keepalived/check_nginx.sh sur les deux serveurs et rendez-le exécutable. Ce script vérifie si Nginx est en cours d'exécution et tente de le redémarrer si ce n'est pas le cas.


#!/bin/bash
# Compte le nombre de processus Nginx en cours d'exécution
NGINX_PROCS=$(ps -C nginx --no-header | wc -l)

if [ $NGINX_PROCS -eq 0 ]; then
    # Nginx est arrêté, tenter de le démarrer
    /usr/local/nginx/sbin/nginx
    sleep 2 # Laisser le temps à Nginx de démarrer
    NGINX_PROCS_AFTER_RESTART=$(ps -C nginx --no-header | wc -l)
    if [ $NGINX_PROCS_AFTER_RESTART -eq 0 ]; then
        exit 1 # Nginx n'a pas réussi à démarrer, signaler une erreur
    else
        exit 0 # Nginx a démarré avec succès
    fi
else
    exit 0 # Nginx est déjà en cours d'exécution
fi



sudo chmod +x /etc/keepalived/check_nginx.sh

Démarrage et Test du Cluster HA

Après la configuration, démarrez Nginx et Keepalived sur les deux machines :


# Sur les deux serveurs
sudo /usr/local/nginx/sbin/nginx
sudo systemctl start keepalived.service
sudo systemctl enable keepalived.service # Pour un démarrage automatique au boot

Vérifiez l'attribution de l'IP virtuelle avec ip addr show ens33 (remplacez ens33 par votre interface réseau) sur les deux serveurs. L'IP virtuelle (192.168.17.50) devrait initialement être visible sur le serveur maître.

Test de Basculement (Failover)

Accédez à votre application via l'IP virtuelle http://192.168.17.50 depuis votre navigateur. Elle devrait être servie par le serveur maître.

Pour tester le basculement, arrêtez Nginx et/ou Keepalived sur le serveur maître :


# Sur le serveur maître (192.168.17.129)
sudo systemctl stop keepalived.service
# Ou, si vous voulez juste tester le script de vérification Nginx
sudo /usr/local/nginx/sbin/nginx -s stop

L'IP virtuelle devrait alors migrer automatiquement vers le serveur esclave en quelques secondes. L'accès via http://192.168.17.50 devrait toujours fonctionner, désormais servi par l'esclave, assurant ainsi une haute disponibilité.

Étiquettes: nginx proxy inverse Équilibrage de charge haute disponibilité Keepalived

Publié le 16 juillet à 13h04

Étiquettes Populaires

©2026 L'Atelier Monstre