Node.js + Nginx - Et maintenant?

J'ai installé Node.js et Nginx sur mon serveur. Maintenant, je veux l'utiliser, mais, avant de commencer, il y a 2 questions:

1. Comment devraient-ils travailler ensemble? Comment dois-je traiter les demandes?

2. Il existe 2 concepts pour un serveur Node.js, lequel est le meilleur:

   une. Créez un serveur HTTP distinct pour chaque site Web qui en a besoin. Chargez ensuite tout le code JavaScript au début du programme, afin que le code soit interprété une fois.

   b. Créez un seul serveur Node.js qui gère toutes les demandes Node.js. Ceci lit les fichiers demandés et en évalue le contenu. Les fichiers sont donc interprétés à chaque requête, mais la logique du serveur est beaucoup plus simple.

Il n'est pas clair pour moi comment utiliser correctement Node.js.

Nginx fonctionne comme un serveur frontal, qui dans ce cas procède par proxy aux demandes d'un serveur node.js. Par conséquent, vous devez configurer un fichier de configuration nginx pour le nœud.

Voici ce que j'ai fait dans ma boîte Ubuntu:

Créez le fichier yourdomain.comà /etc/nginx/sites-available/:

vim /etc/nginx/sites-available/yourdomain.com

Vous devriez y avoir quelque chose comme:

# the IP(s) on which your node server is running. I chose port 3000.
upstream app_yourdomain {
    server 127.0.0.1:3000;
    keepalive 8;
}

# the nginx server instance
server {
    listen 80;
    listen [::]:80;
    server_name yourdomain.com www.yourdomain.com;
    access_log /var/log/nginx/yourdomain.com.log;

    # pass the request to the node.js server with the correct headers
    # and much more can be added, see nginx config options
    location / {
      proxy_set_header X-Real-IP $remote_addr;
      proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
      proxy_set_header Host $http_host;
      proxy_set_header X-NginX-Proxy true;

      proxy_pass http://app_yourdomain/;
      proxy_redirect off;
    }
 }

Si vous souhaitez que nginx (> = 1.3.13) gère également les requêtes Websocket, ajoutez les lignes suivantes dans la location /section:

proxy_http_version 1.1;
proxy_set_header Upgrade $http_upgrade;
proxy_set_header Connection "upgrade";

Une fois que vous avez cette configuration, vous devez activer le site défini dans le fichier de configuration ci-dessus:

cd /etc/nginx/sites-enabled/ 
ln -s /etc/nginx/sites-available/yourdomain.com yourdomain.com

Créez votre application de serveur de nœuds sur /var/www/yourdomain/app.jset exécutez-la surlocalhost:3000

var http = require('http');

http.createServer(function (req, res) {
    res.writeHead(200, {'Content-Type': 'text/plain'});
    res.end('Hello World\n');
}).listen(3000, "127.0.0.1");
console.log('Server running at http://127.0.0.1:3000/');

Testez les erreurs de syntaxe:

nginx -t

Redémarrez nginx:

sudo /etc/init.d/nginx restart

Enfin, démarrez le serveur de noeud:

cd /var/www/yourdomain/ && node app.js

Vous devriez maintenant voir "Hello World" sur votredomaine.com

Une dernière remarque concernant le démarrage du serveur de nœuds: vous devez utiliser une sorte de système de surveillance pour le démon de nœuds. Il y a un tutoriel génial sur le nœud avec upstart et monit .

Vous pouvez également configurer plusieurs domaines avec nginx et les transférer vers plusieurs processus node.js.

Par exemple, pour atteindre ces objectifs:

• domain1.com -> au processus Node.js s'exécutant localement http://127.0.0.1:4000
• domain2.com -> au processus Node.js s'exécutant localement http://127.0.0.1:5000

Ces ports (4000 et 5000) doivent être utilisés pour écouter les demandes d'application dans votre code d'application.

/ etc / nginx / sites-enabled / domain1

