Question

我在我的服务器上设置了Node.js和Nginx。现在我想使用它，但是，在我开始之前有2个问题：

他们应该如何一起工作？我该如何处理这些要求？
Node.js服务器有两个概念，哪一个更好：

一个。为需要它的每个网站创建单独的HTTP服务器。然后在程序开头加载所有JavaScript代码，这样代码就会被解释一次。

湾创建一个处理所有Node.js请求的Node.js服务器。这将读取所请求的文件并篡改其内容。因此，每个请求都会解释文件，但服务器逻辑要简单得多。

我不清楚如何正确使用Node.js。

Answer 1

Nginx作为前端服务器，在这种情况下代理请求到node.js服务器。因此，您需要为节点设置nginx配置文件。

这就是我在Ubuntu框中所做的：

在yourdomain.com创建文件/etc/nginx/sites-available/：

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

在其中你应该有类似的东西：

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

如果您希望nginx（＆gt; = 1.3.13）处理websocket请求，请在location /部分添加以下行：

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

完成此设置后，您必须启用上面配置文件中定义的站点：

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

在/var/www/yourdomain/app.js创建您的节点服务器应用，并在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/');

测试语法错误：

nginx -t

重新启动nginx：

sudo /etc/init.d/nginx restart

最后启动节点服务器：

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

现在你应该在yourdomain.com看到“Hello World”

关于启动节点服务器的最后一点注意事项：您应该为节点守护程序使用某种监视系统。有一个很棒的tutorial on node with upstart and monit。

Answer 2

您还可以使用nginx设置多个域，转发到多个node.js进程。

例如要实现这些目标：

domain1.com - ＆gt;到本地运行的Node.js进程http://127.0.0.1:4000
domain2.com - ＆gt;到本地运行的Node.js进程http://127.0.0.1:5000

<强>的/ etc / nginx的/启用的站点 - / 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/;
    }
}

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

Answer 3

您还可以在一个服务器配置中为应用设置不同的网址：

