web-dev-qa-db-fra.com

Node.js + Nginx - Et maintenant?

J'ai configuré Node.js et Nginx sur mon serveur. Maintenant, je veux l'utiliser, mais avant de commencer, il y a 2 questions:

  1. Comment devraient-ils travailler ensemble? Comment dois-je traiter les demandes?

  2. Il existe 2 concepts pour un serveur Node.js, lequel est le meilleur:

    une. Créez un serveur HTTP distinct pour chaque site Web qui en a besoin. Chargez ensuite tout le code JavaScript au début du programme afin qu'il soit interprété une fois.

    b. Créez un seul serveur Node.js qui gère toutes les demandes Node.js. Ceci lit les fichiers demandés et évalue leur contenu. Les fichiers sont donc interprétés à chaque requête, mais la logique du serveur est beaucoup plus simple.

Ce n'est pas clair pour moi comment utiliser correctement Node.js.

node.jsnginxconcept
941
Van Coding

Nginx fonctionne comme un serveur frontal qui, dans ce cas, envoie les requêtes à un serveur node.js. Par conséquent, vous devez configurer un fichier de configuration nginx pour noeud.

C'est ce que j'ai fait dans ma boîte Ubuntu:

Créez le fichier yourdomain.com dans /etc/nginx/sites-available/:

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

Vous devriez y trouver quelque chose comme:

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

Si vous souhaitez que nginx (> = 1.3.13) traite également les requêtes websocket, ajoutez les lignes suivantes dans la section location /:

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

Une fois que vous avez cette configuration, vous devez activer le site défini dans le fichier de configuration ci-dessus:

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

Créez votre application de serveur de nœuds à /var/www/yourdomain/app.js et exécutez-la à 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 des erreurs de syntaxe:

nginx -t

Redémarrez nginx:

Sudo /etc/init.d/nginx restart

Enfin, démarrez le serveur de noeud:

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

Vous devriez maintenant voir "Hello World" sur yourdomain.com

Une dernière remarque concernant le démarrage du serveur de nœud: vous devez utiliser une sorte de système de surveillance pour le démon de nœud. Il y a un génial tutoriel sur le noeud avec upstart et monit .

1251
Joao Da Silva

Vous pouvez également configurer plusieurs domaines avec nginx, en les transférant vers plusieurs processus node.js.

Par exemple pour atteindre ceux-ci:

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

Dans/etc/nginx/sites-enabled/domaine2 

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

Vous pouvez également avoir différentes URL pour les applications dans une configuration de serveur:

Dans /etc/nginx/sites-enabled/votredomaine :

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

Redémarrez nginx:

Sudo service nginx restart

Lancer des applications.

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

noeud 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

I indépendant du proxy Node Express applications via Nginx.

Ainsi, les nouvelles applications peuvent être facilement montées et je peux également exécuter d'autres tâches sur le même serveur à différents endroits.

Voici plus de détails sur ma configuration avec l'exemple de configuration Nginx:

Déployez plusieurs Node applications sur un serveur Web dans des sous-dossiers avec Nginx

La situation se complique avec Node lorsque vous devez déplacer votre application de localhost à Internet.

Il n'y a pas d'approche commune pour le déploiement de Node.

Google peut trouver des tonnes d'articles sur ce sujet, mais j'avais du mal à trouver la solution adaptée à la configuration dont j'avais besoin.

En gros, j'ai un serveur Web et je veux que Node applications soient montées dans des sous-dossiers (c'est-à-dire http: // myhost/demo/pet-project / ) sans introduire de dépendance à la configuration. au code de l'application.

En même temps, je souhaite que d’autres éléments, tels que blog, soient exécutés sur le même serveur Web.

Cela semble simple hein? Apparemment non.

Dans de nombreux exemples Web, les applications Node s'exécutent sur le port 80 ou sont envoyées par proxy à la racine par Nginx.

Même si les deux approches sont valables pour certains cas d'utilisation, elles ne répondent pas à mes critères simples mais un peu exotiques.

C'est pourquoi j'ai créé ma propre configuration Nginx et voici un extrait:

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

Dans cet exemple, vous remarquerez que je monte mon application Pet Project Node exécutée sur le port 3000 sur http: // myhost/demo/pet-project .

First Nginx vérifie si la ressource demandée est un fichier statique disponible sur / opt/demo/pet-project/public / et si elle le sert tel quel, cela est très efficace, nous n’avons donc pas besoin d'avoir une couche redondante telle que le middleware statique Connect.

