Węzeł.js + Nginx-co teraz?

Możesz również skonfigurować wiele domen za pomocą nginx, przekierowując do wielu węzłów.procesy js.

Na przykład, aby osiągnąć te:

• domain1.com - > do węzła.proces js działający lokalnie http://127.0.0.1:4000
• domain2.com - > do węzła.js process running local http://127.0.0.1:5000

/ to strona internetowa, na której można znaleźć wiele ciekawych informacji.]}

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

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

Możesz również mieć różne adresy URL dla aplikacji w jednej konfiguracji serwera:

• yourdomain.com/app1/* - > do węzła.proces js działający lokalnie http://127.0.0.1:3000
• yourdomain.com/app2/* - > do węzła.proces js uruchamianie lokalnie http://127.0.0.1:4000

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

Restart nginx:

sudo service nginx restart

Uruchamianie aplikacji.

Węzeł 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/');

[[1]}I proxy niezależnych aplikacji Node Express przez Nginx.

W ten sposób nowe aplikacje mogą być łatwo montowane i mogę również uruchamiać inne rzeczy na tym samym serwerze w różnych lokalizacjach.

Dzięki Nginx możesz korzystać z wielu aplikacji węzłowych na jednym serwerze WWW w podfolderach]}

Sprawy stają się trudne z Node, gdy musisz przenieść swoją aplikację z localhost do internet.

Nie ma wspólnego podejścia do wdrażania węzłów.

Google może znaleźć mnóstwo artykułów na ten temat, ale starałem się znaleźć odpowiednie rozwiązanie dla konfiguracji, której potrzebuję.

Zasadniczo mam serwer WWW i chcę, aby Aplikacje węzłów były montowane do podfolderów (np. http://myhost/demo/pet-project/) bez wprowadzania jakichkolwiek zależności konfiguracyjnych do kodu aplikacji.

W tym samym czasie chcę inne rzeczy, takie jak blog do uruchomienia na tym samym serwerze WWW.

Brzmi prosto, co? Najwyraźniej nie.

[1]}w wielu przykładach na węzłach sieci Web aplikacje uruchamiane na porcie 80 lub proxy przez Nginx do katalogu głównego.

Mimo że oba podejścia są ważne dla pewnych przypadków użycia, nie spełniają moich prostych, ale trochę egzotycznych kryteriów.

Dlatego stworzyłem własną konfigurację Nginx i oto wyciąg:

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

Z tego przykładu można zauważyć, że montuję mojego zwierzaka Aplikacja węzła projektu uruchomiona na porcie 3000 do http://myhost/demo/pet-project .

Najpierw Nginx sprawdza, czy żądany zasób jest plikiem statycznym dostępnym w /opt/demo/pet-project/public/, a jeśli tak, to służy mu tak, jak jest to wysoce wydajne, więc nie musimy mieć nadmiarowej warstwy, takiej jak Connect static middleware.

Następnie wszystkie inne żądania są nadpisywane i proxy do węzła projektu Pet aplikacji, więc węzeł aplikacja nie musi wiedzieć, gdzie jest faktycznie zamontowana, a więc może być przeniesiona w dowolne miejsce wyłącznie przez konfigurację.

proxy_redirect jest koniecznością do poprawnej obsługi nagłówka lokalizacji. Jest to niezwykle ważne, jeśli używasz res. redirect () w swojej aplikacji węzła.

Można łatwo replikować tę konfigurację dla wielu aplikacji węzłów działających na różnych portach i dodawać więcej funkcji obsługi lokalizacji do innych celów.

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

Węzeł.js z konfiguracją Nginx.

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

Dodaj następującą konfigurację, aby Nginx działający jako proxy przekierował ruch na port 3000 z serwera, gdy pochodzimy "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;
  }
}

ODPOWIEDŹ na twoje pytanie 2:

Użyłbym opcji b po prostu dlatego, że zużywa znacznie mniej zasobów. z opcją 'a', każdy klient spowoduje, że serwer pochłonie dużo pamięci, ładując wszystkie potrzebne pliki (mimo, że lubię php, jest to jeden z problemów z nim). Dzięki opcji ' b ' możesz załadować swoje biblioteki (kod wielokrotnego użytku) i udostępnić je wszystkim żądaniom klientów.

Ale być ware, że jeśli masz wiele rdzeni należy dostosować węzeł.js do wykorzystania wszystkich oni.

Możesz również użyć node.js do generowania plików statycznych do katalogu obsługiwanego przez nginx. Oczywiście niektóre dynamiczne części witryny mogą być obsługiwane przez węzeł, a niektóre przez nginx (statyczny).

Zrobiłem repozytorium w Githubie, które możesz sklonować, vagrant-node-nginx-boilerplate

W zasadzie węzeł.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/');

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

Możemy łatwo skonfigurować aplikację Nodejs, działając jako odwrotne proxy.
Następująca konfiguracja zakłada, że aplikacja NodeJS działa w wersji 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
     }
   } 

Powyżej skonfiguruj swoją aplikację Nodejs,

• Pobierz nagłówek HTTP_HOST, w którym możesz zastosować logikę specyficzną dla domeny, aby obsłużyć odpowiedź. '

• Aplikacja musi być zarządzana przez menedżera procesów, takiego jak pm2 lub przełożonego do obsługi sytuacji / ponownego wykorzystywania gniazd lub zasobów itd.

• Skonfiguruj usługę raportowania błędów w celu uzyskania błędów produkcyjnych, takich jak sentry lub rollbar

Uwaga: możesz skonfigurować logikę przekazywania tras żądań specyficznych dla domeny, utworzyć middleware dla aplikacji expressjs

Nginx może działać jako serwer odwrotnego proxy, który działa podobnie jak menedżer projektu. Kiedy otrzymuje żądanie, analizuje je i przekazuje żądanie do upstream (członków projektu) lub obsługuje się. Nginx ma dwa sposoby obsługi żądania w oparciu o jego konfigurację.

• obsłuż żądanie

• Prześlij żądanie na inny serwer

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

  }

Serwer żądanie

Z tą konfiguracją, gdy URL żądania na mydomain.com/static/myjs.js zwraca plik myjs.js w /my/static/files/path folder. Kiedy skonfigurujesz nginx do serwowania pliki statyczne sam obsługuje żądanie.

Przekazanie żądania do innego serwera

Nginx przekaże nam adres URL żądania, który zostanie przesłany do nas. wniosek do http://127.0.0.1:8000 . Serwis, który działa na port localhost 8000 otrzyma żądanie i zwróci odpowiedź do nginx i Nginx zwraca odpowiedź na klient.

Kiedy uruchamiasz node.serwer js na porcie 8000 nginx przekaże żądanie do węzła.js. Write node.js logic i obsłużyć żądanie. To jest to, że twój serwer nodejs działa za serwerem nginx.

Jeśli chcesz uruchomić inne usługi inne niż nodejs, po prostu uruchom inną usługę, taką jak Django, flask, php na różnych portach i skonfiguruj ją w nginx.

Możesz uruchomić nodejs używając pm2, jeśli chcesz zarządzać każdym środkiem mikroserwisu i go uruchomić. Node będzie działał w porcie po prostu skonfiguruj ten port w 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;
    }
}

Sprawdź, czy localhost jest uruchomiony, czy nie, używając ping.

I

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.

To jest najlepsze i jak powiedziałeś łatwiejsze zbyt