Node.js + Nginx – Che ora?

Ho installato Node.js e Nginx sul mio server. Ora voglio usarlo, ma prima di iniziare ci sono 2 domande:

  1. Come dovrebbero lavorare insieme? Come dovrei gestire le richieste?
  2. Ci sono 2 concetti per un server Node.js, quale è meglio:

    un. Creare un server HTTP separato per ogni sito Web che ne ha bisogno. Quindi carica tutto il codice JavaScript all’inizio del programma, quindi il codice viene interpretato una volta.

    b. Creare un singolo server Node.js che gestisca tutte le richieste Node.js. Questo legge i file richiesti ed evalora i loro contenuti. Quindi i file vengono interpretati su ogni richiesta, ma la logica del server è molto più semplice.

Non è chiaro per me come usare correttamente Node.js.

Nginx funziona come un server front-end, che in questo caso trasmette le richieste a un server node.js. Pertanto è necessario configurare un file di configurazione nginx per il nodo.

Questo è quello che ho fatto nella mia scatola Ubuntu:

Crea il file yourdomain.com in /etc/nginx/sites-available/ :

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

In esso dovresti avere qualcosa come:

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

Se vuoi nginx (> = 1.3.13) per gestire anche le richieste websocket, aggiungi le seguenti linee nella location / sezione:

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

Una volta che hai questa configurazione devi abilitare il sito definito nel file di configurazione qui sopra:

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

Crea l’app del tuo server di nodes su /var/www/yourdomain/app.js ed /var/www/yourdomain/app.js su 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/'); 

Prova per errori di syntax:

 nginx -t 

Riavviare nginx:

 sudo /etc/init.d/nginx restart 

Infine avvia il server del nodo:

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

Ora dovresti vedere “Hello World” su yourdomain.com

Un’ultima nota per quanto riguarda l’avvio del server nodo: è necessario utilizzare un tipo di sistema di monitoraggio per il daemon del nodo. C’è un fantastico tutorial sul nodo con upstart e monit .

È anche ansible configurare più domini con nginx, inoltrando a più processi node.js.

Ad esempio per raggiungere questi:

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

Puoi anche avere URL diversi per le app in una configurazione del server:

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

Riavviare nginx:

 sudo service nginx restart 

Avvio delle applicazioni.

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

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

Proxy le applicazioni Node Express indipendenti tramite Nginx.

Così le nuove applicazioni possono essere montate facilmente e posso anche eseguire altre cose sullo stesso server in luoghi diversi.

Ecco ulteriori dettagli sulla mia configurazione con l’esempio di configurazione di Nginx:

Distribuire più applicazioni Node su un server Web in sottocartelle con Nginx

Le cose si complicano con il nodo quando è necessario spostare la tua applicazione da localhost a Internet.

Non esiste un approccio comune per la distribuzione dei nodes.

Google può trovare tonnellate di articoli su questo argomento, ma stavo faticando a trovare la soluzione adeguata per l’installazione di cui ho bisogno.

Fondamentalmente, ho un server Web e voglio che le applicazioni Node vengano montate su sottocartelle (ad es. Http: // myhost / demo / pet-project / ) senza introdurre alcuna dipendenza di configurazione dal codice dell’applicazione.

Allo stesso tempo voglio che altre cose come i blog vengano eseguite sullo stesso server web.

Sembra semplice eh? Apparentemente no.

In molti esempi sulle applicazioni Web Node, si esegue sulla porta 80 o con proxy di Nginx alla radice.

Anche se entrambi gli approcci sono validi per determinati casi d’uso, non soddisfano i miei criteri semplici ma un po ‘esotici.

Questo è il motivo per cui ho creato la mia configurazione Nginx e qui c’è un estratto:

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

Da questo esempio puoi notare che monto la mia applicazione Pet Project Node che gira su port 3000 su http: // myhost / demo / pet-project .

First Nginx verifica se la risorsa richiesta è un file statico disponibile in / opt / demo / pet-project / public / e se è così funziona come se fosse altamente efficiente, quindi non è necessario disporre di un layer ridondante come Connect middleware statico.

Quindi tutte le altre richieste vengono sovrascritte e inoltrate all’applicazione Pet Project Node , quindi l’applicazione Node non ha bisogno di sapere dove è effettivamente montata e quindi può essere spostata ovunque per semplice configurazione.

proxy_redirect è un must per gestire correttamente l’intestazione di posizione. Questo è estremamente importante se si utilizza res.redirect () nell’applicazione Node.

È ansible replicare facilmente questa configurazione per più applicazioni Node in esecuzione su porte diverse e aggiungere altri gestori di posizione per altri scopi.

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

Node.js con configurazione Nginx.

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

aggiungi la seguente configurazione in modo che Nginx agisca come un proxy reindirizza al traffico della porta 3000 dal server quando provengono da “sottodominio.tuo_dominio.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; } } 

