it-swarm.com.de

Node.js + Nginx - Was jetzt?

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

  1. Wie sollen sie zusammenarbeiten? Wie soll ich mit den Anfragen umgehen?
  2. Es gibt zwei Konzepte für einen Node.js-Server, eines davon ist besser:

    ein. Erstellen Sie einen separaten HTTP-Server für jede Website, die diesen benötigt. Laden Sie dann den gesamten JavaScript-Code zu Beginn des Programms, damit der Code einmal interpretiert wird.

    b. Erstellen Sie einen einzelnen Node.js-Server, der alle Node.js-Anforderungen verarbeitet. Dies liest die angeforderten Dateien und wertet deren Inhalt aus. Die Dateien werden also bei jeder Anforderung interpretiert, aber die Serverlogik ist viel einfacher.

Mir ist nicht klar, wie ich Node.js richtig verwenden soll.

941
Van Coding

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

Das habe ich in meiner Ubuntu-Box gemacht:

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

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

Darin solltest du etwas haben 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.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;
    }
 }

Wenn nginx (> = 1.3.13) auch Websocket-Anforderungen verarbeiten soll, fügen Sie die folgenden Zeilen im Abschnitt location / hinzu:

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

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

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

Erstellen Sie Ihre Knotenserver-App unter /var/www/yourdomain/app.js und führen Sie sie unter localhost:3000 aus.

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

Test auf Syntaxfehler:

nginx -t

Nginx neu starten:

Sudo /etc/init.d/nginx restart

Starten Sie zuletzt den Knotenserver:

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

Jetzt sollte auf yourdomain.com "Hello World" angezeigt werden

Ein letzter Hinweis zum Starten des Knotenservers: Sie sollten eine Art Überwachungssystem für den Knotendämon verwenden. Es gibt ein tolles Tutorial auf Node mit Upstart und Monit .

1251
Joao Da Silva

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

Zum Beispiel, um diese zu erreichen:

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

In/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/;
    }
}
157
250R

Sie können auch unterschiedliche URLs für Apps in einer Serverkonfiguration haben:

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

Nginx neu starten:

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

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

Ich proxyunabhängige Node Express-Anwendungen über Nginx.

So können neue Anwendungen einfach gemountet werden und ich kann auch andere Dinge auf demselben Server an verschiedenen Orten ausführen.

Hier sind weitere Details zu meinem Setup mit Nginx-Konfigurationsbeispiel:

Bereitstellen mehrerer Node -Anwendungen auf einem Webserver in Unterordnern mit Nginx

Mit Node wird es schwierig, Ihre Anwendung von localhost in das Internet zu verschieben.

Es gibt keinen gemeinsamen Ansatz für die Bereitstellung von Node.

Google kann Unmengen von Artikeln zu diesem Thema finden, aber ich hatte Mühe, die richtige Lösung für das von mir benötigte Setup zu finden.

