NGINX and Web Hosting: Serving Files and Managing Traffic

NGINX can be used to serve files and manage traffic. 1) Configure NGINX service static files: define the listening port and file directory. 2) Implement load balancing and traffic management: Use upstream module and cache policies to optimize performance.

introduction

In the modern Internet world, NGINX has become an indispensable tool, especially in web hosting and traffic management. Today we will dive into how to use NGINX to serve files and manage traffic. With this article, you will learn how to configure NGINX to efficiently handle static files, dynamic content, and how to optimize your server to cope with high traffic.

Review of basic knowledge

NGINX is a high-performance HTTP and reverse proxy server that is commonly used to host websites and applications. It is known for its efficiency, stability and scalability. The configuration file of NGINX is usually nginx.conf , through which we can define the behavior of the server.

In web hosting, NGINX can serve static files, such as HTML, CSS, JavaScript, pictures, etc., and can also serve as a reverse proxy to forward requests to back-end application servers, such as Node.js, Django, etc.

Core concept or function analysis

NGINX's file service function

NGINX's file service feature is one of its core, which allows you to serve static files directly from the server. In a configuration file, you can define which files should be served and how to serve them.

 http {
    server {
        listen 80;
        server_name example.com;

        location / {
            root /usr/share/nginx/html;
            index index.html index.htm;
        }
    }
}

This configuration tells NGINX to listen to port 80, when the request arrives, look up files from the /usr/share/nginx/html directory, and provide index.html or index.htm by default.

Traffic management of NGINX

NGINX can not only serve files, but also manage traffic. Through configuration, you can realize load balancing, caching, current limiting and other functions.

 http {
    upstream backend {
        server backend1.example.com;
        server backend2.example.com;
    }

    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 configuration implements load balancing and distributes requests to two backend servers.

How it works

NGINX works based on event-driven and asynchronous non-blocking I/O models. This means that NGINX can efficiently handle a large number of concurrent connections without blocking because of waiting for I/O operations. NGINX's configuration file is parsed into a series of instructions that define how requests and responses are processed.

In terms of file services, NGINX will decide how to handle requests based on location blocks in the configuration file. If the requested file exists, NGINX will read it directly from disk and send it to the client. If the file does not exist, NGINX will return an error page or redirect based on the configuration.

In terms of traffic management, NGINX can forward requests to different backend servers based on configuration. Through the upstream module, NGINX can achieve load balancing, ensuring that requests are distributed evenly to multiple servers.

Example of usage

Basic usage

Let's look at a simple example of how to configure NGINX to serve static files.

 http {
    server {
        listen 80;
        server_name example.com;

        location / {
            root /var/www/html;
            index index.html;
        }
    }
}

This configuration tells NGINX to listen to port 80 and serve files from the /var/www/html directory, and index.html is provided by default.

Advanced Usage

Now let's look at a more complex example of how to configure NGINX to achieve load balancing and caching.

 http {
    upstream backend {
        least_conn;
        server backend1.example.com;
        server backend2.example.com;
    }

    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;

            proxy_cache_valid 200 1h;
            proxy_cache_valid 404 1m;
            proxy_cache_bypass $http_cache_control;
            add_header X-Proxy-Cache $upstream_cache_status;
        }
    }
}

This configuration implements load balancing, using the least_conn algorithm to select the server with the least connection, and also configures a cache policy to cache the response of 200 status code for 1 hour and the response of 404 status code for 1 minute.

Common Errors and Debugging Tips

When using NGINX, common errors include configuration file syntax errors, permission issues, path errors, etc. Here are some debugging tips:

• Use nginx -t command to check configuration file syntax.
• Check out the error log for NGINX, usually located in /var/log/nginx/error.log .
• Make sure NGINX has permission to access the files and directories you configured.
• Use the browser's developer tools to view requests and responses to help diagnose problems.

Performance optimization and best practices

In practical applications, optimizing NGINX configuration can significantly improve performance. Here are some optimization suggestions:

• Use gzip to compress static files to reduce the amount of data transferred.
• Configure cache policies to reduce requests to the backend server.
• Use worker_processes and worker_connections to adjust the number of worker processes and connections to make full use of server resources.

 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 / {
            proxy_pass http://backend;
            proxy_set_header Host $host;
            proxy_set_header X-Real-IP $remote_addr;

            proxy_cache STATIC;
            proxy_cache_valid 200 1h;
            proxy_cache_valid 404 1m;
            proxy_cache_bypass $http_cache_control;
            add_header X-Proxy-Cache $upstream_cache_status;
        }
    }
}

This configuration enables gzip compression and caching policies, which significantly improves performance.

It is also important to keep the code readable and maintained when writing NGINX configurations. Use comments to explain complex configurations and organize configuration files reasonably to make them easy to understand and modify.

Through this article, you should have mastered how to use NGINX to serve files and manage traffic. NGINX is a powerful tool, mastering its configuration and optimization skills can help you build efficient and reliable web services.

The above is the detailed content of NGINX and Web Hosting: Serving Files and Managing Traffic. For more information, please follow other related articles on the PHP Chinese website!