Ensuite, toutes les autres demandes sont écrasées et traitées par proxy vers l'application Noeud de projet pour animaux de compagnie, de sorte que l'application Node n'a pas besoin de savoir où elle est réellement montée et peut donc être déplacée n'importe où uniquement par configuration. .

proxy_redirect ​​est indispensable pour gérer correctement l'en-tête Location. Ceci est extrêmement important si vous utilisez res.redirect () dans votre application Node.

Vous pouvez facilement répliquer cette configuration pour plusieurs Node applications s'exécutant sur des ports différents et ajouter d'autres gestionnaires d'emplacement à d'autres fins.

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

31
skovalyov

Node.js avec configuration Nginx.

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

ajoutez la configuration suivante pour que Nginx agisse en tant que redirection de proxy vers le trafic du port 3000 depuis le serveur lorsque nous venons de "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;
  }
}
10
aquadir

répondant à votre question 2:

J'utiliserais l'option b simplement parce qu'elle consomme beaucoup moins de ressources. avec l'option 'a', chaque client fera que le serveur consomme beaucoup de mémoire, chargeant tous les fichiers dont vous avez besoin (même si j'aime php, c'est l'un des problèmes avec celui-ci). Avec l'option 'b', vous pouvez charger vos bibliothèques (code réutilisable) et les partager entre toutes les demandes des clients.

Mais sachez que si vous avez plusieurs cœurs, vous devez modifier le fichier node.js pour pouvoir tous les utiliser.

8
Hugo Mota

J'ai fait un dépôt dans Github que vous pouvez cloner, vagrant-node-nginx-boilerplate

essentiellement l'application node.js à /var/www/nodeapp est

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

et la configuration nginx à /etc/nginx/sites-available/ est

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

Vous pouvez également utiliser node.js pour générer des fichiers statiques dans un répertoire géré par nginx. Bien entendu, certaines parties dynamiques de votre site pourraient être desservies par noeud, et d'autres par nginx (statique).

Avoir certains d’entre eux servis par nginx augmente vos performances.

5
code ninja

Nous pouvons facilement configurer une application Nodejs de Nginx agissant en tant que proxy inverse.
La configuration suivante suppose que l’application NodeJS s’exécute sur 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
     }
   }

dans la configuration ci-dessus, votre application Nodejs

  • get HTTP_Host header où vous pouvez appliquer une logique propre à un domaine pour répondre à la réponse. '

  • Votre application doit être gérée par un gestionnaire de processus tel que pm2 ou par un superviseur pour gérer les situations/réutiliser des sockets ou des ressources, etc.

  • Configurez un service de rapport d'erreur pour obtenir des erreurs de production telles que sentinelle ou arcea

REMARQUE: vous pouvez configurer une logique pour la gestion des routes de requête spécifiques à un domaine. Créez un middleware pour l'application expressjs.

5
I Am Batman

Nginx peut agir en tant que serveur proxy inverse qui fonctionne comme un chef de projet. Lorsqu'il reçoit une demande, il l'analyse et la transmet à l'amont (membres du projet) ou se traite tout seul. Nginx dispose de deux méthodes pour traiter une demande en fonction de la configuration de celle-ci.

  • servir la demande

  • transférer la demande vers un autre serveur

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

    }

Serveur la requête

Avec cette configuration, lorsque l'url de la demande est mydomain.com/static/myjs.js, il renvoie le fichier myjs.js dans le dossier /my/static/files/path. Lorsque vous configurez nginx pour traiter des fichiers statiques, la demande est traitée elle-même.

transfère la demande à un autre serveur

Lorsque l'url de la demande est mydomain.com/dothis, nginx transmettra la demande à http://127.0.0.1:80 . Le service en cours d'exécution sur le port localhost 8000 recevra la demande et renverra la réponse à nginx et nginx renverra la réponse au client.

Lorsque vous exécutez le serveur node.js sur le port 8000, nginx transfère la demande à node.js. Ecrivez la logique de node.js et gérez la demande. Voilà, votre serveur nodejs s'exécute derrière le serveur nginx.

Si vous souhaitez exécuter d'autres services que nodejs, exécutez simplement un autre service tel que Django, flask, php sur différents ports et configurez-le dans nginx.

3
Vkreddy Komatireddy

Vous pouvez exécuter nodejs à l’aide de pm2 si vous souhaitez gérer chaque moyen de microservice et l’exécuter. Node s'exécutera dans un port, il suffit de configurer ce port dans 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;
    }
}

Vérifiez si localhost est en cours d'exécution ou non à l'aide de ping.

Et

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.

C'est mieux et comme tu as dit plus facile aussi

1
gokul kandasamy