Node.js + Nginx - ¿Y ahora qué?

1076

Configuré Node.js y Nginx en mi servidor. Ahora quiero usarlo, pero, antes de comenzar, hay 2 preguntas:

  1. ¿Cómo deberían trabajar juntos? ¿Cómo debo manejar las solicitudes?
  2. Hay 2 conceptos para un servidor Node.js, cuál es mejor:

    una. Cree un servidor HTTP independiente para cada sitio web que lo necesite. Luego, cargue todo el código JavaScript al inicio del programa, para que el código se interprete una vez.

    B. Cree un único servidor Node.js que maneje todas las solicitudes de Node.js. Esto lee los archivos solicitados y evalúa su contenido. Entonces, los archivos se interpretan en cada solicitud, pero la lógica del servidor es mucho más simple.

No tengo claro cómo usar Node.js correctamente.

0
1377

Nginx funciona como un servidor front-end, que en este caso envía las solicitudes a un servidor node.js. Por lo tanto, debe configurar un archivo de configuración nginx para node.

Esto es lo que hice en mi caja de Ubuntu:

Cree el archivo yourdomain.comen /etc/nginx/sites-available/:

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

En él deberías tener algo como:

# 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 desea que nginx (> = 1.3.13) también maneje las solicitudes de websocket, agregue las siguientes líneas en la location /sección:

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

Una vez que tenga esta configuración, debe habilitar el sitio definido en el archivo de configuración anterior:

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

Cree su aplicación de servidor de nodo en /var/www/yourdomain/app.jsy ejecútela enlocalhost: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/');

Prueba de errores de sintaxis:

nginx -t

Reinicie nginx:

sudo /etc/init.d/nginx restart

Por último, inicie el servidor de nodo:

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

Ahora debería ver "Hola mundo" en tudominio.com

Una última nota con respecto al inicio del servidor de nodos: debe usar algún tipo de sistema de monitoreo para el demonio de nodos. Hay un tutorial impresionante sobre el nodo con advenedizo y monit .

21
  • 11
    Gracias por la publicación, nginx almacenará en caché las respuestas de node.js para el servidor anterior o las volverá a ejecutar cada vez.
    Lime
    19/07/11 a las 19:31
  • 84
    ¿Hay alguna razón por la que no puedas simplemente hacer location / { proxy_pass http://127.0.0.1:3000; }? ¿Por qué necesitas todo el upstreambit de configuración? 20/11/11 a las 23:59
  • 22
    +1, respuesta muy directa y sencilla a una pregunta común; ideal para personas que desean configurar hosts virtuales utilizando node y nginx. Lo único que creo que se perdió es una respuesta cualitativa a por qué nginx-in-front-of-node es mejor para servir múltiples vhosts (segunda pregunta del autor de la pregunta). 6/03/12 a las 17:52
  • 38
    @Robin Winslow en caso de que desee agregar más servidores para servidores para el equilibrio de carga. 16 de agosto de 2012 a las 10:53
  • 82
    Cabe señalar que esta respuesta (muy útil) se refiere a un tipo de nginx que, de forma predeterminada, viene con directorios sites-enabledy sites-availabledentro /etc/nginx. Si su versión vino sin estos dos directorios, es probable que tenga un solo conf.ddirectorio en su lugar. En ese caso, seguir estas instrucciones no tendrá ningún efecto, A MENOS QUE modifique la includeinstrucción dentro del archivo nginx.confpara apuntar en sites-enabledlugar de la predeterminada conf.d. Espero que tenga sentido. Debería explicarse por sí mismo una vez que vea dicha includedeclaración en el interior nginx.conf. 18/10/12 a las 11:35
177

También puede configurar múltiples dominios con nginx, reenviando a múltiples procesos node.js.

Por ejemplo, para lograr estos:

Estos puertos (4000 y 5000) deben usarse para escuchar las solicitudes de la aplicación en el código de su aplicación.

/ 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/;
    }
}

En / 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/;
    }
}
4
  • 5
    Estoy utilizando el método de PROXY_PASS, pero por alguna razón http://example.comobtiene automáticamente 302'd a http://www.example.com. ¿Porqué es eso? 13 de noviembre de 2015 a las 8:00
  • ¿Tienes Cloudflare o algo similar? La configuración anterior no debería redirigir en absoluto. 18/06/18 a las 21:46
  • 1
    @Kristian Deberá agregar proxy_set_header Host $hostpara evitar la redirección HTTP 302. 30 nov 2018 a las 21:01
  • @IvanShatsky - ¿Puede proporcionar alguna ayuda sobre cómo configurar varios puertos con varios subdominios y evitar que otros puertos se ejecuten en otro dominio? Nginx v 1.14.1
    151291
    1/04/19 a las 10:49
