No.js + Nginx-e agora?

Você também pode configurar vários domínios com nginx, encaminhando para múltiplos nós.processos js.

Por exemplo para atingir estes objectivos:

• domain1.com - > para o nó.processo js a correr localmente http://127.0.0.1:4000
• domain2.com - > para o nó.processo js a correr localmente http://127.0.0.1:5000

/etc/nginx / sites-actived/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/;
    }
}

In/etc/nginx / sites-actived / 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/;
    }
}

Você também pode ter urls diferentes para aplicações em uma configuração de servidor:

• yourdomain.com/app1 / * - > para o nó.processo js a correr localmente http://127.0.0.1:3000
• yourdomain.com/app2 / * - > para o nó.processo js a correr localmente http://127.0.0.1:4000

Em / etc/nginx / sites-activos/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/;
    }
}

Reiniciar nginx:

sudo service nginx restart

Iniciando aplicações.

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

Eu proxy independente Node Express applications through Nginx.

Assim, novas aplicações podem ser facilmente montadas e eu também posso executar outras coisas no mesmo servidor em locais diferentes.

Aqui estão mais detalhes sobre a minha configuração com o exemplo de configuração da Nginx:

Implantar várias aplicações de nós num servidor web em subpastas com o Nginx

As coisas ficam complicadas com o nó quando você precisa mover a sua aplicação de localhost para o quarto.

Não existe uma abordagem comum para a implantação de nós.

O Google pode encontrar toneladas de artigos sobre este tópico, mas eu estava lutando para encontrar a solução adequada para a configuração que eu preciso.

Basicamente, tenho um servidor web e quero que as aplicações de nós sejam montadas em subpastas (isto é, http://myhost/demo/pet-project/) sem introduzir qualquer dependência de configuração no código da aplicação.

Ao mesmo tempo, quero outras coisas como blog para correr no mesmo servidor web. Parece simples, não é? Aparentemente não.

Em muitos exemplos nas aplicações de nós web, seja executado no porto 80 ou proxied por Nginx para o root.

Mesmo que ambas as abordagens sejam válidas para certos casos de uso, elas não satisfazem os meus critérios simples, mas um pouco exóticos.

Foi por isso que criei a minha própria configuração da Nginx e aqui está um 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/;
  }
}

A partir deste exemplo, podes reparar que monto o meu animal de estimação. Aplicação do nó do projecto a correr no Porto 3000 a http://myhost/demo/pet-project

Primeiro, o Nginx verifica se o recurso pedido é um ficheiro estático disponível em /opt/demo/pet-project/public/ e se serve como é altamente eficiente, por isso não precisamos de ter uma camada redundante como o Connect static middleware.

Então todos os outros pedidos são substituídos e proxied para pet Project Node , De modo que o nó a aplicação não precisa saber onde ela é realmente montada e, portanto, pode ser movida em qualquer lugar puramente pela configuração.

proxy_redirect é um must to handle Location header apropriadamente. Isto é extremamente importante se você usar res.redirect () na sua aplicação de nós.

Pode replicar facilmente esta configuração para várias aplicações de nós a correr em diferentes portos e adicionar mais manipuladores de localização para outros fins.

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

Nó.js com configuração Nginx.

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

Adicione a seguinte configuração para que o Nginx actue como um 'proxy' redireccione para o tráfego do porto 3000 a partir do servidor quando viermos de "subdomain.your_domain.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;
  }
}

Respondendo à tua pergunta 2:

Eu usaria a opção {[[0]} simplesmente porque consome muito menos recursos. com a opção 'a', cada cliente fará com que o servidor consuma muita memória, carregando todos os arquivos que você precisa (mesmo que eu goste de php, este é um dos problemas com ele). Com a opção ' b ' você pode carregar suas bibliotecas (código reutilizável) e compartilhá-las entre todos os pedidos do cliente.

Mas tenha cuidado para que, se tiver vários núcleos, deve ajustar o nó.js para utilizar todos os o.

Também podes usar o nó.js para gerar arquivos estáticos em um diretório servido por nginx. É claro, algumas partes dinâmicas de seu site pode ser servido por node, e alguns por nginx (estática).

Fiz um repositório no Github que podes clonar, Vagrant-node-nginx-boilerplate

Basicamente o nó.js app at /var/www/nodeapp is

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

E a configuração da nginx em /etc/nginx/sites-available/ é

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

Podemos facilmente configurar um aplicativo Nodejs por Nginx agindo como um proxy reverso.
A seguinte configuração assume que a aplicação NodeJS está em execução em 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
     }
   } 

Na configuração acima a sua aplicação Nodejs irá,

• obter o cabeçalho HTTP_HOST onde poderá aplicar a lógica específica do domínio para servir a resposta. '

• A sua aplicação deve ser gerida por um gestor de processos como pm2 ou supervisor para lidar com situações/reutilizar tomadas ou recursos etc.

• Configurar um serviço de comunicação de erros para obter erros de produção como Sentinela ou barra de rolagem

Nota: Pode configurar a lógica para passar as rotas de requisição específicas do domínio, criar um middlewarepara a aplicação expressjs

O Nginx pode actuar como um servidor proxy reverso que funciona como um gestor de projecto. Quando recebe um pedido, analisa-o e encaminha o pedido para o upstream(membros do projeto) ou trata de si mesmo. A Nginx tem duas maneiras de lidar com um pedido baseado na sua configuração.

• serve o pedido

• Encaminhe o pedido para outro 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 o pedido

Com esta configuração quando o o url do pedido é mydomain.com/static/myjs.js devolve o ficheiro myjs.js em /my/static/files/path pasta. Quando configurar o nginx a servir arquivos estáticos que lida com o pedido em si.

Encaminhar o pedido para outro servidor

Quando o url do pedido for mydomain.com/dothis, a nginx irá encaminhar o pedido a http://127.0.0.1:8000 . O serviço que está em funcionamento no localhost 8000 port receberá o pedido e devolve a resposta a nginx e a nginx devolve a resposta à cliente.

Quando se executa o nó.o servidor js na porta 8000 nginx irá encaminhar o pedido para o nó.js. Nó de escrita.js lógica e lidar com o pedido. É isso que você tem seu servidor nodejs funcionando atrás do servidor nginx.

Se desejar executar outros serviços para além dos nodejs, execute outro serviço como o Django, flask, php em portos diferentes e configá-lo em nginx.

Você pode executar nodejs usando pm2 se quiser gerir cada meio de microservice e executá-lo. O nó estará a correr num porto à direita. basta configurar esse porto no nginx (/etc/nginx/sites-actived / domain.com)

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

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

Verifique se o localhost está a correr ou não usando o ping.

E

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.