Node.js + Nginx - Was nun?

Question

Ich habe Node.js und Nginx auf meinem Server eingerichtet. Jetzt möchte ich es verwenden, aber, bevor ich anfange, gibt es 2 Fragen:

1. Wie sollten sie zusammenarbeiten? Wie soll ich mit den Anfragen umgehen?

2. Es gibt 2 Konzepte für einen Node.js-Server, welches ist besser:

   a. Erstellen Sie einen separaten HTTP-Server für jede Website, die ihn benötigt. Laden Sie dann den gesamten JavaScript-Code am Anfang des Programms, so dass der Code einmal interpretiert wird.

   b. Erstellen Sie einen einzigen Node.js-Server, der alle Node.js-Anfragen bearbeitet. Dieser liest die angeforderten Dateien und wertet deren Inhalt aus. Die Dateien werden also bei jeder Anfrage interpretiert, aber die Serverlogik ist viel einfacher.

Es ist mir nicht klar, wie man Node.js richtig einsetzt.

Answer 1

Nginx arbeitet als Front-End-Server, der in diesem Fall die Anfragen an einen node.js-Server weiterleitet. Daher müssen Sie eine Nginx-Konfigurationsdatei für Node einrichten.

So habe ich es in meinem Ubuntu-System gemacht:

Erstellen Sie die Datei yourdomain.example unter /etc/nginx/sites-available/ :

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

Darin sollte etwas stehen wie:

# 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.example www.yourdomain.example;
    access_log /var/log/nginx/yourdomain.example.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;
    }
 }

Wenn Sie möchten, dass Nginx (>= 1.3.13) auch Websocket-Anfragen bearbeitet, fügen Sie die folgenden Zeilen in der Datei location / Abschnitt:

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

Sobald Sie dies eingerichtet haben, müssen Sie die in der obigen Konfigurationsdatei definierte Site aktivieren:

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

Erstellen Sie Ihre Node-Server-App unter /var/www/yourdomain/app.js und führen Sie es unter 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/');

Prüfung auf Syntaxfehler:

nginx -t

Starten Sie Nginx neu:

sudo /etc/init.d/nginx restart

Starten Sie abschließend den Node-Server:

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

Jetzt sollten Sie "Hello World" unter yourdomain.example

Ein letzter Hinweis zum Starten des Node-Servers: Sie sollten eine Art Überwachungssystem für den Node-Daemon verwenden. Es gibt ein großartiges Tutorial zu Node mit Upstart und Monit .

Answer 2

Sie können auch mehrere Domänen mit Nginx einrichten und an mehrere node.js-Prozesse weiterleiten.

Zum Beispiel, um diese zu erreichen:

• domain1.example -> zum lokal laufenden Node.js-Prozess http://127.0.0.1:4000
• domain2.example -> zum lokal laufenden Node.js-Prozess http://127.0.0.1:5000

Diese Ports (4000 und 5000) sollten verwendet werden, um die App-Anfragen in Ihrem App-Code abzuhören.

/etc/nginx/sites-enabled/domain1

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

In /etc/nginx/sites-enabled/domain2

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

Answer 3

Sie können auch verschiedene URLs für Anwendungen in einer Serverkonfiguration haben:

• yourdomain.example/app1/* -> zum lokal laufenden Node.js-Prozess http://127.0.0.1:3000
• yourdomain.example/app2/* -> zum Node.js-Prozess der lokal läuft http://127.0.0.1:4000

En /etc/nginx/sites-enabled/ihredomäne :

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

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

Starten Sie Nginx neu:

sudo service nginx restart

Anwendungen starten.

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

Answer 4

Ich stelle unabhängige Node Express-Anwendungen über Nginx bereit.

So lassen sich neue Anwendungen einfach einbinden, und ich kann auch andere Anwendungen auf demselben Server an verschiedenen Standorten ausführen.

Hier finden Sie weitere Details zu meinem Setup mit Nginx-Konfigurationsbeispiel:

Mehrere Node-Anwendungen auf einem Webserver in Unterordnern mit Nginx bereitstellen

Schwierig wird es mit Node, wenn Sie Ihre Anwendung vom lokalen Rechner ins Internet verlagern müssen.

Es gibt kein einheitliches Konzept für den Einsatz von Nodes.

Google kann tonnenweise Artikel zu diesem Thema finden, aber ich hatte Mühe, die richtige Lösung für die Einrichtung zu finden, die ich brauche.

Grundsätzlich habe ich einen Webserver und möchte, dass Node-Anwendungen in Unterordnern gemountet werden (d.h. http://myhost/demo/pet-project/ ), ohne eine Konfigurationsabhängigkeit in den Anwendungscode einzuführen.

Gleichzeitig möchte ich, dass andere Dinge wie der Blog auf demselben Webserver laufen.

Klingt einfach, oder? Offensichtlich nicht.

In vielen Beispielen im Web laufen Node-Anwendungen entweder auf Port 80 oder werden von Nginx an den Root weitergeleitet.

Obwohl beide Ansätze für bestimmte Anwendungsfälle geeignet sind, erfüllen sie nicht meine einfachen, aber doch ein wenig exotischen Kriterien.

Deshalb habe ich meine eigene Nginx-Konfiguration erstellt und hier ist ein Auszug:

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

In diesem Beispiel können Sie sehen, dass ich meine Pet Project Node-Anwendung, die auf Port 3000 läuft, in http://myhost/demo/pet-project .

Zunächst prüft Nginx, ob die angeforderte Ressource eine statische Datei ist, die unter /opt/demo/pet-project/public/ und wenn dies der Fall ist, wird es so serviert, wie es ist, was sehr effizient ist, so dass wir keine redundante Schicht wie die statische Middleware von Connect benötigen.

Dann werden alle anderen Anfragen überschrieben und an Haustier-Projektknoten Anwendung, so dass die Node-Anwendung nicht wissen muss, wo sie tatsächlich eingehängt ist, und daher allein durch die Konfiguration überall hin verschoben werden kann.

proxy_redirect ist ein Muss, um Location Header richtig zu behandeln. Dies ist besonders wichtig, wenn Sie res.redirect() in Ihrer Node-Anwendung.

Sie können dieses Setup für mehrere Node-Anwendungen, die auf verschiedenen Ports laufen, einfach replizieren und weitere Location Handler für andere Zwecke hinzufügen.

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

Answer 5

Node.js mit Nginx-Konfiguration.

$ sudo nano /etc/nginx/sites-available/subdomain.your-domain.example

fügen Sie die folgende Konfiguration hinzu, damit Nginx als Proxy den Verkehr vom Server auf Port 3000 umleitet, wenn wir von subdomain.your_domain.example

upstream subdomain.your-domain.example {
  server 127.0.0.1:3000;
}
server {
  listen 80;
  listen [::]:80;
  server_name subdomain.your-domain.example;
  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.example;
    proxy_redirect off;
  }
}