Node.js + Nginx - Şimdi ne olacak?

Sunucumda Node.js ve Nginx'i kurdum. Şimdi kullanmak istiyorum, ama başlamadan önce 2 soru var:

1. Birlikte nasıl çalışmalılar? İstekleri nasıl ele almalıyım?

2. Bir Node.js sunucusu için 2 kavram vardır, bunlardan biri daha iyidir:

   a. İhtiyacı olan her web sitesi için ayrı bir HTTP sunucusu oluşturun. Ardından, programın başlangıcında tüm JavaScript kodunu yükleyin, böylece kod bir kez yorumlanır.

   b. Tüm Node.js isteklerini işleyen tek bir Node.js sunucusu oluşturun. Bu istenen dosyaları okur ve içeriğini değiştirir. Bu yüzden dosyalar her istek üzerine yorumlanır, ancak sunucu mantığı çok daha basittir.

Node.js'nin doğru bir şekilde nasıl kullanılacağı benim için net değil.

Nginx, bu durumda istekleri bir node.js sunucusuna vekaleten bir ön uç sunucusu olarak çalışır. Bu nedenle, düğüm için bir nginx yapılandırma dosyası ayarlamanız gerekir.

Ubuntu kutumda yaptığım şey bu:

Dosyası oluşturun yourdomain.comat /etc/nginx/sites-available/:

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

İçinde şöyle bir şey olmalı:

# 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'in (> = 1.3.13) websocket isteklerini de işlemesini istiyorsanız, aşağıdaki satırları ekleyin location /:

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

Bu kurulumu yaptıktan sonra, yukarıdaki yapılandırma dosyasında tanımlanan siteyi etkinleştirmeniz gerekir:

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

Düğüm sunucusu uygulamanızı şurada oluşturun ve şurada /var/www/yourdomain/app.jsçalıştırın: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/');

Sözdizimi hatalarını test edin:

nginx -t

Nginx'i yeniden başlat:

sudo /etc/init.d/nginx restart

Son olarak düğüm sunucusunu başlatın:

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

Şimdi alanadiniz.com.tr adresinde "Merhaba Dünya" yı görmelisiniz

Düğüm sunucusunu başlatmayla ilgili son bir not: Düğüm arka plan programı için bir tür izleme sistemi kullanmalısınız. Düğümde uptart ve monit ile harika bir öğretici var .

Birden fazla node.js işlemine yönlendirerek, nginx ile birden fazla etki alanı da kurabilirsiniz.

Örneğin, bunları başarmak için:

• domain1.com -> yerel olarak çalışan Node.js işlemine http://127.0.0.1:4000
• domain2.com -> yerel olarak çalışan Node.js sürecine http://127.0.0.1:5000

Bu bağlantı noktaları (4000 ve 5000), uygulama kodunuzdaki uygulama isteklerini dinlemek için kullanılmalıdır.

/ Etc / nginx / siteler etkin / 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 etkin / domain2'de

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

Bir sunucu yapılandırmasındaki uygulamalar için farklı URL'leriniz de olabilir:

• alan_adiniz.com.tr/app1/* -> yerel olarak çalışan Node.js işlemine http://127.0.0.1:3000
• alan_adiniz.com.tr/app2/* -> yerel olarak çalışan Node.js işlemine http://127.0.0.1:4000

In / etc / nginx / siteler etkin / alanadınız :

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'i yeniden başlat:

sudo service nginx restart

Uygulamaları başlatma.

düğüm 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/');

düğüm 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/');

Nginx üzerinden bağımsız Node Express uygulamalarını proxy olarak kullanıyorum.

Böylece yeni uygulamalar kolayca monte edilebilir ve farklı sunucularda aynı sunucuda başka şeyler de çalıştırabilirim.

Nginx yapılandırma örneği ile kurulumum hakkında daha fazla bilgi:

Nginx ile alt klasörlerde bir web sunucusuna birden çok Düğüm uygulaması dağıtma

Uygulamanızı localhost'tan internete taşımanız gerektiğinde işler Düğüm ile zorlaşır.

Düğüm konuşlandırması için ortak bir yaklaşım yoktur.

Google bu konuyla ilgili tonlarca makale bulabilir, ancak ihtiyacım olan kurulum için uygun çözümü bulmakta zorlanıyordum.

Temel olarak, bir web sunucum var ve uygulama koduna herhangi bir yapılandırma bağımlılığı getirmeden Düğüm uygulamalarının alt klasörlere (yani http: // myhost / demo / pet-project / ) bağlanmasını istiyorum.

Aynı zamanda blog gibi başka şeylerin de aynı web sunucusunda çalışmasını istiyorum.

Basit geliyor ha? Görünüşe göre öyle değil.

Web üzerindeki birçok örnekte ya 80 numaralı bağlantı noktasında çalışır ya da Nginx tarafından köke proxy uygular.

Her iki yaklaşım da belirli kullanım durumları için geçerli olsa da, basit ama biraz egzotik kriterlerimi karşılamıyorlar.

Bu yüzden kendi Nginx yapılandırmamı oluşturdum ve işte bir alıntı:

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

Bu örnekten, 3000 numaralı bağlantı noktasında çalışan Pet Project Node uygulamamı http: // myhost / demo / pet-project'e bağladığımı fark edebilirsiniz .

İlk olarak Nginx, istenen kaynağın / opt / demo / pet-project / public / dizininde mevcut olan statik bir dosya olup olmadığını kontrol eder ve eğer öyleyse, oldukça verimli olduğu gibi sunuluyorsa , bu nedenle Connect gibi yedekli bir katmana ihtiyacımız yok statik ara katman yazılımı.

Daha sonra diğer tüm isteklerin üzerine yazılır ve Pet Project Node uygulamasına vekalet edilir , bu nedenle Node uygulamasının gerçekte nereye monte edildiğini bilmesine gerek yoktur ve bu nedenle herhangi bir yere tamamen konfigürasyon ile taşınabilir.

Konum başlığını düzgün bir şekilde işlemek için proxy_redirect bir zorunluluktur. Düğüm uygulamanızda res.redirect () kullanırsanız bu son derece önemlidir .

Bu kurulumu farklı bağlantı noktalarında çalışan birden çok Düğüm uygulaması için kolayca çoğaltabilir ve başka amaçlar için daha fazla konum işleyicisi ekleyebilirsiniz.

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

Nginx yapılandırmasına sahip Node.js.

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

"subdomain.your_domain.com" adresinden geldiğimizde Nginx'in sunucudan 3000 trafiğe yönlendirmesi için aşağıdaki yapılandırmayı ekleyin

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

sorunuzu cevaplama 2:

Ben bsadece çok daha az kaynak tüketir çünkü seçeneği kullanmak istiyorum . 'a' seçeneği ile, her istemci sunucunun ihtiyacınız olan tüm dosyaları yükleyerek çok fazla bellek tüketmesine neden olur (php'yi sevmeme rağmen bu sorunlardan biridir). 'B' seçeneği ile kitaplıklarınızı (yeniden kullanılabilir kod) yükleyebilir ve tüm istemci istekleri arasında paylaşabilirsiniz.

Ancak, birden fazla çekirdeğiniz varsa hepsini kullanmak için node.js ayarını yapmanız gerekir.

Github'da klonlayabileceğiniz bir depo yaptım, vagrant-node-nginx-boilerplate

temelde de uygulamayı node.js /var/www/nodeappDİR

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

ve en nginx yapılandırma /etc/nginx/sites-available/DİR

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

Ayrıca ndex tarafından sunulan bir dizine statik dosyalar oluşturmak için node.js dosyasını da kullanabilirsiniz. Tabii ki, sitenizin bazı dinamik bölümleri düğüm, bazıları nginx (statik) ile sunulabilir.

Bazılarının nginx tarafından sunulması performansınızı artırır.

Nginx tarafından ters proxy olarak hareket eden bir Nodejs uygulamasını kolayca kurabiliriz.
Aşağıdaki yapılandırma NodeJS uygulamasının 127.0.0.1:8080 üzerinde çalıştığını varsayar,

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

yukarıdaki kurulumda Nodejs uygulamanız,

• HTTP_HOSTyanıtı sunmak için alana özel mantık uygulayabileceğiniz üstbilgiyi alın . '

• Başvurunuz, durumları işlemek / soketleri veya kaynakları yeniden kullanmak vb. İçin pm2 gibi bir süreç yöneticisi veya amiri tarafından yönetilmelidir .

• Nöbetçi veya rollbar gibi üretim hatalarını almak için bir hata raporlama hizmeti kurun

NOT: etki alanına özgü istek yollarını vermek için mantık kurabilir, expressjs uygulaması için bir ara katman yazılımı oluşturabilirsiniz

Nginx, bir proje yöneticisi gibi çalışan bir ters proxy sunucusu gibi davranabilir. Bir istek aldığında, bunu analiz eder ve talebi akışa (proje üyeleri) iletir veya kendi kendine işler. Nginx, bir isteği nasıl yapılandırıldığına bağlı olarak iki şekilde ele alır.

• talebi yerine getir

• isteği başka bir sunucuya iletme

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

  }

İsteği sunucuya ekle

Bu yapılandırmada, istek URL'si olduğunda dosyayı klasörde mydomain.com/static/myjs.jsdöndürür . Nginx'i statik dosyalara hizmet verecek şekilde yapılandırdığınızda, isteğin kendisini işler.myjs.js/my/static/files/path

isteği başka bir sunucuya iletme

İstek URL'si mydomain.com/dothisnginx olduğunda isteği http://127.0.0.1:8000 adresine yönlendirir . Localhost 8000 bağlantı noktasında çalışan hizmet isteği alır ve yanıtı nginx'e döndürür ve nginx yanıtı istemciye döndürür.

8000 nginx bağlantı noktasında node.js sunucusunu çalıştırdığınızda, isteği node.js'ye yönlendirir. Node.js mantığını yazın ve isteği işleyin. Nodejs sunucunuz nginx sunucusunun arkasında çalışıyor.

Nodejs dışında başka bir hizmet çalıştırmak istiyorsanız, farklı bağlantı noktalarında Django, flask, php gibi başka bir hizmeti çalıştırın ve nginx'te yapılandırın.

Her bir mikro hizmet yöntemini yönetmek ve çalıştırmak istiyorsanız, nodejs'i pm2 kullanarak çalıştırabilirsiniz. Düğüm bir bağlantı noktasında çalışıyor olacak ve sadece bu bağlantı noktasını nginx'te yapılandıracak (/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 kullanarak localhost'un çalışıp çalışmadığını kontrol edin.

Ve

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.

Bu en iyisi ve dediğin gibi daha kolay

Nginx ve Nodejs ile en iyi ve basit kurulum, Nginx'i proxy_protocol etkin bir HTTP ve TCP yük dengeleyici olarak kullanmaktır. Bu bağlamda, Nginx gelen istekleri nodej'lere proxy olarak gönderebilecek ve proxy sunucusunun kendisine değil arka uç Nginx sunucularına SSL bağlantılarını sonlandırabilecektir. (SSL PassThrough)

Kanımca, SSL olmayan örnekler vermenin bir anlamı yok, çünkü tüm web uygulamaları güvenli ortamlar kullanıyor (veya olmalı).

Proxy sunucusu için /etc/nginx/nginx.conf dosyasında örnek yapılandırma

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

Şimdi arka uç web sunucusunu ele alalım. /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;
}

Şimdi, şu SSL ile sanal ana bilgisayarı yapılandırmak izin vermedi ve proxy_protocol de konfigürasyon dosyasında etkin /etc/nginx/sites-available/example.com-https.conf :

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

Ve son olarak, 2 nodejs web sunucusu örneği : İlk sunucu:

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

İkinci Server:

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

Şimdi her şey mükemmel bir şekilde çalışmalı ve yük dengeli olmalıdır.

Bir süre önce Nginx'i Docker'da bir TCP yük dengeleyici olarak nasıl kuracağımı yazdım . Docker kullanıp kullanmadığınızı kontrol edin.