Advanced Nginx Configuration: Mastering Server Blocks & Reverse Proxy

The advanced configuration of Nginx can be implemented through server blocks and reverse proxy: 1. Server blocks allow multiple websites to be run in one instance, each block is configured independently. 2. The reverse proxy forwards the request to the backend server to realize load balancing and cache acceleration.

introduction

In the ocean of the Internet, Nginx is undoubtedly the indestructible battleship. It is loved by developers and operation staff for its high performance and flexibility. However, how can we truly navigate this warship and achieve its maximum potential? This article will take you into the deeper discussion of Nginx's advanced configuration skills, especially the applications of Server Blocks and Reverse Proxy. By reading this article, you will learn how to configure Nginx in a refined way so that it can be easily eased in complex network environments.

The basic concept of Nginx

As a high-performance HTTP server and reverse proxy server, Nginx is its event-driven, asynchronous and non-blocking processing mechanism. This makes Nginx particularly good at handling high concurrent requests. Server Blocks is a key concept in Nginx configuration, which allows multiple server configurations to be defined in one Nginx instance, thereby implementing the virtual hosting function of a domain name or IP address. Reverse proxy is a technology that forwards client requests to the backend server through Nginx, which is often used for load balancing and cache acceleration.

For example, a simple Nginx configuration might look like this:

 http {
    server {
        listen 80;
        server_name example.com;
        location / {
            root /var/www/example.com;
            index index.html;
        }
    }
}

This code defines a server that listens to port 80, responds to requests for the example.com domain name, and points the root directory of the request to /var/www/example.com .

In-depth analysis of Server Blocks

Server blocks are the core part of Nginx configuration, which allows you to run multiple websites or services in the same Nginx instance. Each server block can independently configure the listening port, domain name, log file, etc. to achieve high flexibility.

Definition and function

The definition of a server block is very simple, but its function is very powerful. It allows you to run multiple websites or services in one Nginx instance, each with its own configuration without interfering with each other. This is a very useful feature for server administrators hosting multiple websites.

For example, you can define two different server blocks like this:

 http {
    server {
        listen 80;
        server_name example1.com;
        location / {
            root /var/www/example1.com;
            index index.html;
        }
    }

    server {
        listen 80;
        server_name example2.com;
        location / {
            root /var/www/example2.com;
            index index.html;
        }
    }
}

How it works

When Nginx receives a request, it first checks the request's Host header and then matches the appropriate server block according to the server_name directive. If no server block is matched, Nginx will use the default server block for processing. This needs special attention when configuring, as it can lead to unexpected behavior.

The essence of Reverse Proxy

Reverse proxy is another powerful feature of Nginx. It can forward client requests to the backend server, thereby realizing load balancing, cache acceleration and other functions.

Definition and function

The definition of a reverse proxy is to forward client requests to the backend server via Nginx. Its function is that it can hide the real IP address of the backend server, provide additional security, and also achieve load balancing and improve system reliability and performance.

For example, a simple reverse proxy configuration might look like this:

 http {
    upstream backend {
        server localhost:8080;
        server localhost:8081;
    }

    server {
        listen 80;
        server_name example.com;
        location / {
            proxy_pass http://backend;
            proxy_set_header Host $host;
            proxy_set_header X-Real-IP $remote_addr;
        }
    }
}

This code defines an upstream server group called backend , contains two backend servers, and then forwards all requests to this server group.

How it works

When Nginx acts as a reverse proxy, it receives requests from the client and then forwards the requests to the backend server based on configuration. Nginx can select back-end servers according to different load balancing algorithms (such as polling, minimal connection, etc.), thereby achieving efficient request distribution.

Example of usage

Basic usage

Let's start with a simple server block configuration:

 http {
    server {
        listen 80;
        server_name example.com;
        location / {
            root /var/www/example.com;
            index index.html;
        }
    }
}

This code defines a server that listens to port 80, responds to requests for the example.com domain name, and points the root directory of the request to /var/www/example.com .

Advanced Usage

Now let's look at a more complex configuration that combines server blocks and reverse proxy:

 http {
    upstream backend {
        server localhost:8080;
        server localhost:8081;
    }

    server {
        listen 80;
        server_name example.com;
        location / {
            proxy_pass http://backend;
            proxy_set_header Host $host;
            proxy_set_header X-Real-IP $remote_addr;
        }
    }

    server {
        listen 80;
        server_name api.example.com;
        location / {
            proxy_pass http://backend;
            proxy_set_header Host $host;
            proxy_set_header X-Real-IP $remote_addr;
        }
    }
}

This code defines two server blocks, one for example.com and the other for api.example.com. Both use the same backend server group backend , but can be configured differently as needed.

Common Errors and Debugging Tips

Common errors when configuring Nginx include:

• Configuration file syntax error: Use nginx -t command to check the syntax of the configuration file.
• Server block matching problem: Make sure your server_name is configured correctly, otherwise the request may be processed incorrectly.
• Reverse proxy configuration error: Make sure that proxy_pass directive points to the correct upstream server group and that the necessary header information is set.

Performance optimization and best practices

In practical applications, how to optimize Nginx configuration for optimal performance? Here are some suggestions:

• Using Cache: Nginx supports cache static content, which can significantly improve response speed.
• Adjust the number of worker processes: Adjust the worker_processes instruction according to the number of CPU cores of the server, which can improve concurrent processing capabilities.
• Enable Gzip compression: By enabling Gzip compression, you can reduce the amount of data transmitted and increase the transmission speed.

For example, the following is an optimized Nginx configuration example:

 http {
    gzip on;
    gzip_vary on;
    gzip_proxied any;
    gzip_comp_level 6;
    gzip_types text/plain text/css application/json application/javascript text/xml application/xml application/xml rss text/javascript;

    proxy_cache_path /var/cache/nginx levels=1:2 keys_zone=STATIC:10m inactive=24h max_size=1g;

    server {
        listen 80;
        server_name example.com;
        location / {
            root /var/www/example.com;
            index index.html;
            try_files $uri $uri/ =404;
        }

        location ~* \.(jpg|jpeg|png|gif|ico|css|js)$ {
            expires 1y;
            log_not_found off;
            add_header Cache-Control "public, no-transform";
            proxy_cache STATIC;
            proxy_cache_valid 200 1d;
            proxy_cache_use_stale error timeout invalid_header updating http_500 http_502 http_503 http_504;
        }
    }
}

This code enables Gzip compression, sets up static file caching, and adjusts cache policies to improve Nginx performance.

Summarize

Through this article, you should have mastered the essence of advanced Nginx configuration, especially the application of server blocks and reverse proxy. Whether you are a beginner or an experienced operation and maintenance person, these tips will help you better manage and optimize your Nginx servers. Remember, Nginx configuration is an art that requires constant practice and optimization to truly exert its powerful functions.

The above is the detailed content of Advanced Nginx Configuration: Mastering Server Blocks & Reverse Proxy. For more information, please follow other related articles on the PHP Chinese website!