Nginx Server Performance Tuning: Best Practices and Techniques

10 min read

Cover Image for Nginx Server Performance Tuning: Best Practices and Techniques

Nginx is a robust proxy server for load balancing, caching, reverse proxying, and web serving. It is an open source, lightweight, and high performance web server with advanced HTTP capabilities. Nginx also handles logging, serving static files, and blacklisting.

Like other web servers, Nginx plays a key role in distributing traffic and delivering content to end users. Therefore, it requires proper configuration in order to be fully secure. This article discusses 12 of the best practices for fine tuning your Nginx Server. Read on!

1. Optimize Worker Processes and Connections

You can optimize Nginx for high performance by appropriately configuring worker processes and connections. Nginx has one master and multiple worker processes, whereby the master process reads and evaluates the configurations and evaluate master worker processes. The main task of the worker processes is to handle the requests.

You should match the number of worker processes with the number of CPU cores on your server. This allows you to maximize the server's computational capacity. Also, you should adjust worker connections based on the magnitude of expected traffic.

The default Nginx settings doesn’t allow it to handle multiple multiple workloads. To change this configuration, you can use the “worker_processes” parameter. Here is an example:

worker_processes 10;

This tells Nginx to use 12 worker processes. The goal is to optimize the server performance by adjusting number of processes based on server resources. If you don’t know the amount of CPU core available in your system, you should set the worker processes to auto:

worker_processes auto;

In this case, Nginx will automatically detect the available number of CPU cores.

2. Enable Keepalive Connections

Keepalive connections help you optimize Nginx performance as you allow the same TCP connection to send and receive multiple HTTP requests and responses. In turn, this reduces the latency associated with establishing new connections. Keepalive optimizes server resources, as maintaining an active connection consumes fewer resources than frequently setting up new ones.

After an HTTP transaction, keepalive connections maintain the TCP connection between the client and the server alive, hence reducing latency. You can enable keepalive connection through the 'keepalive_timeout' parameter. Here, you specify the time in seconds that the server will keep the connection open. Also, you should adjust the timeline based on server load and specific use case.

It’s important to consider that enabling keepalive connections increases server connections. The connections remain active for the set timeline even when transactions are completed. While Nginx has an event-driven architecture to handle a large number of connections, having excess idle connections can consume extra system resources.

3. Enable Gzip Compression

Gzip is a data compression tool that compresses files that Nginx serves on the fly. These files are then decompressed by the client’s browsers upon retrieval. By enabling Gzip compression in Nginx, you minimize the size of data that your server sends to clients. This process results in smaller data transfer between the server and the browser, effectively minimizing latency and improving site loading speeds. With all major browsers supporting gzip compression, it’s an effective standard for accelerating web performance.

The default setting of Nginx compresses only 'text/html' MIME type responses. However, you can use the gzip_types directive can be used to list and compress other MIME types. The compression directives to use include:

  • gzip_min_length- specifies the minimum length to compress i.e gzip_min_length 500; adjust the length from 20 bytes (default) to 500 bytes.

  • gzip_types - specifies the type of files of MIME types to compress i.e gzip_types text/plain application/xml - this instructs Nginx to apply compression on plain text files (with MIME type text/plain)

  • gzip_proxied - allows you to control the compression of responses to proxied requests. Basically, it allows you to define the circumstances under which Nginx should compress responses sent to requests from proxy servers. It access several parameters such as off, expired, no-cache, no-store, private, any auth, etc.

However, it’s crucial to note that not all file types are suitable for compression. Certain files, such as text files, compress remarkably well - often reducing to over half their original size. Conversely, image files like JPEGs or PNGs, which are naturally compressed, derive little benefit from additional gzip compression. Because compression uses server resources, it's generally advised to only compress files that will yield a significant size reduction, ensuring the optimal utilization of resources.

4. Avoid Unnecessary Modules

Modules extend the functionality of Nginx, but each additional module consumes system resources. You should only install necessary modules and disable any that aren't required. This reduces the memory footprint of Nginx, leading to faster response times. Remember, a lean, streamlined server configuration is the key to optimal performance.

5. Use GeoIP Module for Geolocation

The GeoIP module in Nginx enables geolocation capabilities. It allows you to determine the geographical location of your website's visitors based on their IP address. This information helps provide location-specific content, as well as routing traffic more efficiently. For instance, with this module, you could direct users to the server nearest to them geographically, reducing latency and improving overall website performance.

The GeoIP module, however, adds an extra layer of processing to each request that Nginx handles. While it provides personalized content and efficient routing, it can potentially impact on server performance. Therefore, you should be careful when configuring the server and also monitor its performance when using the GeoIP module. This ensures that the module provides the needed benefits without compromising server efficiency.

6. Fine-Tune Buffer Size Parameters

Buffer sizes in Nginx control the amount of data the server will handle at once while processing requests and responses. Properly configured buffers can significantly improve server performance. For instance, setting a larger buffer size for serving large files can allow Nginx to read larger chunks of data at once, reducing the number of read operations and improving disk I/O. Conversely, reducing the buffer size can be beneficial when dealing with many small files or in memory-limited environments to save memory resources.

When fine-tuning buffer sizes, you should consider the type of content being served as well as hardware capabilities. For instance, a server with large files can benefit from large buffer sizes. On the other hand, a server with limited memory may require small buffer sizes.

