NGINX with Node.js: Load Balancing, Serving Static Content, and SSL

NGINX is a powerful and versatile web server that plays a critical role in scaling Node.js applications. It is commonly used as a reverse proxy to handle load balancing, serve static content, and manage SSL termination. In this article, we’ll explore how to use NGINX in conjunction with Node.js, explaining how each of these functions works with practical examples.

Why Use NGINX with Node.js?

While Node.js excels at building scalable, event-driven applications, it may not be the most efficient way to handle tasks like load balancing, serving static content, or SSL termination. This is where NGINX comes in. NGINX is optimized for handling a large number of concurrent connections efficiently, making it the perfect companion for Node.js applications that need to scale.

Key Benefits of Using NGINX with Node.js:

1. Load Balancing: NGINX can distribute traffic across multiple Node.js instances, ensuring no single server is overwhelmed.
2. Serving Static Content: It efficiently serves static files (e.g., CSS, JS, images), freeing Node.js to focus on dynamic content.
3. SSL Termination: NGINX handles SSL/TLS encryption and decryption, reducing the load on Node.js.

1. Load Balancing with NGINX

When scaling horizontally, you’ll need to run multiple instances of your Node.js application. NGINX can distribute incoming traffic across these instances, ensuring an even load.

Step 1: Install NGINX

On an Ubuntu system, you can install NGINX with the following command:

sudo apt update
sudo apt install nginx

Step 2: NGINX Configuration for Load Balancing

The nginx.conf file is where you define how NGINX handles incoming requests. Here’s how you can set up NGINX to load balance across three Node.js instances.

http {
    upstream node_app {
        server 127.0.0.1:3000;
        server 127.0.0.1:3001;
        server 127.0.0.1:3002;
    }

    server {
        listen 80;

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

Explanation:

• The upstream block defines the pool of Node.js instances that NGINX will balance traffic between.
• The proxy_pass directive forwards requests to one of the Node.js instances.

Step 3: Start Multiple Node.js Instances

node app.js --port 3000 &
node app.js --port 3001 &
node app.js --port 3002 &

Step 4: Start NGINX

Once NGINX is configured, start it using:

sudo systemctl start nginx

Test the Setup:
Now, visiting your server’s IP address or domain should distribute requests among the three Node.js instances.

2. Serving Static Content with NGINX

Node.js applications often need to serve static files (like images, CSS, and JavaScript). NGINX is much more efficient at this task, as it is designed to handle large numbers of static file requests.

Step 1: NGINX Configuration for Static Files

Modify the nginx.conf file to define a location for static content.

server {
    listen 80;

    # Serve static content directly
    location /static/ {
        root /var/www/html;
    }

    # Proxy dynamic requests to Node.js
    location / {
        proxy_pass http://localhost:3000;
        proxy_set_header Host $host;
        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;
    }
}

Explanation:

• The location /static/ block tells NGINX to serve files from /var/www/html/static/ when requests are made to /static/.
• Other requests are proxied to the Node.js application.

Step 2: Move Static Files

Move your static files (e.g., images, CSS, JavaScript) to the /var/www/html/static/ directory.

sudo mkdir -p /var/www/html/static
sudo cp -r path/to/static/files/* /var/www/html/static/

Now, requests for /static resources will be handled directly by NGINX, improving the performance of your Node.js server.

3. SSL Termination with NGINX

SSL (Secure Sockets Layer) is critical for securing communication between your users and your application. NGINX can offload SSL termination, encrypting and decrypting requests, so your Node.js application doesn’t need to handle SSL itself.

Step 1: Obtain an SSL Certificate

You can obtain an SSL certificate for free using Let’s Encrypt:

sudo apt install certbot python3-certbot-nginx
sudo certbot --nginx -d yourdomain.com

Step 2: NGINX SSL Configuration

Once the SSL certificate is issued, you can configure NGINX to handle SSL traffic.

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

server {
    listen 443 ssl;
    server_name yourdomain.com;

    ssl_certificate /etc/letsencrypt/live/yourdomain.com/fullchain.pem;
    ssl_certificate_key /etc/letsencrypt/live/yourdomain.com/privkey.pem;

    location / {
        proxy_pass http://localhost:3000;
        proxy_set_header Host $host;
        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;
    }
}

Explanation:

• The first server block redirects all HTTP traffic to HTTPS.
• The second block listens on port 443 (HTTPS), handling SSL encryption with the certificate issued by Let’s Encrypt.

Step 3: Test SSL Setup

Visit your domain (e.g., https://yourdomain.com), and your Node.js app should now be served over HTTPS.

Additional NGINX Configurations for Optimizing Node.js

1. Handling Timeouts

To prevent long-running requests from being prematurely closed, configure NGINX’s timeout settings.

server {
    proxy_read_timeout 90s;
    proxy_send_timeout 90s;
    send_timeout 90s;
}

2. Rate Limiting

Rate limiting can help prevent abuse and manage high traffic by limiting the number of requests a user can make in a given time.

http {
    limit_req_zone $binary_remote_addr zone=mylimit:10m rate=1r/s;

    server {
        location / {
            limit_req zone=mylimit burst=5;
            proxy_pass http://localhost:3000;
        }
    }
}

Explanation:

• The limit_req_zone directive defines a rate limit of 1 request per second.
• The burst parameter allows a small number of requests to exceed the limit before throttling kicks in.

Conclusion

NGINX is a powerful tool that can significantly enhance the performance, security, and scalability of your Node.js applications. By offloading tasks such as load balancing, serving static content, and handling SSL termination to NGINX, your Node.js server can focus on what it does best: processing dynamic content and handling real-time events.

The above is the detailed content of NGINX with Node.js: Load Balancing, Serving Static Content, and SSL. For more information, please follow other related articles on the PHP Chinese website!