rispondendo alla tua domanda 2:

Userei l’opzione b semplicemente perché consuma molto meno risorse. con l’opzione ‘a’, ogni client farà sì che il server consumi molta memoria, caricando tutti i file necessari (anche se mi piace il php, questo è uno dei problemi con esso). Con l’opzione ‘b’ puoi caricare le tue librerie (codice riusabile) e condividerle tra tutte le richieste dei clienti.

Ma sappi che se hai più core dovresti modificare node.js per usarli tutti.

È anche ansible utilizzare node.js per generare file statici in una directory servita da nginx. Certo, alcune parti dinamiche del tuo sito potrebbero essere servite dal nodo e alcune da nginx (statico).

Avere alcuni di loro serviti da nginx aumenta le tue prestazioni ..

Possiamo facilmente configurare un’app Nodejs di Nginx che agisce come proxy inverso.
La seguente configurazione presuppone che l’applicazione NodeJS sia in esecuzione su 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 } } 

nella configurazione di cui sopra la tua app Nodejs,

  • ottenere HTTP_HOST intestazione HTTP_HOST cui è ansible applicare la logica specifica del dominio per servire la risposta. ‘
  • La tua applicazione deve essere gestita da un responsabile di processo come pm2 o supervisore per gestire le situazioni / riutilizzare socket o risorse ecc.

  • Imposta un servizio di segnalazione degli errori per ottenere errori di produzione come sentinella o rollbar

NOTA: è ansible impostare la logica per la consegna di percorsi di richiesta specifici del dominio, creare un middleware per l’applicazione expressjs

Ho creato un repository in Github che puoi clonare, vagrant-node-nginx-boilerplate

in pratica l’app node.js in /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/'); 

e la configurazione di nginx in /etc/nginx/sites-available/ is

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

Nginx può fungere da server proxy inverso che funziona come un project manager. Quando riceve una richiesta, lo analizza e inoltra la richiesta a monte (membri del progetto) o gestisce se stessa. Nginx ha due modi di gestire una richiesta in base a come è configurata.

  • servire la richiesta
  • inoltra la richiesta a un altro 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 la richiesta

Con questa configurazione quando l’URL della richiesta è myjs.js restituisce il file myjs.js nella cartella /my/static/files/path . Quando configuri nginx per servire file statici, gestisce la richiesta stessa.

inoltra la richiesta a un altro server

Quando l’URL della richiesta è mydomain.com/dothis nginx inoltrerà la richiesta a http://127.0.0.1:8000 . Il servizio in esecuzione sulla porta localhost 8000 riceverà la richiesta e restituirà la risposta a nginx e nginx restituirà la risposta al client.

Quando si esegue il server node.js sulla porta 8000 nginx inoltrerà la richiesta a node.js. Scrivi la logica node.js e gestisci la richiesta. È così che hai il tuo server nodejs in esecuzione dietro il server nginx.

Se desideri eseguire altri servizi diversi da nodejs, esegui un altro servizio come Django, flask, php su porte diverse e configuralo in nginx.

È ansible eseguire nodejs utilizzando pm2 se si desidera gestire ciascun mezzo di microservizio ed eseguirlo. Il nodo verrà eseguito in una porta, basta configurare quella porta 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; } } 

Controlla se localhost è in esecuzione o meno usando 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. 

Questo è il migliore e, come hai detto, anche più facile