yourdomain.com/app1/* - ＆gt;到本地运行的Node.js进程 http://127.0.0.1:3000
yourdomain.com/app2/* - ＆gt;到Node.js进程在本地运行http://127.0.0.1:4000

在 / 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：

sudo service nginx restart

启动应用程序。

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

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

Answer 4

我通过Nginx代理独立的Node Express应用程序。

因此可以轻松安装新应用程序，我也可以在不同位置的同一台服务器上运行其他内容。

以下是有关使用Nginx配置示例进行设置的更多详细信息：

使用Nginx在子文件夹中的一个Web服务器上部署多个Node应用程序

当您需要将应用程序从localhost移动到互联网时，Node会变得棘手。

节点部署没有通用的方法。

谷歌可以找到关于这个主题的大量文章，但我很难为我需要的设置找到合适的解决方案。

基本上，我有一个Web服务器，我希望将Node应用程序挂载到子文件夹（即http://myhost/demo/pet-project/），而不会对应用程序代码引入任何配置依赖性。

与此同时，我希望像博客这样的其他东西在同一个网络服务器上运行。

听起来很简单吧？显然不是。

在Web节点应用程序的许多示例中，可以在端口80上运行，也可以由Nginx代理到根目录。

尽管这两种方法对某些用例都有效，但它们并不符合我的简单但有点奇特的标准。

这就是我创建自己的Nginx配置的原因，这是一个摘录：
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/;
  }
}
从这个示例中，您可以注意到我将在端口3000上运行的Pet Project Node应用程序挂载到http://myhost/demo/pet-project。

首先，Nginx会检查所请求的资源是否是 / opt / demo / pet-project / public / 中可用的静态文件，如果是，那么它的效率非常高，所以我们不需要像Connect static middleware这样的冗余层。

然后所有其他请求都被覆盖并代理到 Pet Project Node 应用程序，因此Node应用程序不需要知道它实际安装在何处，因此可以完全通过配置移动到任何地方。

proxy_redirect 是正确处理Location头的必须。如果在Node应用程序中使用 res.redirect（），这一点非常重要。

您可以轻松地为在不同端口上运行的多个Node应用程序复制此设置，并为其他目的添加更多位置处理程序。

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

Answer 5

具有Nginx配置的Node.js。

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

添加以下配置，以便当我们来自“subdomain.your_domain.com”时，Nginx充当代理重定向到来自服务器的端口3000流量

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

Answer 6

回答你的问题2：

我会使用选项b，因为它消耗的资源少得多。使用选项'a'，每个客户端将导致服务器消耗大量内存，加载您需要的所有文件（即使我喜欢php，这是它的问题之一）。使用选项'b'，您可以加载库（可重用代码）并在所有客户端请求中共享它们。

但要知道如果你有多个核心，你应该调整node.js来使用它们。

Answer 7

我在Github中创建了一个可以克隆的存储库，vagrant-node-nginx-boilerplate

/var/www/nodeapp的node.js应用程序基本上是

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

和/etc/nginx/sites-available/的nginx配置是

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

Answer 8

您还可以使用node.js将静态文件生成到nginx提供的目录中。当然，站点的某些动态部分可以由节点提供，有些则由nginx（静态）提供。

其中一些由nginx提供服务会提高你的表现。

Answer 9

我们可以通过Nginx作为反向代理轻松设置Nodejs应用程序以下配置假定NodeJS应用程序在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
     }
   }

在上面的设置中，您的Nodejs应用程序将

获取HTTP_HOST标头，您可以在其中应用特定于域的逻辑来提供响应。 “
您的应用程序必须由https://www.gnupg.org/documentation/manuals/gnupg-devel/Invoking-GPG_002dAGENT.html或主管等流程管理员管理，以处理情况/重用套接字或资源等。
设置错误报告服务以获取生成错误，例如pm2或sentry

注意：您可以设置逻辑以处理特定于域的请求路由，为expressjs应用程序创建rollbar

Answer 10

Nginx可以充当反向代理服务器，就像项目经理一样。当它收到请求时，它会分析它并将请求转发给上游（项目成员）或处理自己。 Nginx有两种基于配置方式处理请求的方法。

提供请求

将请求转发给其他服务器

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

}

服务器请求

使用此配置时，请求URL为 mydomain.com/static/myjs.js它会返回myjs.js个文件 /my/static/files/path文件夹。配置nginx以进行服务时静态文件，它自己处理请求。

将请求转发给其他服务器

当请求网址为mydomain.com/dothis时，nginx将转发请求http://127.0.0.1:8000。正在运行的服务 localhost 8000端口将收到请求并返回响应到nginx和nginx将响应返回给客户端。

当您在端口8000上运行node.js服务器时，nginx会将请求转发给node.js.编写node.js逻辑并处理请求。就是你让你的nodejs服务器在nginx服务器后运行。

如果您希望运行除nodejs之外的任何其他服务，只需在不同的端口上运行Django，flask，php等其他服务，并在nginx中进行配置。

Answer 11

如果要管理每个微服务手段并运行它，则可以使用pm2运行nodejs。只需在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;
    }
}

使用ping检查localhost是否正在运行。

还有

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.

这是最好的，而且正如您所说的那样容易

Answer 12

使用Nginx和Nodejs的最好，最简单的设置是将Nginx用作启用proxy_protocol的HTTP和TCP负载均衡器。在这种情况下，Nginx将能够将传入的请求代理到nodejs，还可以终止与后端Nginx服务器的SSL连接，而不是与代理服务器本身的SSL连接。（SSL-PassThrough）

我认为，给出非SSL示例是没有意义的，因为所有Web应用程序都（或应该）使用安全环境。

代理服务器的示例配置，位于 /etc/nginx/nginx.conf

user  nginx;
worker_processes  1;
error_log  /var/log/nginx/error.log warn;
pid        /var/run/nginx.pid;
events {
    worker_connections  1024;
}
http {
  upstream webserver-http {
    server 192.168.1.4; #use a host port instead if using docker
    server 192.168.1.5; #use a host port instead if using docker
  }
  upstream nodejs-http {
    server 192.168.1.4:8080; #nodejs listening port
    server 192.168.1.5:8080; #nodejs listening port
  }
  server {
    server_name example.com;
    location / {
      proxy_set_header X-Real-IP $remote_addr;
      proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
      proxy_set_header X-Forwarded-Proto $scheme;
      proxy_set_header Host $http_host;
      proxy_set_header X-Forwarded-Host $server_name;
      proxy_set_header Connection "";
      add_header       X-Upstream $upstream_addr;
      proxy_redirect     off;
      proxy_connect_timeout  300;
      proxy_http_version 1.1;
      proxy_buffers 16 16k;
      proxy_buffer_size 16k;
      proxy_cache_background_update on;
      proxy_pass http://webserver-http$request_uri;
    }
  }
  server {
    server_name node.example.com;
    location / {
      proxy_set_header X-Real-IP $remote_addr;
      proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
      proxy_set_header X-Forwarded-Proto $scheme;
      proxy_set_header Host $http_host;
      proxy_set_header X-Forwarded-Host $server_name;
      proxy_set_header Upgrade $http_upgrade;
      proxy_set_header Connection "Upgrade";
      add_header       X-Upstream $upstream_addr;
      proxy_redirect     off;
      proxy_connect_timeout  300;
      proxy_http_version 1.1;
      proxy_buffers 16 16k;
      proxy_buffer_size 16k;
      proxy_cache_background_update on;
      proxy_pass http://nodejs-http$request_uri;
    }
  }
}
stream {
  upstream webserver-https {
    server 192.168.1.4:443; #use a host port instead if using docker
    server 192.168.1.5:443; #use a host port instead if using docker
  }

  server {
    proxy_protocol on;
    tcp_nodelay on;
    listen 443;
    proxy_pass webserver-https;
  }
  log_format proxy 'Protocol: $protocol - $status $bytes_sent $bytes_received $session_time';
  access_log  /var/log/nginx/access.log proxy;
  error_log /var/log/nginx/error.log debug;
}

现在，让我们处理后端Web服务器。 /etc/nginx/nginx.conf ：

user  nginx;
worker_processes  1;
error_log  /var/log/nginx/error.log warn;
pid        /var/run/nginx.pid;
load_module /etc/nginx/modules/ngx_http_geoip2_module.so; # GeoIP2
events {
    worker_connections  1024;
}
http {
    variables_hash_bucket_size 64;
    variables_hash_max_size 2048;
    server_tokens off;
    sendfile    on;
    tcp_nopush  on;
    tcp_nodelay on;
    autoindex off;
    keepalive_timeout  30;
    types_hash_bucket_size 256;
    client_max_body_size 100m;
    server_names_hash_bucket_size 256;
    include         mime.types;
    default_type    application/octet-stream;
    index  index.php index.html index.htm;
    # GeoIP2
    log_format  main    'Proxy Protocol Address: [$proxy_protocol_addr] '
                        '"$request" $remote_addr - $remote_user [$time_local] "$request" '
                        '$status $body_bytes_sent "$http_referer" '
                        '"$http_user_agent" "$http_x_forwarded_for"';

    # GeoIP2
    log_format  main_geo    'Original Client Address: [$realip_remote_addr]- Proxy Protocol Address: [$proxy_protocol_addr] '
                            'Proxy Protocol Server Address:$proxy_protocol_server_addr - '
                            '"$request" $remote_addr - $remote_user [$time_local] "$request" '
                            '$status $body_bytes_sent "$http_referer" '
                            '$geoip2_data_country_iso $geoip2_data_country_name';

    access_log  /var/log/nginx/access.log  main_geo; # GeoIP2
#===================== GEOIP2 =====================#
    geoip2 /usr/share/geoip/GeoLite2-Country.mmdb {
        $geoip2_metadata_country_build  metadata build_epoch;
        $geoip2_data_country_geonameid  country geoname_id;
        $geoip2_data_country_iso        country iso_code;
        $geoip2_data_country_name       country names en;
        $geoip2_data_country_is_eu      country is_in_european_union;
    }
    #geoip2 /usr/share/geoip/GeoLite2-City.mmdb {
    #   $geoip2_data_city_name city names en;
    #   $geoip2_data_city_geonameid city geoname_id;
    #   $geoip2_data_continent_code continent code;
    #   $geoip2_data_continent_geonameid continent geoname_id;
    #   $geoip2_data_continent_name continent names en;
    #   $geoip2_data_location_accuracyradius location accuracy_radius;
    #   $geoip2_data_location_latitude location latitude;
    #   $geoip2_data_location_longitude location longitude;
    #   $geoip2_data_location_metrocode location metro_code;
    #   $geoip2_data_location_timezone location time_zone;
    #   $geoip2_data_postal_code postal code;
    #   $geoip2_data_rcountry_geonameid registered_country geoname_id;
    #   $geoip2_data_rcountry_iso registered_country iso_code;
    #   $geoip2_data_rcountry_name registered_country names en;
    #   $geoip2_data_rcountry_is_eu registered_country is_in_european_union;
    #   $geoip2_data_region_geonameid subdivisions 0 geoname_id;
    #   $geoip2_data_region_iso subdivisions 0 iso_code;
    #   $geoip2_data_region_name subdivisions 0 names en;
   #}

#=================Basic Compression=================#
    gzip on;
    gzip_disable "msie6";
    gzip_vary on;
    gzip_proxied any;
    gzip_comp_level 6;
    gzip_buffers 16 8k;
    gzip_http_version 1.1;
    gzip_types text/css text/xml text/plain application/javascript image/jpeg image/png image/gif image/x-icon image/svg+xml image/webp application/font-woff application/json application/vnd.ms-fontobject application/vnd.ms-powerpoint;
    gzip_static on;

    include /etc/nginx/sites-enabled/example.com-https.conf;
}

现在，让我们在 /etc/nginx/sites-available/example.com-https.conf 中使用启用了SSL和proxy_protocol的配置来配置虚拟主机：

server {
    real_ip_header proxy_protocol;
    set_real_ip_from 192.168.1.1; #proxy server ip address
    #set_real_ip_from proxy; #proxy container hostname if you are using docker
    server_name 192.168.1.4; #Your current server ip address. It will redirect to the domain name.
    listen 80;
    listen 443 ssl http2;
    listen [::]:80;
    listen [::]:443 ssl http2;
    ssl_certificate     /etc/nginx/certs/example.com.crt;
    ssl_certificate_key /etc/nginx/certs/example.com.key;
    ssl_dhparam /etc/nginx/ssl/dhparam.pem;
    return 301 https://example.com$request_uri;
}
server {
    real_ip_header proxy_protocol;
    set_real_ip_from 192.168.1.1; #proxy server ip address
    #set_real_ip_from proxy; #proxy container hostname if you are using docker
    server_name  example.com;
    listen       *:80;
    return 301   https://example.com$request_uri;
}
server {
    real_ip_header proxy_protocol;
    set_real_ip_from 192.168.1.1; #proxy server ip address
    #set_real_ip_from proxy; #proxy container hostname if you are using docker
    server_name www.example.com;
    listen 80;
    listen 443 http2;
    listen [::]:80;
    listen [::]:443 ssl http2 ;
    ssl_certificate     /etc/nginx/certs/example.com.crt;
    ssl_certificate_key /etc/nginx/certs/example.com.key;
    ssl_dhparam /etc/nginx/ssl/dhparam.pem;
    return 301 https://example.com$request_uri;
}
server {
    real_ip_header proxy_protocol;
    set_real_ip_from 192.168.1.1; #proxy server ip address
    #set_real_ip_from proxy; #proxy container hostname if you are using docker
    server_name example.com;
    listen 443 proxy_protocol ssl http2;
    listen [::]:443 proxy_protocol ssl http2;
    root /var/www/html;
    charset UTF-8;
    add_header Strict-Transport-Security 'max-age=31536000; includeSubDomains; preload';
    add_header X-Frame-Options SAMEORIGIN;
    add_header X-Content-Type-Options nosniff;
    add_header X-XSS-Protection "1; mode=block";
    add_header Referrer-Policy no-referrer;
    ssl_prefer_server_ciphers on;
    ssl_ciphers "EECDH+AESGCM:EDH+AESGCM:AES256+EECDH:AES256+EDH";
    ssl_protocols TLSv1.2 TLSv1.1 TLSv1;
    ssl_session_cache   shared:SSL:10m;
    ssl_session_timeout 10m;
    keepalive_timeout   70;
    ssl_buffer_size 1400;
    ssl_dhparam /etc/nginx/ssl/dhparam.pem;
    ssl_stapling on;
    ssl_stapling_verify on;
    resolver 8.8.8.8 8.8.4.4 valid=86400;
    resolver_timeout 10;
    ssl_certificate     /etc/nginx/certs/example.com.crt;
    ssl_certificate_key /etc/nginx/certs/example.com.key;
    ssl_trusted_certificate /etc/nginx/certs/example.com.crt;
location ~* \.(jpg|jpe?g|gif|png|ico|cur|gz|svgz|mp4|ogg|ogv|webm|htc|css|js|otf|eot|svg|ttf|woff|woff2)(\?ver=[0-9.]+)?$ {
    expires modified 1M;
    add_header Access-Control-Allow-Origin '*';
    add_header Pragma public;
    add_header Cache-Control "public, must-revalidate, proxy-revalidate";
    access_log off;
    }
    location ~ /.well-known { #For issuing LetsEncrypt Certificates
        allow all;
    }
location / {
    index index.php;
    try_files $uri $uri/ /index.php?$args;
    }
error_page  404    /404.php;

location ~ \.php$ {
    try_files       $uri =404;
    fastcgi_index   index.php;
    fastcgi_pass    unix:/tmp/php7-fpm.sock;
    #fastcgi_pass    php-container-hostname:9000; (if using docker)
    fastcgi_pass_request_headers on;
    fastcgi_split_path_info ^(.+\.php)(/.+)$;
    fastcgi_param   SCRIPT_FILENAME  $document_root$fastcgi_script_name;
    fastcgi_intercept_errors on;
    fastcgi_ignore_client_abort off;
    fastcgi_connect_timeout 60;
    fastcgi_send_timeout 180;
    fastcgi_read_timeout 180;
    fastcgi_request_buffering on;
    fastcgi_buffer_size 128k;
    fastcgi_buffers 4 256k;
    fastcgi_busy_buffers_size 256k;
    fastcgi_temp_file_write_size 256k;
    include fastcgi_params;
}
location = /robots.txt {
    access_log off;
    log_not_found off;
    }
location ~ /\. {
    deny  all;
    access_log off;
    log_not_found off;
    }
}

最后，有一个 2个nodejs网络服务器的示例：第一台服务器：

var http = require('http');

http.createServer(function (req, res) {
    res.writeHead(200, {'Content-Type': 'text/plain'});
    res.end('Hello From Nodejs\n');
}).listen(8080, "192.168.1.4");
console.log('Server running at http://192.168.1.4:8080/');

第二个服务器：

var http = require('http');

http.createServer(function (req, res) {
    res.writeHead(200, {'Content-Type': 'text/plain'});
    res.end('Hello From Nodejs\n');
}).listen(8080, "192.168.1.5");
console.log('Server running at http://192.168.1.5:8080/');

现在一切应该都可以正常工作并且负载均衡了。

前一段时间，我写了关于How to set up Nginx as a TCP load balancer in Docker的文章。看看是否正在使用Docker。

Answer 13

您可以使用以下系统部署您的应用： https://github.com/dokku/dokku 例如，这将极大地帮助管理 nginx 和应用程序停机时间。它将带有预配置的 nginx conf 文件，您可以根据需要对其进行自定义。

Node.js + Nginx - 现在怎么办？

13 个答案: