Menskalakan Aplikasi Node.js dengan NGINX dan Pengimbangan Beban

Apabila aplikasi Node.js anda berkembang dan menerima lebih banyak trafik, penskalaan menjadi penting untuk mengekalkan prestasi dan kestabilan. Dalam artikel ini, kami akan menyelami teknik dan alatan utama yang membantu menskalakan aplikasi Node.js anda, memfokuskan pada NGINX sebagai proksi terbalik dan pengimbang beban, serta kaedah lain untuk mengendalikan trafik dan permintaan yang tinggi.

Dalam artikel ini, kami akan membincangkan:

1. Apakah NGINX dan mengapa ia penting?
2. Menyediakan NGINX sebagai proksi terbalik untuk Node.js.
3. Imbangan beban dengan NGINX.
4. Caching kandungan statik dengan NGINX.
5. Strategi penskalaan untuk aplikasi Node.js.
6. Kes penggunaan dunia sebenar untuk penskalaan.

Apakah NGINX dan Mengapa Ia Penting?

NGINX ialah pelayan web berprestasi tinggi yang terkenal dengan keupayaannya sebagai proksi terbalik, pengimbang beban dan cache HTTP. Ia mengendalikan volum besar sambungan serentak dengan cekap, menjadikannya alat yang sangat baik untuk menskalakan aplikasi Node.js.

Ciri-ciri Utama NGINX:

• Proksi Songsang: Ia mengarahkan permintaan pelanggan masuk ke pelayan akhir, membantu mengagihkan beban merentas berbilang pelayan.
• Pengimbangan Beban: NGINX mengimbangi trafik masuk merentas berbilang kejadian pelayan, memastikan tiada pelayan tunggal yang terharu.
• Caching: Ia menyimpan cache kandungan statik seperti imej, helaian gaya dan skrip, mengurangkan keperluan untuk menjana respons yang sama berulang kali.

Menyediakan NGINX sebagai Proksi Songsang untuk Node.js

Satu proksi terbalik mengarahkan permintaan pelanggan ke satu atau lebih pelayan bahagian belakang. Menggunakan NGINX sebagai proksi terbalik untuk aplikasi Node.js anda boleh memunggah tugas seperti penamatan SSL, caching dan pengimbangan beban daripada aplikasi anda.

Persediaan Langkah demi Langkah:

1. Pasang NGINX:
   Mula-mula, pasang NGINX pada pelayan anda. Di Ubuntu, ini boleh dilakukan menggunakan:

   sudo apt update
   sudo apt install nginx
   

2. Konfigurasikan NGINX:
   Cipta fail konfigurasi baharu untuk apl Node.js anda dalam direktori /etc/nginx/sites-available/.

Berikut ialah contoh fail konfigurasi:

   server {
       listen 80;
       server_name yourdomain.com;

       location / {
           proxy_pass http://localhost:3000; # Your Node.js app
           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;
       }
   }

1. Dayakan Konfigurasi:
   Buat pautan simbolik daripada tapak-tersedia kepada tapak-didayakan untuk mendayakan konfigurasi:

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

2. Mulakan semula NGINX:
   Mulakan semula NGINX untuk menggunakan perubahan:

   sudo systemctl restart nginx
   

Kini, NGINX akan memajukan sebarang permintaan masuk ke aplikasi Node.js anda yang dijalankan pada port 3000. Persediaan proksi terbalik memastikan apl Node.js anda diasingkan daripada akses pelanggan langsung, menambahkan lapisan keselamatan.

Pengimbangan Beban dengan NGINX

Apabila trafik meningkat, satu contoh Node.js mungkin bergelut untuk mengendalikan semua permintaan masuk. Pengimbangan beban membolehkan trafik diagihkan secara sama rata merentas berbilang contoh aplikasi anda, meningkatkan kebolehpercayaan dan prestasi.

Persediaan Pengimbang Beban NGINX:

1. Ubah suai Konfigurasi NGINX: Dalam fail konfigurasi NGINX, tentukan pelayan bahagian belakang yang NGINX akan mengimbangi permintaan merentas: ```nginx apl node huluan { pelayan localhost:3000; pelayan localhost:3001; pelayan localhost:3002; }

pelayan {
dengar 80;
server_name yourdomain.com;

   location / {
       proxy_pass http://node_app;
       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;
   }

}

2. **Explanation**:
   - The `upstream` block defines a pool of Node.js servers running on different ports.
   - NGINX will distribute incoming requests evenly among these servers.

3. **Load Balancing Algorithms**:
   By default, NGINX uses a round-robin algorithm to balance traffic. You can specify other load balancing methods such as:
   - **Least Connections**: Sends requests to the server with the fewest active connections.
     ```nginx
     upstream node_app {
         least_conn;
         server localhost:3000;
         server localhost:3001;
     }
     ```

4. **Test and Scale**:
   You can now test the setup by running multiple instances of your Node.js app on different ports (3000, 3001, 3002, etc.) and monitor how NGINX balances the traffic.

## Caching Static Content with NGINX
Caching static content such as images, CSS, and JavaScript files can significantly reduce the load on your Node.js application by serving cached versions of these assets directly from NGINX.

### Caching Setup in NGINX:
1. **Modify Configuration for Caching**:
   Add caching rules to your server block:
   ```nginx
   server {
       listen 80;
       server_name yourdomain.com;

       location / {
           proxy_pass http://localhost:3000;
           proxy_set_header Host $host;
           proxy_cache_bypass $http_upgrade;
       }

       # Caching static content
       location ~* \.(jpg|jpeg|png|gif|ico|css|js)$ {
           expires 30d;
           add_header Cache-Control "public, no-transform";
       }
   }