65

También puede tener diferentes URL para aplicaciones en una configuración de servidor:

En / 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/;
    }
}

Reinicie nginx:

sudo service nginx restart

Iniciar aplicaciones.

nodo 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/');

nodo 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/');
5
  • 3
    La versión de la comunidad de código abierto es gratuita, pero tienen una versión con otras características que no son gratuitas. nginx.com/products/feature-matrix 7 de septiembre de 2016 a las 19:34
  • Perdón por mi ignorancia. ¿Cuál es el propósito, los beneficios de servirlo de esta manera? ¿tienes algún ejemplo o caso de uso? Gracias por adelantado. 29/06/17 a las 21:28
  • 2
    @MauroAguilar Si necesita la aplicación 2 node.js en un servidor, puede servirlos usando la forma sugerida (usando diferentes puertos). En mis casos fueron dos aplicaciones de prueba diferentes. 29/06/2017 a las 21:34
  • Ok, pero ¿cuál es la diferencia entre ejecutar 2 aplicaciones y una sola? Quiero decir, ¿cuáles son los beneficios si estuvieran destinados al mismo propósito? 29/06/2017 a las 21:50
  • 2
    @MauroAguilar, puedes ejecutarlos en uno solo y no hay beneficio si puede ser parte de un proyecto y tiene el mismo propósito. Pero si necesita ejecutar 2 proyectos diferentes con diferentes propósitos y con diferentes configuraciones en un servidor, entonces tiene la ventaja de usar esta configuración. 29/06/2017 a las 21:54
35

Aprovecho aplicaciones independientes de Node Express a través de Nginx.

Por lo tanto, las nuevas aplicaciones se pueden montar fácilmente y también puedo ejecutar otras cosas en el mismo servidor en diferentes ubicaciones.

Aquí hay más detalles sobre mi configuración con el ejemplo de configuración de Nginx:

Deploy multiple Node applications on one web server in subfolders with Nginx

Things get tricky with Node when you need to move your application from from localhost to the internet.

There is no common approach for Node deployment.

Google can find tons of articles on this topic, but I was struggling to find the proper solution for the setup I need.

Basically, I have a web server and I want Node applications to be mounted to subfolders (i.e. http://myhost/demo/pet-project/) without introducing any configuration dependency to the application code.

At the same time I want other stuff like blog to run on the same web server.

Sounds simple huh? Apparently not.

In many examples on the web Node applications either run on port 80 or proxied by Nginx to the root.

Even though both approaches are valid for certain use cases, they do not meet my simple yet a little bit exotic criteria.

That is why I created my own Nginx configuration and here is an extract:

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/;
  }
}

From this example you can notice that I mount my Pet Project Node application running on port 3000 to http://myhost/demo/pet-project.

First Nginx checks if whether the requested resource is a static file available at /opt/demo/pet-project/public/ and if so it serves it as is that is highly efficient, so we do not need to have a redundant layer like Connect static middleware.

Then all other requests are overwritten and proxied to Pet Project Node application, so the Node application does not need to know where it is actually mounted and thus can be moved anywhere purely by configuration.

proxy_redirect is a must to handle Location header properly. This is extremely important if you use res.redirect() in your Node application.

You can easily replicate this setup for multiple Node applications running on different ports and add more location handlers for other purposes.

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

2
  • 1
    Por qué y cómo debería hacerlo en subdominios: skovalyov.blogspot.dk/2012/10/… 23/10/12 a las 9:57
  • Enlace solo respuesta ... ¿puede resumir las partes relevantes en su respuesta en caso de que su blog se haya ido?
    kaiser
    14 de marzo de 2016 a las 14:59
13

Node.js con configuración de Nginx.

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

agregue la siguiente configuración para que Nginx actúe como un proxy redirigir al tráfico del puerto 3000 desde el servidor cuando venimos de "subdominio.su_dominio.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;
  }
}
9

respondiendo a su pregunta 2:

Usaría la opción bsimplemente porque consume muchos menos recursos. con la opción 'a', cada cliente hará que el servidor consuma mucha memoria, cargando todos los archivos que necesitas (aunque me gusta php, este es uno de los problemas que tiene). Con la opción 'b' puede cargar sus bibliotecas (código reutilizable) y compartirlas entre todas las solicitudes de los clientes.

Pero tenga en cuenta que si tiene varios núcleos, debe modificar node.js para usarlos todos.