server {
    listen 80;
    listen [::]:80;
    server_name domain1.com;
    access_log /var/log/nginx/domain1.access.log;
    location / {
        proxy_pass    http://127.0.0.1:4000/;
    }
}

Dans / etc / nginx / sites-enabled / domain2

server {
    listen 80;
    listen [::]:80;
    server_name domain2.com;
    access_log /var/log/nginx/domain2.access.log;
    location / {
        proxy_pass    http://127.0.0.1:5000/;
    }
}

Vous pouvez également avoir différentes URL pour les applications dans une configuration de serveur:

• votredomaine.com/app1/* -> vers le processus Node.js s'exécutant localement http://127.0.0.1:3000
• votredomaine.com/app2/* -> vers le processus Node.js exécuté localement http://127.0.0.1:4000

Dans / etc / nginx / sites-enabled / yourdomain :

server {
    listen 80;
    listen [::]:80;
    server_name yourdomain.com;

    location ^~ /app1/{
        proxy_set_header X-Real-IP $remote_addr;
        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
        proxy_set_header Host $http_host;
        proxy_set_header X-NginX-Proxy true;
        proxy_pass    http://127.0.0.1:3000/;
    }

    location ^~ /app2/{
        proxy_set_header X-Real-IP $remote_addr;
        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
        proxy_set_header Host $http_host;
        proxy_set_header X-NginX-Proxy true;
        proxy_pass    http://127.0.0.1:4000/;
    }
}

Redémarrez nginx:

sudo service nginx restart

Démarrage des applications.

node app1.js

var http = require('http');
http.createServer(function (req, res) {
    res.writeHead(200, {'Content-Type': 'text/plain'});
    res.end('Hello from app1!\n');
}).listen(3000, "127.0.0.1");
console.log('Server running at http://127.0.0.1:3000/');

node app2.js

var http = require('http');
http.createServer(function (req, res) {
    res.writeHead(200, {'Content-Type': 'text/plain'});
    res.end('Hello from app2!\n');
}).listen(4000, "127.0.0.1");
console.log('Server running at http://127.0.0.1:4000/');

Je proxy des applications Node Express indépendantes via Nginx.

Ainsi, de nouvelles applications peuvent être facilement montées et je peux également exécuter d'autres choses sur le même serveur à différents endroits.

Voici plus de détails sur ma configuration avec l'exemple de configuration Nginx:

Déployez plusieurs applications Node sur un serveur Web dans des sous-dossiers avec Nginx

Les choses deviennent difficiles avec Node lorsque vous devez déplacer votre application de l'hôte local vers Internet.

Il n'y a pas d'approche commune pour le déploiement de Node.

Google peut trouver des tonnes d'articles sur ce sujet, mais j'avais du mal à trouver la bonne solution pour la configuration dont j'avais besoin.

Fondamentalement, j'ai un serveur Web et je souhaite que les applications Node soient montées sur des sous-dossiers (c'est-à-dire http: // myhost / demo / pet-project / ) sans introduire de dépendance de configuration dans le code d'application.

En même temps, je veux que d'autres choses comme le blog s'exécutent sur le même serveur Web.

Cela semble simple, hein? Apparemment non.

Dans de nombreux exemples sur le Web, les applications Node s'exécutent sur le port 80 ou sont mandatées par Nginx à la racine.

Même si les deux approches sont valables pour certains cas d'utilisation, elles ne répondent pas à mes critères simples mais un peu exotiques.

C'est pourquoi j'ai créé ma propre configuration Nginx et voici un extrait:

upstream pet_project {
  server localhost:3000;
}

server {
  listen 80;
  listen [::]:80;
  server_name frontend;

  location /demo/pet-project {
    alias /opt/demo/pet-project/public/;
    try_files $uri $uri/ @pet-project;
  }

  location @pet-project {
    rewrite /demo/pet-project(.*) $1 break;

    proxy_set_header X-Real-IP $remote_addr;
    proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
    proxy_set_header Host $proxy_host;
    proxy_set_header X-NginX-Proxy true;

    proxy_pass http://pet_project;
    proxy_redirect http://pet_project/ /demo/pet-project/;
  }
}

Dans cet exemple, vous pouvez remarquer que je monte mon application Pet Project Node exécutée sur le port 3000 sur http: // myhost / demo / pet-project .

Nginx vérifie d'abord si la ressource demandée est un fichier statique disponible dans / opt / demo / pet-project / public / et si c'est le cas, elle est très efficace, nous n'avons donc pas besoin d'avoir une couche redondante comme Connect middleware statique.

Ensuite, toutes les autres demandes sont écrasées et transmises par proxy à l' application Pet Project Node , de sorte que l'application Node n'a pas besoin de savoir où elle est réellement montée et peut donc être déplacée n'importe où uniquement par configuration.

proxy_redirect est indispensable pour gérer correctement l'en-tête Location. Ceci est extrêmement important si vous utilisez res.redirect () dans votre application Node.

Vous pouvez facilement répliquer cette configuration pour plusieurs applications Node exécutées sur différents ports et ajouter d'autres gestionnaires d'emplacement à d'autres fins.

De: http://skovalyov.blogspot.dk/2012/07/deploy-multiple-node-applications-on.html

Node.js avec configuration Nginx.

$ sudo nano /etc/nginx/sites-available/subdomain.your_domain.com

ajoutez la configuration suivante afin que Nginx agisse comme une redirection proxy vers le trafic du port 3000 depuis le serveur lorsque nous venons de «subdomain.votre_domaine.com»

upstream subdomain.your_domain.com {
  server 127.0.0.1:3000;
}
server {
  listen 80;
  listen [::]:80;
  server_name subdomain.your_domain.com;
  access_log /var/log/nginx/subdomain.your_domain.access.log;
  error_log /var/log/nginx/subdomain.your_domain.error.log debug;
  location / {
    proxy_set_header X-Real-IP $remote_addr;
    proxy_set_header X-Forwarder-For $proxy_add_x_forwarded_for;
    proxy_set_header Host $http_host;
    proxy_set_header X-NginX-Proxy true;
    proxy_pass http://subdomain.your_domain.com;
    proxy_redirect off;
  }
}

répondre à votre question 2:

J'utiliserais l'option bsimplement parce qu'elle consomme beaucoup moins de ressources. avec l'option 'a', chaque client fera que le serveur consommera beaucoup de mémoire, chargeant tous les fichiers dont vous avez besoin (même si j'aime php, c'est l'un des problèmes avec cela). Avec l'option 'b' vous pouvez charger vos bibliothèques (code réutilisable) et les partager entre toutes les demandes des clients.

Mais sachez que si vous avez plusieurs cœurs, vous devez modifier node.js pour les utiliser tous.

J'ai fait un dépôt dans Github que vous pouvez cloner, vagrant-node-nginx -ilerplate

Fondamentalement, l'application node.js /var/www/nodeappest à

var http = require('http');
http.createServer(function (req, res) {
  res.writeHead(200, {'Content-Type': 'text/plain'});
  res.end('Hello World\n');
}).listen(4570, '127.0.0.1');

console.log('Node Server running at 127.0.0.1:4570/');

et la configuration nginx /etc/nginx/sites-available/est

server {
        listen 80 default_server;
        listen [::]:80 default_server;

        root /var/www/nodeapp;
        index index.html index.htm;

        server_name localhost;

        location / {
          proxy_pass http://127.0.0.1:4570;
          proxy_http_version 1.1;
          proxy_set_header Upgrade $http_upgrade;
          proxy_set_header Connection 'upgrade';
          proxy_set_header Host $host;
          proxy_cache_bypass $http_upgrade;
        }
}

Vous pouvez également utiliser node.js pour générer des fichiers statiques dans un répertoire desservi par nginx. Bien sûr, certaines parties dynamiques de votre site peuvent être desservies par nœud, et certaines par nginx (statique).

Le fait que certains d'entre eux soient desservis par nginx augmente vos performances.

Nous pouvons facilement configurer une application Nodejs par Nginx agissant comme un proxy inverse.
La configuration suivante suppose que l'application NodeJS s'exécute sur 127.0.0.1:8080,

  server{
     server_name domain.com sub.domain.com; # multiple domains

     location /{ 
      proxy_pass http://127.0.0.1:8080;  
      proxy_set_header Host $host;
      proxy_pass_request_headers on;  
     }

     location /static/{
       alias /absolute/path/to/static/files; # nginx will handle js/css
     }
   } 

dans la configuration ci-dessus, votre application Nodejs

• obtenir un en- HTTP_HOSTtête où vous pouvez appliquer une logique spécifique au domaine pour servir la réponse. "

• Votre application doit être gérée par un gestionnaire de processus comme pm2 ou un superviseur pour gérer les situations / réutiliser les sockets ou les ressources, etc.

• Configurer un service de rapport d'erreurs pour obtenir des erreurs de production telles que sentinelle ou arceau

REMARQUE: vous pouvez configurer la logique pour gérer les itinéraires de demande spécifiques au domaine, créer un middleware pour l'application expressjs

Nginx peut agir comme un serveur proxy inverse qui fonctionne exactement comme un chef de projet. Lorsqu'il reçoit une demande, il l'analyse et la transmet en amont (membres du projet) ou se gère lui-même. Nginx a deux façons de traiter une demande en fonction de sa configuration.

• signifier la demande

• transmettre la demande à un autre serveur

  server{
   server_name mydomain.com sub.mydomain.com;
  
   location /{ 
    proxy_pass http://127.0.0.1:8000;  
    proxy_set_header Host $host;
    proxy_pass_request_headers on;  
   }
  
   location /static/{
     alias /my/static/files/path;
   }

  }

Servir la demande

Avec cette configuration, lorsque l'URL de demande est, mydomain.com/static/myjs.jselle renvoie le myjs.jsfichier dans le /my/static/files/pathdossier. Lorsque vous configurez nginx pour servir des fichiers statiques, il gère la demande elle-même.

transmettre la demande à un autre serveur

Lorsque l'URL de la demande est mydomain.com/dothisnginx, la demande est transmise à http://127.0.0.1:8000 . Le service qui s'exécute sur le port localhost 8000 recevra la demande et renvoie la réponse à nginx et nginx renvoie la réponse au client.

Lorsque vous exécutez le serveur node.js sur le port 8000, nginx transmet la demande à node.js. Écrivez la logique node.js et gérez la demande. C'est tout, vous avez votre serveur nodejs fonctionnant derrière le serveur nginx.

Si vous souhaitez exécuter d'autres services que nodejs, exécutez simplement un autre service comme Django, flask, php sur différents ports et configurez-le dans nginx.

Vous pouvez exécuter nodejs à l'aide de pm2 si vous souhaitez gérer chaque moyen de microservice et l'exécuter. Le nœud s'exécutera dans un port droit, il suffit de configurer ce port dans nginx (/etc/nginx/sites-enabled/domain.com)

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

  location / {
     return 403;
  }
    location /url {
        proxy_pass http://localhost:51967/info;
    }
}

Vérifiez si localhost est en cours d'exécution ou non en utilisant ping.

Et

Create one single Node.js server which handles all Node.js requests. This reads the requested files and evals their contents. So the files are interpreted on each request, but the server logic is much simpler.

C'est mieux et comme vous l'avez dit plus facile aussi

La configuration la meilleure et la plus simple avec Nginx et Nodejs consiste à utiliser Nginx comme équilibreur de charge HTTP et TCP avec proxy_protocol activé. Dans ce contexte, Nginx sera en mesure de proxyer les requêtes entrantes vers nodejs, et également de mettre fin aux connexions SSL au (x) serveur (s) Nginx backend, et non au serveur proxy lui-même. (SSL-PassThrough)

À mon avis, il est inutile de donner des exemples non SSL, car toutes les applications Web utilisent (ou devraient utiliser) des environnements sécurisés.

Exemple de configuration pour le serveur proxy, dans /etc/nginx/nginx.conf

user  nginx;
worker_processes  1;
error_log  /var/log/nginx/error.log warn;
pid        /var/run/nginx.pid;
events {
    worker_connections  1024;
}
http {
  upstream webserver-http {
    server 192.168.1.4; #use a host port instead if using docker
    server 192.168.1.5; #use a host port instead if using docker
  }
  upstream nodejs-http {
    server 192.168.1.4:8080; #nodejs listening port
    server 192.168.1.5:8080; #nodejs listening port
  }
  server {
    server_name example.com;
    location / {
      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;
      proxy_set_header Host $http_host;
      proxy_set_header X-Forwarded-Host $server_name;
      proxy_set_header Connection "";
      add_header       X-Upstream $upstream_addr;
      proxy_redirect     off;
      proxy_connect_timeout  300;
      proxy_http_version 1.1;
      proxy_buffers 16 16k;
      proxy_buffer_size 16k;
      proxy_cache_background_update on;
      proxy_pass http://webserver-http$request_uri;
    }
  }
  server {
    server_name node.example.com;
    location / {
      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;
      proxy_set_header Host $http_host;
      proxy_set_header X-Forwarded-Host $server_name;
      proxy_set_header Upgrade $http_upgrade;
      proxy_set_header Connection "Upgrade";
      add_header       X-Upstream $upstream_addr;
      proxy_redirect     off;
      proxy_connect_timeout  300;
      proxy_http_version 1.1;
      proxy_buffers 16 16k;
      proxy_buffer_size 16k;
      proxy_cache_background_update on;
      proxy_pass http://nodejs-http$request_uri;
    }
  }
}
stream {
  upstream webserver-https {
    server 192.168.1.4:443; #use a host port instead if using docker
    server 192.168.1.5:443; #use a host port instead if using docker
  }

  server {
    proxy_protocol on;
    tcp_nodelay on;
    listen 443;
    proxy_pass webserver-https;
  }
  log_format proxy 'Protocol: $protocol - $status $bytes_sent $bytes_received $session_time';
  access_log  /var/log/nginx/access.log proxy;
  error_log /var/log/nginx/error.log debug;
}

Maintenant, traitons le serveur Web principal. /etc/nginx/nginx.conf :

user  nginx;
worker_processes  1;
error_log  /var/log/nginx/error.log warn;
pid        /var/run/nginx.pid;
load_module /etc/nginx/modules/ngx_http_geoip2_module.so; # GeoIP2
events {
    worker_connections  1024;
}
http {
    variables_hash_bucket_size 64;
    variables_hash_max_size 2048;
    server_tokens off;
    sendfile    on;
    tcp_nopush  on;
    tcp_nodelay on;
    autoindex off;
    keepalive_timeout  30;
    types_hash_bucket_size 256;
    client_max_body_size 100m;
    server_names_hash_bucket_size 256;
    include         mime.types;
    default_type    application/octet-stream;
    index  index.php index.html index.htm;
    # GeoIP2
    log_format  main    'Proxy Protocol Address: [$proxy_protocol_addr] '
                        '"$request" $remote_addr - $remote_user [$time_local] "$request" '
                        '$status $body_bytes_sent "$http_referer" '
                        '"$http_user_agent" "$http_x_forwarded_for"';

    # GeoIP2
    log_format  main_geo    'Original Client Address: [$realip_remote_addr]- Proxy Protocol Address: [$proxy_protocol_addr] '
                            'Proxy Protocol Server Address:$proxy_protocol_server_addr - '
                            '"$request" $remote_addr - $remote_user [$time_local] "$request" '
                            '$status $body_bytes_sent "$http_referer" '
                            '$geoip2_data_country_iso $geoip2_data_country_name';

    access_log  /var/log/nginx/access.log  main_geo; # GeoIP2
#===================== GEOIP2 =====================#
    geoip2 /usr/share/geoip/GeoLite2-Country.mmdb {
        $geoip2_metadata_country_build  metadata build_epoch;
        $geoip2_data_country_geonameid  country geoname_id;
        $geoip2_data_country_iso        country iso_code;
        $geoip2_data_country_name       country names en;
        $geoip2_data_country_is_eu      country is_in_european_union;
    }
    #geoip2 /usr/share/geoip/GeoLite2-City.mmdb {
    #   $geoip2_data_city_name city names en;
    #   $geoip2_data_city_geonameid city geoname_id;
    #   $geoip2_data_continent_code continent code;
    #   $geoip2_data_continent_geonameid continent geoname_id;
    #   $geoip2_data_continent_name continent names en;
    #   $geoip2_data_location_accuracyradius location accuracy_radius;
    #   $geoip2_data_location_latitude location latitude;
    #   $geoip2_data_location_longitude location longitude;
    #   $geoip2_data_location_metrocode location metro_code;
    #   $geoip2_data_location_timezone location time_zone;
    #   $geoip2_data_postal_code postal code;
    #   $geoip2_data_rcountry_geonameid registered_country geoname_id;
    #   $geoip2_data_rcountry_iso registered_country iso_code;
    #   $geoip2_data_rcountry_name registered_country names en;
    #   $geoip2_data_rcountry_is_eu registered_country is_in_european_union;
    #   $geoip2_data_region_geonameid subdivisions 0 geoname_id;
    #   $geoip2_data_region_iso subdivisions 0 iso_code;
    #   $geoip2_data_region_name subdivisions 0 names en;
   #}

#=================Basic Compression=================#
    gzip on;
    gzip_disable "msie6";
    gzip_vary on;
    gzip_proxied any;
    gzip_comp_level 6;
    gzip_buffers 16 8k;
    gzip_http_version 1.1;
    gzip_types text/css text/xml text/plain application/javascript image/jpeg image/png image/gif image/x-icon image/svg+xml image/webp application/font-woff application/json application/vnd.ms-fontobject application/vnd.ms-powerpoint;
    gzip_static on;

    include /etc/nginx/sites-enabled/example.com-https.conf;
}

Maintenant, configurons l'hôte virtuel avec cette configuration SSL et proxy_protocol activée à /etc/nginx/sites-available/example.com-https.conf :

server {
    real_ip_header proxy_protocol;
    set_real_ip_from 192.168.1.1; #proxy server ip address
    #set_real_ip_from proxy; #proxy container hostname if you are using docker
    server_name 192.168.1.4; #Your current server ip address. It will redirect to the domain name.
    listen 80;
    listen 443 ssl http2;
    listen [::]:80;
    listen [::]:443 ssl http2;
    ssl_certificate     /etc/nginx/certs/example.com.crt;
    ssl_certificate_key /etc/nginx/certs/example.com.key;
    ssl_dhparam /etc/nginx/ssl/dhparam.pem;
    return 301 https://example.com$request_uri;
}
server {
    real_ip_header proxy_protocol;
    set_real_ip_from 192.168.1.1; #proxy server ip address
    #set_real_ip_from proxy; #proxy container hostname if you are using docker
    server_name  example.com;
    listen       *:80;
    return 301   https://example.com$request_uri;
}
server {
    real_ip_header proxy_protocol;
    set_real_ip_from 192.168.1.1; #proxy server ip address
    #set_real_ip_from proxy; #proxy container hostname if you are using docker
    server_name www.example.com;
    listen 80;
    listen 443 http2;
    listen [::]:80;
    listen [::]:443 ssl http2 ;
    ssl_certificate     /etc/nginx/certs/example.com.crt;
    ssl_certificate_key /etc/nginx/certs/example.com.key;
    ssl_dhparam /etc/nginx/ssl/dhparam.pem;
    return 301 https://example.com$request_uri;
}
server {
    real_ip_header proxy_protocol;
    set_real_ip_from 192.168.1.1; #proxy server ip address
    #set_real_ip_from proxy; #proxy container hostname if you are using docker
    server_name example.com;
    listen 443 proxy_protocol ssl http2;
    listen [::]:443 proxy_protocol ssl http2;
    root /var/www/html;
    charset UTF-8;
    add_header Strict-Transport-Security 'max-age=31536000; includeSubDomains; preload';
    add_header X-Frame-Options SAMEORIGIN;
    add_header X-Content-Type-Options nosniff;
    add_header X-XSS-Protection "1; mode=block";
    add_header Referrer-Policy no-referrer;
    ssl_prefer_server_ciphers on;
    ssl_ciphers "EECDH+AESGCM:EDH+AESGCM:AES256+EECDH:AES256+EDH";
    ssl_protocols TLSv1.2 TLSv1.1 TLSv1;
    ssl_session_cache   shared:SSL:10m;
    ssl_session_timeout 10m;
    keepalive_timeout   70;
    ssl_buffer_size 1400;
    ssl_dhparam /etc/nginx/ssl/dhparam.pem;
    ssl_stapling on;
    ssl_stapling_verify on;
    resolver 8.8.8.8 8.8.4.4 valid=86400;
    resolver_timeout 10;
    ssl_certificate     /etc/nginx/certs/example.com.crt;
    ssl_certificate_key /etc/nginx/certs/example.com.key;
    ssl_trusted_certificate /etc/nginx/certs/example.com.crt;
location ~* \.(jpg|jpe?g|gif|png|ico|cur|gz|svgz|mp4|ogg|ogv|webm|htc|css|js|otf|eot|svg|ttf|woff|woff2)(\?ver=[0-9.]+)?$ {
    expires modified 1M;
    add_header Access-Control-Allow-Origin '*';
    add_header Pragma public;
    add_header Cache-Control "public, must-revalidate, proxy-revalidate";
    access_log off;
    }
    location ~ /.well-known { #For issuing LetsEncrypt Certificates
        allow all;
    }
location / {
    index index.php;
    try_files $uri $uri/ /index.php?$args;
    }
error_page  404    /404.php;

location ~ \.php$ {
    try_files       $uri =404;
    fastcgi_index   index.php;
    fastcgi_pass    unix:/tmp/php7-fpm.sock;
    #fastcgi_pass    php-container-hostname:9000; (if using docker)
    fastcgi_pass_request_headers on;
    fastcgi_split_path_info ^(.+\.php)(/.+)$;
    fastcgi_param   SCRIPT_FILENAME  $document_root$fastcgi_script_name;
    fastcgi_intercept_errors on;
    fastcgi_ignore_client_abort off;
    fastcgi_connect_timeout 60;
    fastcgi_send_timeout 180;
    fastcgi_read_timeout 180;
    fastcgi_request_buffering on;
    fastcgi_buffer_size 128k;
    fastcgi_buffers 4 256k;
    fastcgi_busy_buffers_size 256k;
    fastcgi_temp_file_write_size 256k;
    include fastcgi_params;
}
location = /robots.txt {
    access_log off;
    log_not_found off;
    }
location ~ /\. {
    deny  all;
    access_log off;
    log_not_found off;
    }
}

Et enfin, un échantillon de 2 serveurs web nodejs : Premier serveur:

var http = require('http');

http.createServer(function (req, res) {
    res.writeHead(200, {'Content-Type': 'text/plain'});
    res.end('Hello From Nodejs\n');
}).listen(8080, "192.168.1.4");
console.log('Server running at http://192.168.1.4:8080/');

Deuxième serveur:

var http = require('http');

http.createServer(function (req, res) {
    res.writeHead(200, {'Content-Type': 'text/plain'});
    res.end('Hello From Nodejs\n');
}).listen(8080, "192.168.1.5");
console.log('Server running at http://192.168.1.5:8080/');

Maintenant, tout devrait fonctionner parfaitement et équilibrer la charge.

Il y a quelque temps, j'ai écrit sur la façon de configurer Nginx comme équilibreur de charge TCP dans Docker . Vérifiez-le si vous utilisez Docker.