Frage Node.js + Nginx - Was nun?


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

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

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

    b. Erstellen Sie einen einzelnen Node.js-Server, der alle Node.js-Anforderungen verarbeitet. Dadurch werden die angeforderten Dateien gelesen und ihr Inhalt wird nachvollzogen. So werden die Dateien bei jeder Anfrage interpretiert, aber die Serverlogik ist viel einfacher.

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


856
2018-02-15 20:49


Ursprung


Antworten:


Nginx arbeitet 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 beim /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 Sie wollen, dass nginx (> = 1.3.13) auch WebSocket-Anfragen behandelt, fügen Sie die folgenden Zeilen in die location / Sektion:

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

Sobald Sie diese Einstellung 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 Node-Server-App unter /var/www/yourdomain/app.js und führe es an 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/');

Test auf Syntaxfehler:

nginx -t

Starten Sie nginx neu:

sudo /etc/init.d/nginx restart

Zuletzt starten Sie den Knoten Server:

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

Jetzt sollten Sie "Hallo Welt" auf yourdomain.com sehen

Eine letzte Anmerkung bezüglich des Startens des Knotenservers: Sie sollten eine Art Überwachungssystem für den Knoten-Daemon verwenden. Es gibt ein tolles Tutorial auf Knoten mit Upstart und Monit.


1177
2018-02-16 10:20



Sie können auch mehrere Domänen mit nginx einrichten und sie 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/;
    }
}

146
2018-05-02 11:38



Sie können auch verschiedene URLs für Apps in einer Serverkonfiguration verwenden:

Im / etc / nginx / sites-enabled / IhreDomain:

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

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

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

44
2018-03-31 17:31



Ich Proxy unabhängige Node Express-Anwendungen durch Nginx.

Somit können neue Anwendungen einfach gemountet werden und ich kann auch andere Dinge auf dem gleichen Server an verschiedenen Orten laufen lassen.

Hier sind weitere Details zu meiner Konfiguration mit dem Nginx-Konfigurationsbeispiel:

Stellen Sie mehrere Knotenanwendungen auf einem Webserver in Unterordnern mit Nginx bereit

Mit Node wird es schwierig, wenn Sie Ihre Anwendung von localhost auf das Internet übertragen müssen.

Es gibt keinen gemeinsamen Ansatz für die Knotenbereitstellung.

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

Grundsätzlich habe ich einen Webserver und möchte, dass Knotenanwendungen in Unterordnern eingebunden werden http: // myhost / demo / haustierprojekt /), ohne eine Konfigurationsabhängigkeit zum Anwendungscode einzuführen.

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

Klingt einfach, nicht wahr? Scheinbar nicht.

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

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

Aus diesem Grund 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/;
  }
}

Anhand dieses Beispiels können Sie feststellen, dass ich meine Pet Project Node-Anwendung, die auf Port 3000 ausgeführt wird, anmeldet http: // myhost / demo / pet-project.

Zuerst überprüft Nginx ob es sich bei der angeforderten Ressource um eine statische Datei handelt / opt / demo / pet-project / öffentlich / und wenn es so funktioniert, wie es ist, ist das hocheffizient, so dass wir keine redundante Schicht wie Connect statische Middleware benötigen.

Dann werden alle anderen Anfragen überschrieben und weitergeleitet Pet-Projektknoten Anwendung, so dass die Node-Anwendung nicht wissen muss, wo sie tatsächlich gemountet ist und somit durch Konfiguration einfach überall hin bewegt werden kann.

Proxy_Redirekt ist ein Muss, um Location Header richtig zu behandeln. Dies ist äußerst wichtig, wenn Sie verwenden res.redirect () in Ihrer Knotenanwendung.

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

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


26
2017-07-13 07:53



Node.js mit Nginx-Konfiguration.

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

Fügen Sie die folgende Konfiguration hinzu, so dass Nginx als Proxy-Umleitung zu Port 3000-Verkehr vom Server fungiert, wenn wir von "subdomain.your_domain.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;
  }
}

8
2018-03-17 12:24



Beantworten Sie Ihre Frage 2:

Ich würde die Option verwenden b einfach weil es viel weniger Ressourcen verbraucht. Mit der Option 'a' wird jeder Client dazu führen, dass der Server viel Speicher verbraucht und alle benötigten Dateien lädt (auch wenn ich PHP mag, ist das eines der Probleme). Mit der Option 'b' können Sie Ihre Bibliotheken (wiederverwendbarer Code) laden und für alle Client-Anfragen freigeben.

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


6
2018-01-03 04:51



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

Wenn einige von ihnen von nginx bedient werden, erhöht sich Ihre Leistung.


5
2017-07-05 14:17



Wir können eine Nodejs-App einfach einrichten, indem Nginx als Reverse-Proxy fungiert.
Die folgende Konfiguration setzt voraus, 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 deine Nodejs App

  • bekommen HTTP_HOST Header, in dem Sie domänenspezifische Logik anwenden können, um die Antwort zu bedienen. "
  • Ihre Anwendung muss von einem Prozessmanager wie verwaltet werden pm2 oder Supervisor für die Handhabung von Situationen / Wiederverwendung von Sockets oder Ressourcen usw.

  • Richten Sie einen Fehlermeldungsdienst ein, um Produktionsfehler zu erhalten Posten oder Überrollbügel

HINWEIS: Sie können eine Logik für das Verteilen domänenspezifischer Anforderungsrouten einrichten, indem Sie eine Middleware für expressjs Anwendung


4
2018-01-07 18:54



Ich habe in Github ein Repository erstellt, das du klonen kannst, Vagrant-Knoten-Nginx-Boilerplate

im Grunde die node.js App bei /var/www/nodeapp ist

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

4
2018-03-18 10:24



Nginx kann als Reverse-Proxy-Server fungieren, der wie ein Projektmanager funktioniert. Wenn es eine Anfrage erhält, analysiert es sie und leitet die Anfrage an die Upstream-Seite (Projektmitglieder) weiter oder bearbeitet sich selbst. Nginx hat zwei Möglichkeiten, eine Anfrage basierend auf ihrer Konfiguration zu bearbeiten.

  • erfülle die Anfrage
  • Weiterleiten der Anfrage an einen anderen Server

    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

Mit dieser Konfiguration, wenn die Anfrage-URL ist    mydomain.com/static/myjs.js es gibt das zurück myjs.js Datei in    /my/static/files/path Mappe. Wenn Sie nginx zum Servieren konfigurieren   statische Dateien behandelt es die Anfrage selbst.

Weiterleiten der Anfrage an einen anderen Server

Wenn die Anfrage-URL ist mydomain.com/dothis Nginx wird die   Anfrage zu http://127.0.0.1:8000. Der Dienst, der auf dem läuft   Der Port "localhost 8000" empfängt die Anforderung und gibt die Antwort zurück   zu nginx und nginx gibt die Antwort an den Client zurück.

Wenn Sie den Knoten node.js auf dem Port 8000 ausführen, leitet nginx die Anfrage an node.js weiter. Schreiben Sie die node.js-Logik und bearbeiten Sie die Anfrage. Das ist es, Sie haben Ihren Nodejs-Server hinter dem Nginx-Server ausgeführt.

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.


2
2017-09-27 08:07



Sie können Nodejs mit PM2 ausführen, wenn Sie jeden Microservice verwalten und ausführen möchten. Der Knoten wird in einem Port ausgeführt. Konfigurieren Sie 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, ob localhost ausgeführt wird oder nicht, indem Sie ping verwenden.

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 das Beste und wie du gesagt hast auch einfacher


0
2017-07-06 12:01