Grundsätzlich habe ich einen Webserver und möchte, dass Node Anwendungen in Unterordnern bereitgestellt werden (z. B. http: // myhost/demo/pet-project / ), ohne dass eine Konfigurationsabhängigkeit besteht zum Anwendungscode.

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

Klingt einfach, oder? Scheinbar nicht.

In vielen Beispielen im Web werden Node Anwendungen entweder auf Port 80 ausgeführt oder von Nginx an das Stammverzeichnis weitergeleitet.

Obwohl beide Ansätze für bestimmte Anwendungsfälle gültig sind, erfüllen sie nicht meine einfachen, aber ein bisschen 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 feststellen, dass ich meine Pet Project Node -Anwendung, die auf Port 3000 ausgeführt wird, an http: // myhost/demo/pet-project anhänge.

Zuerst prüft Nginx, ob es sich bei der angeforderten Ressource um eine statische Datei handelt, die unter /opt/demo/pet-project/public/ verfügbar ist. Wir brauchen also keine redundante Schicht wie die statische Connect-Middleware.

Dann werden alle anderen Anforderungen überschrieben und an die Anwendung Pet Project Node weitergeleitet, sodass die Anwendung Node nicht wissen muss, wo sie tatsächlich eingehängt ist und sich somit befinden kann irgendwo rein durch Konfiguration verschoben.

proxy_redirect ist ein Muss, um den Location-Header richtig zu behandeln. Dies ist äußerst wichtig, wenn Sie res.redirect () in Ihrer Node -Anwendung verwenden.

Sie können dieses Setup problemlos für mehrere Node Anwendungen replizieren, die an verschiedenen Ports ausgeführt werden, und weitere Standort-Handler für andere Zwecke hinzufügen.

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

31
skovalyov

Node.js mit Nginx-Konfiguration.

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

fügen Sie die folgende Konfiguration hinzu, damit Nginx als Proxy-Umleitung zum Port 3000-Verkehr vom Server fungiert, wenn wir von "subdomain.Ihre_Domäne.com" kommen.

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

beantwortung Ihrer Frage 2:

Ich würde die Option b verwenden, nur weil sie viel weniger Ressourcen verbraucht. mit der Option 'a' verbraucht jeder Client viel Speicher und lädt alle benötigten Dateien (auch wenn ich PHP mag, ist dies eines der Probleme damit). Mit der Option 'b' können Sie Ihre Bibliotheken laden (wiederverwendbarer Code) und sie für alle Clientanforderungen freigeben.

Aber seien Sie vorsichtig, wenn Sie mehrere Kerne haben, sollten Sie node.js optimieren, um alle zu verwenden.

8
Hugo Mota

Ich habe ein Repository in Github erstellt, das Sie klonen können, vagrant-node-nginx-boilerplate

grundsätzlich ist die node.js App bei /var/www/nodeapp

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

und die nginx config bei /etc/nginx/sites-available/ ist

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

Sie können auch node.js verwenden, um statische Dateien in einem von nginx bereitgestellten Verzeichnis zu generieren. Natürlich können einige dynamische Teile Ihrer Site von Node und andere von Nginx (statisch) bedient werden.

Einige von ihnen von Nginx serviert zu bekommen, steigert Ihre Leistung.

5
code ninja

Wir können ganz einfach eine Nodejs-App einrichten, indem Nginx als Reverse-Proxy fungiert.
In der folgenden Konfiguration wird davon ausgegangen, dass die NodeJS-Anwendung unter 127.0.0.1:8080 ausgeführt wird.

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

im obigen Setup wird Ihre Nodejs App,

  • get HTTP_Host header, in dem Sie domänenspezifische Logik anwenden können, um die Antwort zu liefern. '
  • Ihre Anwendung muss von einem Prozessmanager wie pm2 oder einem Supervisor für die Behandlung von Situationen/die Wiederverwendung von Sockets oder Ressourcen usw. verwaltet werden.

  • Richten Sie einen Fehlerberichtsdienst ein, um Produktionsfehler wie Wachposten oder Rollbalken zu erhalten

HINWEIS: Sie können eine Logik für die Übergabe domänenspezifischer Anforderungsrouten einrichten und eine Middleware für die Expressanwendung erstellen

5
I Am Batman

Nginx kann als Reverse-Proxy-Server fungieren, der genau wie ein Projektmanager funktioniert. Wenn es eine Anfrage erhält, analysiert es diese und leitet die Anfrage an Upstream-Mitglieder (Projektmitglieder) weiter oder bearbeitet sich selbst. Nginx kann eine Anfrage auf zwei Arten verarbeiten, je nachdem, wie sie konfiguriert ist.

  • die Anfrage bedienen
  • leiten Sie die Anfrage an einen anderen Server weiter

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

    }

Server die Anfrage

Wenn bei dieser Konfiguration die Anforderungs-URL mydomain.com/static/myjs.js lautet, wird die myjs.js -Datei im /my/static/files/path -Ordner zurückgegeben. Wenn Sie nginx so konfigurieren, dass statische Dateien bereitgestellt werden, wird die Anforderung selbst verarbeitet.

leitet die Anfrage an einen anderen Server weiter

Wenn die Anfrage-URL mydomain.com/dothis lautet, leitet nginx die Anfrage an http://127.0.0.1:80 weiter. Der Dienst, der auf dem localhost 8000-Port ausgeführt wird, empfängt die Anforderung und gibt die Antwort an nginx und nginx die Antwort an den Client zurück.

Wenn Sie den Server node.js auf dem Port 8000 ausführen, leitet nginx die Anforderung an node.js weiter. Schreiben Sie die node.js-Logik und bearbeiten Sie die Anforderung. Das ist es, was du hast, wenn dein NodeJS-Server hinter dem Nginx-Server läuft.

Wenn Sie andere Dienste als nodejs ausführen möchten, führen Sie einfach einen anderen Dienst wie Django, flask, php auf verschiedenen Ports aus und konfigurieren Sie ihn in nginx.

3

Sie können nodejs mit pm2 ausführen, wenn Sie jedes Microservice-Mittel verwalten und ausführen möchten. Node wird in einem Port ausgeführt. Konfigurieren Sie einfach diesen Port in 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;
    }
}

Überprüfen Sie mithilfe von Ping, ob localhost ausgeführt wird.

Und

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.

Das ist am besten und wie du sagtest auch einfacher

1
gokul kandasamy