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




server nodejs (10)

He configurado 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:

    a. Cree un servidor HTTP separado 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.

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

No me queda claro cómo usar Node.js correctamente.


Answers

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

Esto es lo que he hecho en mi caja de Ubuntu:

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

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

En ella 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.js y ejecútelo en localhost: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 iniciar el servidor de nodo:

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

Ahora deberías ver "Hello World" en yourdomain.com

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


Node.js con la 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 redireccionamiento de proxy al tráfico del puerto 3000 desde el servidor cuando venimos de "subdominio.tu_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;
  }
}

respondiendo a tu pregunta 2:

Usaría la opción b simplemente porque consume muchos menos recursos. con la opción 'a', cada cliente hará que el servidor consuma mucha memoria, cargando todos los archivos que necesita (aunque me gusta php, este es uno de los problemas). 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 ajustar node.js para utilizarlos todos.


Puede ejecutar nodejs utilizando pm2 si desea administrar cada medio de microservicio y ejecutarlo. El nodo se ejecutará en un puerto a la derecha, simplemente 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 utilizando 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.


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

básicamente la aplicación node.js en /var/www/nodeapp es

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/ is

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

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

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

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 servidas por nodo y otras por nginx (estática).

Tener algunos de ellos servidos por nginx aumenta su rendimiento ...


Podemos configurar fácilmente una aplicación Nodejs por Nginx actuando 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 será,

  • obtenga el encabezado HTTP_HOST donde puede aplicar la lógica específica del dominio para servir 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 informe de errores para obtener errores de producción como sentry o rollbar

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


Yo proxy 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:

Implemente múltiples aplicaciones Node en un servidor web en subcarpetas con Nginx

Las cosas se complican con Node cuando necesita mover su aplicación de localhost a internet.

No hay un enfoque común para la implementación de nodos.

Google puede encontrar toneladas de artículos sobre este tema, pero me costaba encontrar la solución adecuada para la configuración que necesito.

Básicamente, tengo un servidor web y quiero que las aplicaciones de Node se monten en subcarpetas (es decir, http://myhost/demo/pet-project/ ) sin introducir ninguna dependencia de configuración en el código de la aplicación.

Al mismo tiempo, quiero que otras cosas como el blog se ejecuten en el mismo servidor web.

Suena simple eh? Aparentemente no.

En muchos ejemplos en la web, las aplicaciones de Nodo se ejecutan en el puerto 80 o se envían mediante proxy por Nginx a la raíz.

Aunque ambos enfoques son válidos para ciertos casos de uso, no cumplen con mi criterio simple pero un poco exótico.

Es por eso que creé mi propia configuración Nginx y aquí hay un extracto:

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

En este ejemplo, puede observar que instalo mi aplicación Pet Project Node en el puerto 3000 en http://myhost/demo/pet-project .

First Nginx verifica si el recurso solicitado es un archivo estático disponible en / opt / demo / pet-project / public / y, de ser así, es muy eficiente, por lo que no necesitamos tener una capa redundante como Connect middleware estático.

Luego, todas las demás solicitudes se sobrescriben y envían como proxy a la aplicación Pet Project Node , por lo que la aplicación Node no necesita saber dónde se monta realmente y, por lo tanto, se puede mover a cualquier lugar simplemente por configuración.

proxy_redirect es un deber para manejar el encabezado de la ubicación correctamente. Esto es extremadamente importante si usa res.redirect () en su aplicación Node.

Puede replicar fácilmente esta configuración para múltiples aplicaciones de Nodo que se ejecutan en diferentes puertos y agregar más manejadores de ubicación para otros propósitos.

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


Uso el siguiente código para iniciar un servidor web simple que renderiza el archivo html predeterminado si no se menciona ningún archivo en la URL

var http = require('http'),
fs = require('fs'),
url = require('url'),
rootFolder = '/views/',
defaultFileName = '/views/5 Tips on improving Programming Logic   Geek Files.htm';


http.createServer(function(req, res){

    var fileName = url.parse(req.url).pathname;
    // If no file name in Url, use default file name
    fileName = (fileName == "/") ? defaultFileName : rootFolder + fileName;

    fs.readFile(__dirname + decodeURIComponent(fileName), 'binary',function(err, content){
        if (content != null && content != '' ){
            res.writeHead(200,{'Content-Length':content.length});
            res.write(content);
        }
        res.end();
    });

}).listen(8800);

Mostrará todos los archivos js, css y de imagen, junto con todo el contenido html.

De acuerdo con la declaración " Ningún tipo de contenido es mejor que uno incorrecto "





node.js nginx concept