1. Penjelasan:
   • Tamat tempoh 30h; arahan memberitahu NGINX untuk cache fail statik selama 30 hari.
   • Ini meningkatkan dengan ketara masa tindak balas untuk aset ini kerana ia disampaikan terus daripada NGINX tanpa menyentuh aplikasi Node.js.

Strategi Penskalaan untuk Aplikasi Node.js

Menskalakan aplikasi Node.js bukan sekadar menggunakan NGINX. Di bawah ialah beberapa lagi teknik untuk memastikan aplikasi anda berskala dengan berkesan:

Penskalaan Menegak

Penskalaan menegak bermaksud menaik taraf sumber perkakasan pelayan, seperti menambah bilangan CPU atau menambah lebih banyak memori. Walaupun ini boleh meningkatkan prestasi dalam jangka pendek, ia terhad oleh keupayaan fizikal mesin.

Penskalaan Mendatar

Penskalaan mendatar melibatkan menjalankan berbilang kejadian aplikasi anda merentas pelayan yang berbeza dan mengimbangi trafik antaranya menggunakan alatan seperti NGINX atau pengimbang beban awan. Kaedah ini membenarkan penskalaan hampir tanpa had dengan menambahkan lebih banyak kejadian.

Clustering in Node.js

Node.js can run on multiple cores by using the built-in cluster module. This allows you to utilize all the available CPU cores on a server, increasing throughput.

Example:

const cluster = require('cluster');
const http = require('http');
const os = require('os');

if (cluster.isMaster) {
    const numCPUs = os.cpus().length;

    // Fork workers.
    for (let i = 0; i < numCPUs; i++) {
        cluster.fork();
    }

    cluster.on('exit', (worker, code, signal) => {
        console.log(`Worker ${worker.process.pid} died`);
    });
} else {
    // Workers can share any TCP connection
    http.createServer((req, res) => {
        res.writeHead(200);
        res.end('Hello, world!\n');
    }).listen(8000);
}

This example shows how to use all CPU cores available on a machine by forking worker processes.

Real-World Use Case: Scaling an E-commerce Website

Problem: An e-commerce website is experiencing high traffic during sales events, leading to slow response times and occasional server crashes.

Solution:

• Use NGINX to distribute traffic across multiple Node.js servers running different instances of the application.
• Cache static assets like product images and JavaScript files with NGINX to reduce load on the server.
• Implement Node.js Clustering to fully utilize the server’s CPU resources.

Outcome: The e-commerce website can now handle thousands of concurrent users without slowdowns, ensuring a smooth user experience during peak traffic times.

Why SSL, Encryption, and Security Matter?

When scaling applications, security should not be overlooked. Implementing SSL (Secure Sockets Layer) ensures that data transmitted between the client and server is encrypted and protected from attacks.

Steps to Enable SSL:

1. Obtain an SSL Certificate from a trusted Certificate Authority (CA) like Let's Encrypt.

2. Configure NGINX to use SSL:

   server {
      listen 443 ssl;
      server_name yourdomain.com;
   
      ssl_certificate /etc/ssl/certs/yourdomain.crt;
      ssl_certificate_key /etc/ssl/private/yourdomain.key;
   
      location / {
          proxy_pass http://localhost:3000;
      }
   }
   

3. Redirect HTTP to HTTPS to ensure all traffic is secure:

   server {
      listen 80;
      server_name yourdomain.com;
      return 301 https://$host$request_uri;
   }
   

Conclusion

Scaling a Node.js application is essential as traffic and demand grow. By utilizing NGINX as a reverse proxy and load balancer, you can distribute traffic effectively, cache static assets, and ensure high availability. Combining these techniques with horizontal scaling and Node.js clustering enables your applications to handle massive traffic loads while maintaining performance and stability.

Implement these strategies in your projects to achieve better scalability, improved user experience, and increased uptime.

Atas ialah kandungan terperinci Menskalakan Aplikasi Node.js dengan NGINX dan Pengimbangan Beban. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!