Wednesday, January 23, 2013

Fine Tune Nginx

Nginx is an open-source Web Server. It is a high-performance HTTP server that uses very low server resources, is reliable and integrates beautifully with Linux. In this article, I’ll talk about optimizing your nginx server for maximum performance.
A worker process is a single-threaded process. If Nginx is doing CPU-intensive work such as SSL or gzipping and you have 2 or more CPUs/cores, then you may set worker_processes to be equal to the number of CPUs or cores. Example, i’m running nginx on server has CPU is X3340 (4 cores) then i set worker_processes = 4. If you are serving a lot of static files and the total size of the files is bigger than the available memory, then you may increase worker_processes to fully utilize disk bandwidth.
This sets the number of connections that each worker can handle. You can determine the value by using ulimit -n command which output is something like 1024, then your worker connections would need to be set to 1024 or less but 1024 is a good default setting.
You can work out the maximum clients value by multiplying this and the worker_processes settings

max_clients = worker_processes * worker_connections

One of the most important things you need to tweak is the buffer sizes you allow Nginx to use. If the buffer sizes are set too low Nginx will have to store the responses from upstreams in a temporary file which causes both write and read IO, the more traffic you get the more of a problem this becomes. Edit and set the buffer size limitations for all clients as follows:

client_body_buffer_size 8K;

client_header_buffer_size 1k;

client_max_body_size 2m;

large_client_header_buffers 2 1k;


1. client_body_buffer_size: The directive specifies the client request body buffer size. If the request body is more than the buffer, then the entire request body or some part is written in a temporary file.

2. client_header_buffer_size: Directive sets the headerbuffer size for the request header from client. For the overwhelming majority of requests it is completely sufficient a buffer size of 1K.

3. client_max_body_size: Directive assigns the maximum accepted body size of client request, indicated by the line Content-Length in the header of request. If size is greater the given one, then the client gets the error “Request Entity Too Large” (413).

4. large_client_header_buffers: Directive assigns the maximum number and size of buffers for large headers to read from client request. The request line can not be bigger than the size of one buffer, if the client send a bigger header nginx returns error “Request URI too large” (414). The longest header line of request also must be not more than the size of one buffer, otherwise the client get the error “Bad request” (400).

You also need to control timeouts to improve server performance and cut clients. Edit it as follows:

client_body_timeout   10;

client_header_timeout 10;

keepalive_timeout     15;

send_timeout          10;


1. client_body_timeout: Directive sets the read timeout for the request body from client. The timeout is set only if a body is not get in one readstep. If after this time the client send nothing, nginx returns error “Request time out” (408).

2. client_header_timeout: Directive assigns timeout with reading of the title of the request of client. The timeout is set only if a header is not get in one readstep. If after this time the client send nothing, nginx returns error “Request time out” (408).

3. keepalive_timeout: The first parameter assigns the timeout for keep-alive connections with the client. The server will close connections after this time. The optional second parameter assigns the time value in the header Keep-Alive: timeout=time of the response. This header can convince some browsers to close the connection, so that the server does not have to. Without this parameter, nginx does not send a Keep-Alive header (though this is not what makes a connection “keep-alive”).

4. send_timeout: Directive assigns response timeout to client. Timeout is established not on entire transfer of answer, but only between two operations of reading, if after this time client will take nothing, then nginx is shutting down the connection.

access_log off;

Gzip compress content before it is delivered to the client. It’s a simple and effective way to speed up your site.

gzip             on;
gzip_comp_level  2;
gzip_min_length  1000;
gzip_proxied     expired no-cache no-store private auth;
gzip_types       text/plain application/xml;
gzip_disable     "MSIE [1-6]\.";
Caching static files

80% of the end-user response time is spent on the front-end. Most of this time is tied up in downloading all the components in the page: images, stylesheets, scripts, Flash, etc. Reducing the number of components in turn reduces the number of HTTP requests required to render the page. Example, i’m using the following configuration to cache static files on nginx

location ~* "\.(js|ico|gif|jpg|png|css|html|htm|swf|htc|xml|bmp|cur)$" {
root /home/site/public_html;
        add_header Pragma "public";
        add_header Cache-Control "public";
expires     3M;
        access_log  off;
log_not_found off;

KeepAlive allows multiple requests to be sent over the same TCP/IP connection. Turning it on can greatly improve the speed of your server, particularly when you have static pages and are serving quite a bit of images from your server. An example would be a catalogue site with screenshots. From my experience it is best to keep it On.
keepalive_timeout in nginx has default is very high. I recommend change it to 10-20.

keepalive_timeout 15
Make best nginx configuration

To make best nginx configuration, you should visit to

1 comment:

Anonymous said...

I don't even know how I stopped up right here, but I assumed this post was once great. I do not recognize who you might be but certainly you are going to a well-known blogger in case you are not already. Cheers!
Here is my page ; Superyacht Charter ecommerce specialist