7. Optimize Client Body and Header Buffer Size

The client body buffer size in Nginx defines the maximum amount of data Nginx will read from the client in a single reading operation when the client sends data. This is often used in scenarios where clients upload files to the server. When you optimize this value based on the average size of client uploads, you streamline the reading process, which in turn improves server performance.

The client header buffer size defines the maximum size of the client request header. If the size of the request header is more than the set value, Nginx allocates an additional buffer to store the large headers. Optimizing this value can improve memory usage and ensure efficient processing of client requests.

8. Use Nginx as a Reverse Proxy

Using Nginx as a reverse proxy can significantly boost your web server performance. A reverse proxy accepts client requests, forwards them to appropriate servers, and then delivers the server’s response back to the client. This setup adds a layer of control, allowing you to distribute load, ensure smooth traffic flow, and add an extra layer of security.

9. Use FastCGI Caching for Dynamic Content

FastCGI caching in Nginx allows the server to cache the responses from FastCGI servers, which are often used for serving dynamic content. With FastCGI caching enabled, Nginx can store the output of your applications' responses and serve them directly from the cache for future identical requests. This reduces the load on your application servers since they no longer need to process the same requests multiple times, and significantly improves response times.

However, using FastCGI caching requires careful management to ensure that the content served is still relevant and fresh. This is particularly important for dynamic content that may change frequently. Proper configuration of cache expiration values and cache invalidation mechanisms are critical when using FastCGI caching to ensure that users receive the most up-to-date content.

10. Enable OCSP Stapling

Online Certificate Status Protocol (OCSP) stapling is a method that improves SSL connections. This method checks if an SSL certificate is valid or revoked without requiring the client to make a separate request to the Certificate Authority. This reduces the amount of taken for SSL handshake processes, hence improving overall server performance. When you enable OCSP, Nginx retrieves the OCSP response and then delivers it to clients during SSL/TLS handshakes.

Implementing OCSP stapling on your Nginx server also improves security. By verifying the SSL certificate, it also provides protection from a variety of attacks such as man-in-the-middle attacks.

11. Limit Large Requests and Timeouts

Limiting the size of client requests protects your Nginx server from being overwhelmed by extremely large requests. This prevents potential outages and maintains server performance. It ensures the server has plenty of resources to handle all incoming requests efficiently. Similarly, limiting timeouts ensures that a single slow client does not consume server resources that could benefit other clients.

Configuring these requests appropriately limits requires you to first understand your server capacity as well as client behavior. When you set the request size too low, it can result in legitimate client requests being denied. Also, leaving request size too high could leave your server vulnerable to DDoS attacks.

12. Configure Open File Cache

Nginx's open file cache stores information about open files, directories, and other file-like objects. This cache reduces the need for repetitive file system operations, hence improving Nginx performance as it reduces latency that comes with those operations. You can fine tune several parameters for the open file cache, such as expiration time and cache size to optimize performance based on your workload and server capacity.

Fine-tuning the open file cache requires you to find a balance between cache size and data freshness. When the cache is large, you have fewer file system operations. However, it also consumes more memory. The cache expiration time determines how often the cache is refreshed. A shorter expiration time ensures data is upto data, which also means more frequent file system operations. Therefore, you should configure the open file cache in a way that suits your specific server.

13. Always Monitor Your Nginx Server

When using a Nginx server, it’s always essential to monitor it in real time. Real time monitoring helps maintain server performance, high availability, and security. There are numerous metrics that affect how the Nginx performance, such as memory, CPU, disk saturation, disk I/O, and request throughput. Nginx monitoring involves collecting and analyzing crucial metrics related to the server's performance.

  • Requests Per Second (RPS) -Measures server throughput

  • Response Time - measures how long it takes to serve each request

  • Active Connections - Represents the number of current connections served by NGINX

  • Connection Backlogs - Shows the connection requests in a queue waiting to be served

  • Server Errors - These are server status codes indicating errors on the server or client-side

  • Dropped Connections - These are connections dropped due to full backlogs or maximum active connections

  • Available Upstream: Indicates the number of upstream servers available to serve requests

  • Active Upstream Connections: Represents active connections with upstream servers. Changes in this metric can suggest connection issues.

  • Upstream Errors: Alerts to errors from upstream servers

Other system metrics include load average, disk I/O, memory, storage, and network I/O.

To effectively monitor NGINX, you have to utilize various server monitoring tools depending on your specific needs and requirements. Some of the leading solutions in this field include Datadog, New Relic, Sematext, Solarwinds, and Dynatrace. These tools provide real-time insights and historical data on NGINX performance, allowing for proactive troubleshooting and performance optimization.

14. Log Only Necessary Information

Collecting Nginx logs is essential for troubleshooting and finding cause for errors. However, collecting too many logs can slow down your server. It's therefore crucial to log only the necessary information you need. When you reduce the logged data, you speed up your server. Also, it makes it easier to find log data whenever you need it. Besides, you can also consider offloading logs to external storage to free up your server to perform its main tasks.

15. Use the Latest Version of Nginx

It’s always crucial to update your Nginx server to the latest version. When a new version is released, it comes with important performance improvements, bug fixes, and security patches. Regular updates provide access to the newest features while improving server security and performance. However, it’s crucial to plan how you roll out upgrades to avoid server downtime.