Nœud.js + Nginx-et maintenant?

vous pouvez également configurer plusieurs domaines avec nginx, transfert vers plusieurs noeuds.processus js.

par exemple pour réaliser ceux-ci:

• domain1.com -> pour le Nœud.processus js exécuté localement http://127.0.0.1:4000
• domain2.com -> pour le Nœud.processus js exécuté localement http://127.0.0.1:5000

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

vous pouvez également avoir des urls différentes pour les applications dans une configuration de serveur:

• yourdomain.com/app1/* -> à Nœud.processus js exécuté localement http://127.0.0.1:3000
• yourdomain.com/app2/* -> à Nœud.processus js exécution locale http://127.0.0.1:4000

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émarrer nginx:

sudo service nginx restart

les applications de Démarrage.

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

je proxy Noeud indépendant Express applications par le biais de Nginx.

ainsi de nouvelles applications peuvent être facilement montées et je peux également exécuter d'autres choses sur le même serveur à des endroits différents.

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

déployer des applications à noeuds multiples sur un serveur web dans des sous-dossiers avec Nginx

Les choses deviennent délicates avec Node quand vous avez besoin de déplacer votre application de localhost à l'internet.

il n'y a pas d'approche commune pour le déploiement des Noeuds.

Google peut trouver des tonnes d'articles sur ce sujet, mais j'ai eu du mal à trouver la bonne solution pour la configuration dont j'ai besoin.

fondamentalement, j'ai un serveur web et je veux que les applications de Noeud soient montées à des sous-dossiers (i.e. http://myhost/demo/pet-project / ) sans introduire de dépendance de configuration au code d'application.

en même temps je veux que d'autres choses comme blog tournent sur le même serveur web.

ça a l'air simple, hein? Apparemment pas.

dans de nombreux exemples sur les nodules web, les applications tournent soit sur le port 80, soit avec Nginx à la racine.

Même si les deux approches sont valables pour certains cas d'utilisation, ils 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(.*)  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 pouvez remarquer que je monte mon application pet project Node sur le port 3000 à http://myhost/demo/pet-project .

Première Nginx vérifie si la ressource demandée est un fichier statique disponible à /opt/demo/pet-project/ public / et si c'est le cas, il est très efficace, donc nous n'avons pas besoin d'avoir une couche redondante comme Connect static middleware.

puis toutes les autres requêtes sont écrasées et remplacées par l'application pet project Node , de sorte que l'application de Noeud n'a pas besoin de savoir où elle est effectivement montée et peut donc être déplacée n'importe où par la configuration.

proxy_redirect est un must pour gérer l'Emplacement de l'en-tête correctement. Ceci est extrêmement important si vous utilisez res.rediriger () dans votre application de Noeud.

vous pouvez facilement répliquer cette configuration pour des applications à noeuds multiples tournant sur des ports différents et ajouter plus de gestionnaires d'emplacement pour d'autres buts.

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

Node.js avec la configuration Nginx.

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

ajouter la configuration suivante de sorte que Nginx agissant comme un proxy rediriger vers le trafic de port 3000 à partir du 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;
  }
}

répondre à 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 consommera beaucoup de mémoire, en chargeant tous les fichiers dont vous avez besoin (même si j'aime php, c'est l'un des problèmes). Avec l'option 'b', vous pouvez charger vos bibliothèques (code réutilisable) et les partager entre toutes les demandes des clients.

mais soyez conscient que si vous avez plusieurs cœurs tu devrais modifier le noeud.js pour les utiliser tous.

vous pouvez également utiliser le noeud.js pour générer des fichiers statiques dans un répertoire servi par nginx. Bien sûr, certaines parties dynamiques de votre site pourraient être servies par noeud, et certaines par nginx (statique).

avoir certains d'entre eux servis par nginx augmente votre performance..

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

essentiellement le noeud.js application /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 config 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;
        }
}

nous pouvons facilement configurer une application Nodejs par Nginx agissant comme un proxy inverse.

La configuration suivante suppose que L'application NodeJS tourne 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 sera,

• get HTTP_HOST en-tête où vous pouvez appliquer de domaine logique spécifique pour servir la réponse. "

• votre demande doit être gérée par un processus gestionnaire comme pm2 ou superviseur pour la manipulation des situations / la réutilisation des sockets ou des ressources, etc.

• l'Installation d'un service de rapport d'erreur pour obtenir des erreurs de production comme sentinelle ou arceau de sécurité

NOTE: Vous pouvez configurer la logique pour traiter les routes de requête spécifiques à un domaine, créer un middleware pour expressjs application

Nginx peut agir comme un serveur mandataire inverse qui fonctionne exactement comme un gestionnaire de projet. Lorsqu'il reçoit une demande, il l'analyse et transmet la demande à l'amont(membres du projet) ou s'en occupe lui-même. Nginx dispose de deux façons de traiter une requête basée sur la façon dont elle est configurée.

• servir la demande

• transmettre la demande à 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 requête est mydomain.com/static/myjs.js il retourne le fichier myjs.js en /my/static/files/path le dossier. Quand vous configurez nginx pour servir fichiers statiques il traite la requête elle-même.

transmettre la demande à un autre serveur

lorsque l'url de la requête est mydomain.com/dothis nginx va transmet l' demande de http://127.0.0.1:8000 . Le service qui fonctionne sur le le port localhost 8000 recevra la requête et retournera la réponse pour nginx et nginx renvoie la réponse au client.

quand vous lancez noeud.js server sur le port 8000 NGINX transmet la requête à node.js. Écrire nœud.js logic et gérer la demande. C'est tout. votre serveur nodejs tourne derrière nginx. serveur.

si vous souhaitez exécuter d'autres services que nodejs, il vous suffit d'exécuter un autre service comme Django, flask, php sur différents ports et de le configurer dans nginx.

vous pouvez exécuter nodejs en utilisant pm2 si vous voulez gérer chaque microservice signifie Et l'exécuter. Le noeud tournera dans un port à droite, 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 en utilisant 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 le meilleur, et comme vous l'avez dit plus facile trop