NGINX avec Node.js : équilibrage de charge, diffusion de contenu statique et SSL

NGINX est un serveur Web puissant et polyvalent qui joue un rôle essentiel dans la mise à l'échelle des applications Node.js. Il est couramment utilisé comme proxy inverse pour gérer l'équilibrage de charge, diffuser du contenu statique et gérer la terminaison SSL. Dans cet article, nous explorerons comment utiliser NGINX avec Node.js, en expliquant le fonctionnement de chacune de ces fonctions avec des exemples pratiques.

Pourquoi utiliser NGINX avec Node.js ?

Bien que Node.js excelle dans la création d'applications évolutives basées sur des événements, ce n'est peut-être pas le moyen le plus efficace de gérer des tâches telles que l'équilibrage de charge, la diffusion de contenu statique ou la terminaison SSL. C'est là qu'intervient NGINX. NGINX est optimisé pour gérer efficacement un grand nombre de connexions simultanées, ce qui en fait le compagnon idéal pour les applications Node.js qui doivent évoluer.

Principaux avantages de l'utilisation de NGINX avec Node.js :

1. Équilibrage de charge : NGINX peut répartir le trafic sur plusieurs instances Node.js, garantissant ainsi qu'aucun serveur n'est submergé.
2. Servir du contenu statique : il sert efficacement les fichiers statiques (par exemple, CSS, JS, images), permettant à Node.js de se concentrer sur le contenu dynamique.
3. Terminaison SSL : NGINX gère le cryptage et le déchiffrement SSL/TLS, réduisant ainsi la charge sur Node.js.

1. Équilibrage de charge avec NGINX

Lors d'une mise à l'échelle horizontale, vous devrez exécuter plusieurs instances de votre application Node.js. NGINX peut répartir le trafic entrant sur ces instances, garantissant ainsi une charge uniforme.

Étape 1 : Installer NGINX

Sur un système Ubuntu, vous pouvez installer NGINX avec la commande suivante :

sudo apt update
sudo apt install nginx

Étape 2 : Configuration NGINX pour l'équilibrage de charge

Le fichier nginx.conf est l'endroit où vous définissez comment NGINX gère les requêtes entrantes. Voici comment configurer NGINX pour équilibrer la charge sur trois instances Node.js.

http {
    upstream node_app {
        server 127.0.0.1:3000;
        server 127.0.0.1:3001;
        server 127.0.0.1:3002;
    }

    server {
        listen 80;

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

Explication :

• Le bloc en amont définit le pool d'instances Node.js entre lesquelles NGINX équilibrera le trafic.
• La directive proxy_pass transmet les requêtes à l'une des instances Node.js.

Étape 3 : démarrer plusieurs instances Node.js

node app.js --port 3000 &
node app.js --port 3001 &
node app.js --port 3002 &

Étape 4 : démarrez NGINX

Une fois NGINX configuré, démarrez-le en utilisant :

sudo systemctl start nginx

Tester la configuration :
Désormais, la visite de l'adresse IP ou du domaine de votre serveur devrait répartir les requêtes entre les trois instances Node.js.

2. Servir du contenu statique avec NGINX

Les applications Node.js doivent souvent servir des fichiers statiques (comme des images, CSS et JavaScript). NGINX est beaucoup plus efficace dans cette tâche, car il est conçu pour gérer un grand nombre de requêtes de fichiers statiques.

Étape 1 : Configuration NGINX pour les fichiers statiques

Modifiez le fichier nginx.conf pour définir un emplacement pour le contenu statique.

server {
    listen 80;

    # Serve static content directly
    location /static/ {
        root /var/www/html;
    }

    # Proxy dynamic requests to Node.js
    location / {
        proxy_pass http://localhost:3000;
        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;
    }
}

Explication :

• Le bloc location /static/ indique à NGINX de servir les fichiers de /var/www/html/static/ lorsque des requêtes sont adressées à /static/.
• D'autres requêtes sont transmises par proxy à l'application Node.js.

Étape 2 : déplacer les fichiers statiques

Déplacez vos fichiers statiques (par exemple, images, CSS, JavaScript) vers le répertoire /var/www/html/static/.

sudo mkdir -p /var/www/html/static
sudo cp -r path/to/static/files/* /var/www/html/static/

Désormais, les demandes de ressources /static seront traitées directement par NGINX, améliorant ainsi les performances de votre serveur Node.js.

3. Résiliation SSL avec NGINX

SSL (Secure Sockets Layer) est essentiel pour sécuriser la communication entre vos utilisateurs et votre application. NGINX peut décharger les demandes de terminaison, de cryptage et de déchiffrement SSL, de sorte que votre application Node.js n'a pas besoin de gérer SSL elle-même.

Étape 1 : Obtenez un certificat SSL

Vous pouvez obtenir un certificat SSL gratuitement grâce à Let's Encrypt :

sudo apt install certbot python3-certbot-nginx
sudo certbot --nginx -d yourdomain.com

Étape 2 : Configuration SSL NGINX

Une fois le certificat SSL émis, vous pouvez configurer NGINX pour gérer le trafic SSL.

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

server {
    listen 443 ssl;
    server_name yourdomain.com;

    ssl_certificate /etc/letsencrypt/live/yourdomain.com/fullchain.pem;
    ssl_certificate_key /etc/letsencrypt/live/yourdomain.com/privkey.pem;

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

Explication :

• Le premier bloc du serveur redirige tout le trafic HTTP vers HTTPS.
• Le deuxième bloc écoute sur le port 443 (HTTPS), gérant le cryptage SSL avec le certificat émis par Let's Encrypt.

Étape 3 : tester la configuration SSL

Visitez votre domaine (par exemple, https://votredomaine.com) et votre application Node.js devrait maintenant être diffusée via HTTPS.

Configurations NGINX supplémentaires pour l'optimisation de Node.js

1. Gestion des délais d'attente

Pour éviter que les requêtes de longue durée ne soient fermées prématurément, configurez les paramètres de délai d'attente de NGINX.

server {
    proxy_read_timeout 90s;
    proxy_send_timeout 90s;
    send_timeout 90s;
}

2. Rate Limiting

Rate limiting can help prevent abuse and manage high traffic by limiting the number of requests a user can make in a given time.

http {
    limit_req_zone $binary_remote_addr zone=mylimit:10m rate=1r/s;

    server {
        location / {
            limit_req zone=mylimit burst=5;
            proxy_pass http://localhost:3000;
        }
    }
}

Explanation:

• The limit_req_zone directive defines a rate limit of 1 request per second.
• The burst parameter allows a small number of requests to exceed the limit before throttling kicks in.

Conclusion

NGINX is a powerful tool that can significantly enhance the performance, security, and scalability of your Node.js applications. By offloading tasks such as load balancing, serving static content, and handling SSL termination to NGINX, your Node.js server can focus on what it does best: processing dynamic content and handling real-time events.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!