{"id":521,"date":"2016-01-25T11:58:04","date_gmt":"2016-01-25T09:58:04","guid":{"rendered":"http:\/\/www.systemcodegeeks.com\/?p=521"},"modified":"2017-12-04T15:03:49","modified_gmt":"2017-12-04T13:03:49","slug":"nginx-and-apache","status":"publish","type":"post","link":"https:\/\/www.systemcodegeeks.com\/web-servers\/nginx\/nginx-and-apache\/","title":{"rendered":"Nginx and Apache (Ubuntu 12.04 LTS)"},"content":{"rendered":"

This article is part of our Academy Course titled Introduction to Nginx<\/a>.<\/p>\n

This course will introduce you to the magic of nginx. You will learn to install and configure nginx for a variety of software platforms and how to integrate it with Apache. Additionally, you will get involved with more advanced concepts like Load Balancing, SSL configuration and Websockets proxying. Check it out here<\/a>!<\/em>
\n 
\n 
\n 
\n 
\n 
\n[ulp id=’O5wwlXQPIiCQp2ED’]<\/p>\n

\n

Table Of Contents<\/h4>\n
\n
1. Introduction<\/a><\/dt>\n
2. Nginx as reverse proxy<\/a><\/dt>\n
3. Nginx proxy module<\/a><\/dt>\n
4. A note on variables<\/a><\/dt>\n
5. Configuring Apache<\/a><\/dt>\n
6. Configuring Nginx<\/a><\/dt>\n
7. Separating content<\/a><\/dt>\n
8. Download the configuration files<\/a><\/dt>\n<\/dl>\n<\/div>\n

<\/a>1. Introduction<\/h2>\n

Nginx and Apache can certainly work together, not necessarily replacing each other as our web server of choice. This solution offers many advantages and solves the issues that most system administrators are familiar with, such as slowdowns and complex configurations. You can just take a look at the Apache configuration file and chances are you\u2019ll probably agree with me!<\/p>\n

<\/a>2. Nginx as reverse proxy<\/h2>\n

A reverse proxy is a device or service placed between a client and a server in a network infrastructure. Incoming requests are handled by the proxy, which interacts on behalf of the client with the desired server or service residing on the server1. In this case, Nginx will act as reverse proxy between the client (your computer, for example) and Apache, the backend web server (see Fig. 1).<\/p>\n

\"nginx_reverse_proxy.png\"<\/a>
Figure 1: Nginx acting as reverse proxy<\/figcaption><\/figure>\n

In this above diagram, Nginx acts as reverse proxy (or in other words, as frontend server) and receives all requests from the outside world. At this point those requests can be filtered or \u201cdelivered\u201d to Apache (acting as HTTP client) in the backend. These two services can even be hosted in the same physical server with the caution to use different listening ports for each of them. This whole operation is handled by the proxy module of Nginx.<\/p>\n

The main purpose of setting up Nginx as a frontend server and giving Apache a simple backend role is to improve the serving speed, given the fact that great amount of requests coming from clients are for static files (html pages, cascading style sheets, regular images, and so on), and static files are served much faster by Nginx. The overall performance sharply improves both on the client side and server side.<\/p>\n

<\/a>3. Nginx proxy module<\/h2>\n

Fortunately, the proxy module is enabled by default during the installation of Nginx. The main directives of the module can be seen in Table 1.<\/p>\n

\n\n\n\n\n\n\n\n\n\n
Directive\/Context<\/strong><\/td>\nDescription<\/strong><\/td>\n<\/tr>\n
proxy_buffers<\/code>
\nContext: http, server,
\nlocation<\/code><\/td>\n		The request is sent to the backend server by specifying its location.
\nSyntax:
\nTCP sockets: proxy_pass<\/code> http:\/\/hostname:port;
\nUNIX domain sockets: proxy_pass<\/code> http:\/\/unix:\/path\/to\/file.socket;
\n(https can be used instead of http for secure traffic)
\nExamples:
\nproxy_pass<\/code> http:\/\/localhost:8080;
\nproxy_pass<\/code> http:\/\/127.0.0.1:8080;
\nproxy_pass<\/code> http:\/\/unix:\/tmp\/nginx.sock;<\/td>\n<\/tr>\n
proxy_method<\/code><\/code><\/td>\nAllows overriding the HTTP method of the request to be forwarded to the backend server.
\nSyntax: proxy_method method<\/code>;
\nExample: proxy_method POST;<\/code><\/td>\n<\/tr>\n
proxy_hide_header<\/code>
\nContext: http, server,
\nlocation<\/code><\/code><\/td>\n		By default, as Nginx prepares the response received from the backend server to be forwarded back to the client, it ignores some of the http headers4. With this directive, you can specify an additional header line to be hidden from the client. This directive can be inserted multiple times with one header name for each.
\nSyntax: proxy_hide_header header_name;<\/code>
\nExample: proxy_hide_header Cache-Control;<\/code><\/td>\n<\/tr>\n
proxy_pass_header<\/code>
\nContext: http, server,
\nlocation<\/code><\/code><\/td>\n		Forces some of the ignored headers to be passed on to the client.
\nSyntax: proxy_pass_header header_name;<\/code>
\nExample: proxy_pass_header Date;<\/code><\/td>\n<\/tr>\n
proxy_pass_request_body<\/code>
\nproxy_pass_request_headers<\/code>
\nContext: http, server, location<\/code><\/td>\n		Defines whether or not, respectively, the request body and extra request headers should be passed on to the backend server.
\nSyntax: on<\/code> or off<\/code>;<\/td>\n<\/tr>\n
proxy_redirect<\/code>
\nContext: http, server,
\nlocation<\/code><\/td>\n		Allows you to rewrite the URL appearing in the Location HTTP header on redirections triggered by the backend server.
\nSyntax: off<\/code>, default<\/code>, or the URL<\/code> of your choice
\noff<\/code>: Redirections are forwarded as it is.
\ndefault<\/code>: The value of the proxy_pass<\/code> directive is used as the hostname and the current path of the document is appended.
\nNote that the proxy_redirect<\/code> directive must be inserted after the proxy_pass<\/code> directive as the configuration is parsed sequentially.
\nURL<\/code>: Replace a part of the URL by another.
\nAdditionally, you may use variables in the rewritten URL.
\nExamples:
\nproxy_redirect off;<\/code>
\nproxy_redirect default;<\/code>
\nproxy_redirect<\/code> http:\/\/localhost:8080\/ http:\/\/mysite.com\/;<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n

Table 1: Main directives of the proxy module<\/p>\n<\/div>\n

The best scenario is to limit to the extent possible the number of requests that are forwarded to the backend server. To that end, the proxy module comes with a group of directives that will help us build a caching system as well as control buffering options and the way Nginx deals with temporary files (see Table 2 for more information on most of these directives).<\/p>\n

\n\n\n\n\n\n\n\n\n\n
Directive\/Context<\/strong><\/td>\nDescription<\/strong><\/td>\n<\/tr>\n
proxy_pass<\/code>
\nContext: location, if<\/code><\/td>\n		Sets the amount and size of buffers that will be used for reading the response data from the backend server. If the buffers aren\u2019t large enough the data will be saved to disk before being served to the user.
\nSyntax: proxy_buffers amount size;<\/code>
\nDefault: 8 buffers, 4k or 8k each depending on platform
\nExample: proxy_buffers 8 4k;<\/code><\/td>\n<\/tr>\n
proxy_method<\/code><\/td>\nSets the size of the buffer for reading the beginning of the response from the backend server, which usually contains simple header data.
\nSyntax: Numeric value (size)
\nExample:
\nproxy_buffer_size 4k;<\/code><\/td>\n<\/tr>\n
proxy_cache_key<\/code>
\nContext: http, server,
\nlocation<\/code><\/td>\n		This directive defines the cache key, in other words, it differentiates one cache entry from another.
\nSyntax: proxy_cache_key key;<\/code>
\nExample: proxy_cache_key \"$scheme$host$request_
\nuri $cookie_user\";<\/code>
\nNote: strings beginning with \u201c$\u201d (dollar sign) are variables. The proxy module offers 4 built-in variables; others can be created at the user\u2019s will.<\/td>\n<\/tr>\n
proxy_cache<\/code>
\nContext: http, server,
\nlocation<\/code><\/td>\n		Defines a shared memory zone used for caching. The same zone can be used in several places. The off parameter disables caching inherited from the previous configuration level.
\nSyntax:
\nproxy_cache zone | off;<\/code>
\nDefault:
\nproxy_cache off;<\/code><\/td>\n<\/tr>\n
proxy_cache_path<\/code>
\nContext: http<\/code><\/td>\n		Sets the path and other parameters of a cache. Cache data are stored in files. Both the key and file name in a cache are a result of applying the MD5 function to the proxied URL. The levels parameter defines hierarchy levels of a cache.
\nSyntax: proxy_cache_path path [levels=levels] keys_zone=name:size [inactive=time] [max_size=size] [loader_files=number] [loader_sleep=time] [loader_threshold=time];<\/code>
\n[Optional parameters are indicated inside square brackets]
\nExample: proxy_cache_path \/tmp\/nginx_cache
\nlevels=1:2 zone=zone1:10m inactive=10m max_
\nsize=200M;<\/code><\/td>\n<\/tr>\n
proxy_cache_min_uses<\/code>
\nContext: http, server,
\nlocation<\/code><\/td>\n		Defines the minimum amount of hits before a request is eligible for caching. By default, the response of a request is cached after one hit (next requests with the same cache key will receive the cached response).
\nSyntax: Numeric value
\nExample: proxy_cache_min_uses 1;<\/code><\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n

Table 2: Some caching \/ buffering directives<\/p>\n<\/div>\n

There are even more directives that let you define the behavior of Nginx in the case of timeouts or other limitations regarding communications with the backend server (see Table 3):<\/p>\n

\n\n\n\n\n\n\n\n
Directive\/Context<\/strong><\/td>\nDescription<\/strong><\/td>\n<\/tr>\n
proxy_connect_timeout<\/code>
\nContext: http, server,
\nlocation<\/code><\/td>\n		Defines the backend server connection timeout. This is different from the read\/send timeout. If Nginx is already connected to the backend server, the proxy_connect_ timeout is not applicable. It should be noted that this timeout cannot usually exceed 75 seconds.
\nSyntax: Time value (in seconds)
\nExample: proxy_connect_timeout 15;<\/code><\/td>\n<\/tr>\n
proxy_read_timeout<\/code>
\nContext: http, server,
\nlocation<\/code><\/td>\n		Defines a timeout for reading a response from the proxied server. A timeout is set only between two successive read operations, not for the transmission of the whole response. If a proxied server does not transmit anything within this time, a connection is closed.
\nSyntax: Time value (in seconds)
\nDefault value: 60
\nExample: proxy_read_timeout 60;<\/code><\/td>\n<\/tr>\n
proxy_send_timeout<\/code>
\nContext: http, server,
\nlocation<\/code><\/td>\n		This timeout is for sending data to the backend server. The timeout isn’t applied to the entire response delay but between two write operations instead.
\nSyntax: Time value (in seconds)
\nDefault value: 60
\nExample: proxy_send_timeout 60;<\/code><\/td>\n<\/tr>\n
proxy_ignore_client_abort<\/code>
\nContext: http, server,
\nlocation<\/code><\/td>\n		Determines whether the connection with a proxied server should be closed when a client closes a connection without waiting for a response. If set to on, Nginx will continue processing the proxy request, even if the client aborts its request. In the other case (off), when the client aborts its request, Nginx also aborts its request to the backend server.
\nDefault value: off<\/code><\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n

Table 3: Some directives regarding communications with the backend server (Apache)<\/p>\n<\/div>\n

<\/a>4. A note on variables<\/h2>\n

The proxy module comes with the following variables that can be used as arguments for the directives listed above:<\/p>\n