1
  • 2
    Siga este consejo si los recursos son su problema más importante (poco probable). Hay diferentes compromisos entre (a) y (b). La opción (a) es probablemente mejor si desea que los sitios sean más independientes, por ejemplo, reinicio o mantenimiento del sitio, conexiones de base de datos, base de código, dependencias de bibliotecas, movimiento de sitios entre servidores, etc.
    robocat
    8 de febrero de 2016 a las 0:56
9

Hice un repositorio en Github que puedes clonar, vagrant-node-nginx-boilerplate

Básicamente, la aplicación node.js en /var/www/nodeappes

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/');

y la configuración de nginx en /etc/nginx/sites-available/es

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;
        }
}
6

También puede usar node.js para generar archivos estáticos en un directorio servido por nginx. Por supuesto, algunas partes dinámicas de su sitio podrían ser atendidas por nodo y otras por nginx (estático).

Tener algunos de ellos servidos por nginx aumenta su rendimiento.

5

Podemos configurar fácilmente una aplicación Nodejs mediante Nginx que actúa como un proxy inverso.
La siguiente configuración asume que la aplicación NodeJS se está ejecutando en 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
     }
   } 

en la configuración anterior, su aplicación Nodejs lo hará,

  • obtener el HTTP_HOSTencabezado donde puede aplicar la lógica específica del dominio para entregar la respuesta. '
  • Su aplicación debe ser administrada por un administrador de procesos como pm2 o supervisor para manejar situaciones / reutilizar sockets o recursos, etc.

  • Configure un servicio de informes de errores para obtener errores de producción como centinela o barra antivuelco

NOTA: puede configurar la lógica para administrar rutas de solicitud específicas del dominio, crear un middleware para la aplicación expressjs

1
  • 1
    Otra razón para usar pm2 es para que pueda ejecutar su aplicación 'para siempre' después de salir del shell e iniciarla automáticamente si alguna vez necesita reiniciar su servidor, consulte: pm2.keymetrics.io/docs/usage/startup 14 dic 2018 a las 0:04
4

Nginx puede actuar como un servidor proxy inverso que funciona como un administrador de proyectos. Cuando recibe una solicitud, la analiza y reenvía la solicitud a aguas arriba (miembros del proyecto) o se maneja a sí mismo. Nginx tiene dos formas de manejar una solicitud en función de cómo esté configurada.

  • atender la solicitud
  • reenviar la solicitud a otro servidor

    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;
     }
    

    }

Servidor de la solicitud

With this configuration, when the request url is mydomain.com/static/myjs.js it returns the myjs.js file in /my/static/files/path folder. When you configure nginx to serve static files, it handles the request itself.

reenviar la solicitud a otro servidor

When the request url is mydomain.com/dothis nginx will forwards the request to http://127.0.0.1:8000. The service which is running on the localhost 8000 port will receive the request and returns the response to nginx and nginx returns the response to the client.

Cuando ejecuta el servidor node.js en el puerto 8000, nginx reenviará la solicitud a node.js. Escriba la lógica de node.js y maneje la solicitud. Eso es todo, tiene su servidor nodejs ejecutándose detrás del servidor nginx.

Si desea ejecutar cualquier otro servicio que no sea nodejs, simplemente ejecute otro servicio como Django, flask, php en diferentes puertos y configúrelo en nginx.

2

La configuración mejor y más simple con Nginx y Nodejs es usar Nginx como un balanceador de carga HTTP y TCP con proxy_protocol habilitado. En este contexto, Nginx podrá enviar por proxy las solicitudes entrantes a nodejs, y también finalizar las conexiones SSL al servidor (es) backend de Nginx, y no al servidor proxy en sí. (SSL-PassThrough)

En mi opinión, no tiene sentido dar ejemplos que no sean SSL, ya que todas las aplicaciones web utilizan (o deberían hacerlo) entornos seguros.

Configuración de ejemplo para el servidor proxy, en /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;
}

Ahora, manejemos el servidor web backend. /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;
}

Ahora, configuremos el host virtual con esta configuración habilitada para SSL y proxy_protocol en /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;
    }
}

Y por último, una muestra de 2 servidores web nodejs : Primer servidor:

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/');

Segundo servidor:

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/');

Ahora todo debería estar funcionando perfectamente y con la carga equilibrada.

Hace un tiempo escribí sobre cómo configurar Nginx como un equilibrador de carga TCP en Docker . Compruébelo si está utilizando Docker.

1

Puede ejecutar nodejs usando pm2 si desea administrar cada medio de microservicio y ejecutarlo. El nodo se ejecutará en un puerto correctamente, solo configure ese puerto en 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;
    }
}

Compruebe si localhost se está ejecutando o no mediante el uso de ping.

Y

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.

Esto es lo mejor y como dijiste más fácil también