#!/bin/sh
#
# /etc/rc.d/rc.nginx
#
# Start/stop/restart nginx web server.

test_config() {
  set +e
  RES=`nginx -t 2>&1`
  if [ $? -ne 0 ] ; then
     echo "Error in nginx configuration found, restart aborted!"
     echo $RES
     exit 10
  fi
  set -e
}

nginx_start() {
 ulimit -n 65535
 /usr/sbin/nginx -c /etc/nginx/nginx.conf
}

nginx_stop() {
 killall nginx
 rm -f /var/run/nginx/nginx.pid
}

nginx_restart() {
 test_config
 nginx_stop
 nginx_start
}

case "$1" in
  'start')
    nginx_start
  ;;
  'stop')
    nginx_stop
  ;;
  'restart')
    nginx_restart
  ;;
  *)
    echo "Usage: $0 {start|stop|restart}"
  ;;
esac

So, Apache is very good serving dynamic content while nginx is the best on serving static content. But is it possible to have the best from both worlds? Is it possible to use all the apache features (like native .htaccess support) while serving the static content of the website with nginx? Luckily yes.

First of all let’s see the general structure of Apache web server and why it would be a good idea to use a reverse proxy:
1. Client initiates request to the Apache server.
2. His browser connects to the Apache server.
3. The Apache server creates new thread/process to handle the request.
4. If client requested dynamic content, web server spawns CGI process or executes dynamic content handling module (i.e. mod_php) and waits while request will be processed. When it receives resulted web-page, it sends it back to the client.
5. If client asked for some static file, web server sends this file to client
6. Client’s browser receives answer, closes connection to web server and displays content.

As we can see, when there are many requests coming to the web server, the server needs to create many parallel threads/processes and keep them running while client will close connection. If client has slow connection, web server process will wait too long and resource consumption will increase very fast. In the same time, if the website has lots of static content, Apache will create lots of parallel processes which will quickly eat up the memory only to serve a static file. If the money are not a problem we can continue to buy more and more RAM and more powerful processors.

However, there is a more efficient solution. We can use a small piece of software (nginx for example) in front of the Apache web server which will handle all the requests for static content and forward to Apache only the requests for dynamic content. This way Apache will open new threads only to process the dynamic requests and will close them quickly as it won’t need to wait after the client to close the connection (this is going to be nginx’s job).

But (there’s always a but) this approach will bring us the following problems:
1. Each time a vhost is added to apache, we’ll have to add it also to nginx.
2. Because nginx is a reverse proxy layer on top of Apache, Apache will think that all connections originate from the server running nginx. Every entry in the Apache access logs will appear to come from the IP of the nginx server and securing sessions by checking that a user’s IP address hasn’t changed becomes more difficult.

I believe the first problem doesn’t bring such great hassle. I’ll show you how to add vhosts to nginx and you’ll see it’s easy.
It can even be created a small bash script which can read apache’s vhosts and generate the nginx’s ones. But this is not going to be covered in this post.

As for the second problem we’ll use the Apache mod_rpaf module to populate the REMOTE_ADDR using a special HTTP header inserted by nginx.

A typical request would work as follows:
- 1.2.3.4 sends HTTP request to nginx server;
- nginx determines that it needs to proxy pass the request to a back-end Apache server (e.g. by looking at the content-type or virtual host).
- nginx adds an HTTP header “X-Forwarded-For” with the client’s real IP
- nginx forwards (proxy_pass) the request to back-end Apache server
- mod_rpaf in Apache detects that the request is coming from the nginx IP, then substitutes REMOTE_ADDR with the contents of X-Forwarded-For
- Apache handles request as normal. Applications do not need to be aware of the reverse proxy.

Ok, enough with talking, let’s see how are we going to install nginx as a reverse proxy for a back-end Apache server. Of course we are going to use a Slackware server.

First of all we have to build mod_rpaf and configure apache to use it. Go to mod_rpaf website and get the latest version available. In this tutorial i’m going to use mod_rpaf 0.6.

cd /usr/local/src
wget http://stderr.net/apache/rpaf/download/mod_rpaf-0.6.tar.gz
tar -xzvf mod_rpaf-0.6.tar.gz
cd mod_rpaf-0.6
apxs -i -c -n mod_rpaf-2.0.so mod_rpaf-2.0.c

This is going to install mod_rpaf-2.0.so on /usr/lib/httpd/modules/

Now edit /etc/httpd/httpd.conf and add the following:

LoadModule rpaf_module lib/httpd/modules/mod_rpaf-2.0.so

RPAFenable On
RPAFsethostname On
RPAFproxy_ips 127.0.0.1
RPAFheader X-Forwarded-For

Also we have to configure apache to listen only on localhost:

Listen 127.0.0.1:80

Edit /etc/httpd/extra/httpd-vhosts.conf and make sure you use the following directive:

NameVirtualHost *:80

Make sure each of your virtual hosts are defined as:

<VirtualHost *:80>
 ...
</VirtualHost>

Now we have to build and configure nginx. If you want you can use the following nginx slackware package made by me:

nginx-0763-i486-1.txz

However if you’re like me and you like to build things manually:

cd /usr/local/src
wget http://sysoev.ru/nginx/nginx-0.7.63.tar.gz

mkdir /etc/nginx
mkdir /var/log/nginx
mkdir /var/run/nginx

tar -xzvf nginx-0.7.63.tar.gz
cd nginx-0.7.63
./configure --prefix=/usr \
--conf-path=/etc/nginx/nginx.conf \
--error-log-path=/var/log/nginx/error.log \
--pid-path=/var/run/nginx/nginx.pid

make
make install

groupadd nginx
useradd -g nginx -d /var/www/htdocs -s /bin/false nginx

The next step is to edit /etc/nginx/nginx.conf file. Here it is the file i’m using:

user  nginx;
worker_processes  2;

error_log  /var/log/nginx/error.log;
#error_log  logs/error.log  notice;
#error_log  logs/error.log  info;

pid /var/run/nginx.pid;

events {
    worker_connections  1024;
}

http {
    include       mime.types;
    default_type  application/octet-stream;

    log_format  main  '$remote_addr - $remote_user [$time_local] "$request" '
                      '$status $body_bytes_sent "$http_referer" '
                      '"$http_user_agent" "$http_x_forwarded_for"';

    #access_log  logs/access.log  main;

    sendfile        on;
    #tcp_nopush     on;

    #keepalive_timeout  0;
    keepalive_timeout  65;

    gzip  on;

  server {
    listen       86.55.9.90:80 default;
    listen       86.55.239.6:80 default;
    server_name  _;
    access_log /var/log/nginx/default.access.log main;

    location / {
        proxy_pass http://127.0.0.1:80;
        include /etc/nginx/proxy.conf;
    }
  }
  include /etc/nginx/vhosts/*[^~];
}

Create /etc/nginx/proxy.conf template file which is going to be used on every vhost:

proxy_redirect          off;
proxy_set_header        Host            $host;
proxy_set_header        X-Real-IP       $remote_addr;
proxy_set_header        X-Forwarded-For $proxy_add_x_forwarded_for;
client_max_body_size    10m;
client_body_buffer_size 128k;
proxy_connect_timeout   90;
proxy_send_timeout      90;
proxy_read_timeout      90;
proxy_buffers           32 4k;

Now you have to set up your virtual hosts. Here it is how /etc/nginx/vhosts/razvan.ws vhost file looks like:

server {
    listen 86.55.239.2:80;
    server_name www.razvan.ws razvan.ws;
    # I'm not going to use nginx to create an access log as this is created by apache anyway
    #access_log /var/log/nginx/razvan.ws.access.log main;

    location / {
        proxy_pass http://127.0.0.1:80;
        include /etc/nginx/proxy.conf;
    }

    location ~* ^.+\.(jpe?g|gif|png|ico|css|zip|tgz|gz|rar|bz2|doc|xls|exe|pdf|ppt|txt|tar|mid|midi|wav|bmp|rtf|js|swf|avi|mp3)$ {
        expires 1d;
        root /var/www/htdocs/razvan.ws;
    }
}

Let’s create a nice slackware-like /etc/rc.d/rc.nginx script to start/stop/restart nginx:

#!/bin/sh
#
# /etc/rc.d/rc.nginx
#
# Start/stop/restart the nginx web server.

nginx_start() {
 /usr/sbin/nginx -c /etc/nginx/nginx.conf
}

nginx_stop() {
 killall nginx
 rm -f /var/run/nginx.pid
}

nginx_restart() {
 nginx_stop
 nginx_start
}

case "$1" in
  'start')
    nginx_start
  ;;
  'stop')
    nginx_stop
  ;;
  'restart')
    nginx_restart
  ;;
  *)
    echo "Usage: $0 {start|stop|restart}"
  ;;
esac

Now the only thing left is to restart apache and start nginx:

apachectl restart
/etc/rc.d/rc.nginx start

If everything went well, we’ll have the following processes:

 4263 ?        Ss     0:00 nginx: master process /usr/bin/nginx -c /etc/nginx/nginx.conf
 4264 ?        S      0:00  \_ nginx: worker process
 4265 ?        S      0:00  \_ nginx: worker process
 4836 ?        Ss     0:00 /usr/bin/httpd -k start
 4837 ?        S      0:00  \_ /usr/bin/fcgi- -k start
 4896 ?        Ss     0:00  |   \_ /usr/bin/php-cgi
 4897 ?        S      0:00  |       \_ /usr/bin/php-cgi
 4898 ?        S      0:00  |       \_ /usr/bin/php-cgi
 4838 ?        Sl     0:00  \_ /usr/bin/httpd -k start
 4866 ?        Sl     0:00  \_ /usr/bin/httpd -k start

Check out your apache access logs to see if everything is ok. Also if you want to make sure nginx is serving the static files, enable nginx access log as well and see if it gets the hits correctly.

Now the server is able to handle more traffic with the less resources. Everything is done transparently for the currently written scripts and for the users.

The typical nginx configuration involves using spawn-fcgi from the LightTPD project to get nginx serving up PHP. There are a few issues with spawn-fcgi which I’m not going to cover here.
In order to avoid these issues I’m going to use PHP-FPM. PHP-FPM stands for PHP FastCGI Process Manager. It is actually a set of patches for the PHP source that bake in FastCGI process management into the PHP binaries.

PHP-FPM requires libevent to be installed. Since Slackware doesn’t include a libevent package it has to be build from sources. In this tutorial I’m using libevent-1.4.12. An attached slackware package of libevent-1.4.12 is available at the end of this post.

cd /usr/local/src
wget http://www.monkey.org/~provos/libevent-1.4.12-stable.tar.gz
tar -xzvf libevent-1.4.12-stable.tar.gz
./configure --prefix=/usr
make
make install

Now we’re going to get php-fpm package according to the php version we’re going to build. I’m gonna use php-5.3.0 so I need php-fpm-0.6-5.3.0.tar.gz. You can get different versions from php-fpm website.

cd /usr/local/src
wget http://launchpad.net/php-fpm/master/0.6/+download/php-fpm-0.6-5.3.0.tar.gz
tar -xzvf php-fpm-0.6-5.3.0.tar.gz

Php-fpm can be built into php or standalone. According to php-fpm readme it’s recommended to be build into php.
So, we’re going to generate fpm patch for php:

php-fpm-0.6-5.3.0/generate-fpm-patch

That should give you fpm.patch file.

Now we’re going to download php source and patch it with fpm:

wget http://www.php.net/get/php-5.3.0.tar.gz/from/ro2.php.net/mirror
tar -xzvf php-5.3.0.tar.gz
cd php-5.3.0
patch -p1 < ../fpm.patch

We’re going to configure it slackware style, with as many things as possible included:

./buildconf --force

EXTENSION_DIR=/usr/lib/php/extensions \
CFLAGS="-O2 -march=i486 -mtune=i686" \
./configure \
--prefix=/usr \
--sysconfdir=/etc \
--with-fpm \
--with-libevent=/usr \
--enable-fastcgi \
--enable-discard-path \
--enable-force-cgi-redirect \
--disable-safe-mode \
--enable-apc \
--enable-apc-mmap \
--enable-memory-limit \
--enable-suhosin \
--disable-magic-quotes \
--enable-zend-multibyte \
--enable-mbregex \
--enable-tokenizer=shared \
--with-config-file-scan-dir=/etc/php \
--with-config-file-path=/etc/httpd \
--with-mod_charset \
--with-layout=PHP \
--enable-sigchild \
--enable-xml \
--with-libxml-dir=/usr \
--enable-simplexml \
--enable-spl \
--enable-filter \
--disable-debug \
--with-openssl=shared \
--with-pcre-regex=/usr \
--with-zlib=shared,/usr \
--enable-bcmath=shared \
--with-bz2=shared,/usr \
--enable-calendar=shared \
--enable-ctype=shared \
--with-curl=shared \
--with-curlwrappers \
--enable-dba=shared \
--with-gdbm=/usr \
--with-db4=/usr \
--enable-exif=shared \
--enable-ftp=shared \
--with-gd=shared \
--with-jpeg-dir=/usr \
--with-png-dir=/usr \
--with-zlib-dir=/usr \
--with-xpm-dir=/usr \
--with-freetype-dir=/usr \
--with-t1lib=/usr \
--enable-gd-native-ttf \
--enable-gd-jis-conv \
--with-gettext=shared,/usr \
--with-gmp=shared,/usr \
--with-iconv=shared \
--with-ldap=shared \
--enable-mbstring=shared \
--enable-hash \
--with-mysql=mysqlnd \
--with-mysqli=mysqlnd \
--enable-pdo \
--with-pdo-mysql=mysqlnd \
--with-pdo-sqlite=shared \
--with-pspell=shared,/usr \
--with-mm=/usr \
--enable-shmop=shared \
--with-snmp=shared,/usr \
--enable-soap=shared \
--enable-sockets \
--with-sqlite=shared \
--enable-sqlite-utf8 \
--with-regex=php \
--enable-sysvmsg \
--enable-sysvsem \
--enable-sysvshm \
--enable-wddx=shared \
--with-xsl=shared,/usr \
--enable-zip=shared \
--with-tsrm-pthreads \
--enable-shared=yes \
--enable-static=no \
--with-gnu-ld \
--with-pic \
--with-mcrypt=shared

Notice the following options used:

--with-fpm \
--with-libevent=/usr \
--with-mysql=mysqlnd \
--with-mysqli=mysqlnd \
--with-pdo-mysql=mysqlnd \
--enable-fastcgi \
--enable-discard-path \
--enable-force-cgi-redirect \
--with-mcrypt=shared

If you don’t have mcrypt installed, you can skip that line.

PHP 5.3.0 is the first version of php which includes mysqlnd.
According to php.net, mysqlnd is a new core library shipped with PHP. It is a PHP-specific replacement for libmysql. mysqlnd will be used to build the mysql, mysqli and PDO_MySQL extensions if libmysql isnt found on the system. It may also be used instead of libmysql even when libmysql is present. mysqlnd is recommended for all PHP installations for performance reasons.

If everything went well, we can proceed to build php-5.3.0:

make
make install

At this point you should edit your /etc/httpd/php.ini file as mhash extension is no more provided with php-5.3.0. Also dbase extension have been moved in PECL and it appears to be a bug with pdo_sqlite extension built as shared. So comment out mhash.so, dbase.so and pdo_sqlite.so. It’s recommended to comment out (disable) all the extensions which are not going to be used.

A slackware (13.0) package of php-5.3.0 configured with php-fpm and fastcgi using options above is available at the end of this post.

If everything went well, php -v and php-fpm -v should give you the following output:

root@hopeseekr:/# php -v
PHP 5.3.0 (cli) (built: Oct 27 2009 20:07:27)
Copyright (c) 1997-2009 The PHP Group
Zend Engine v2.3.0, Copyright (c) 1998-2009 Zend Technologies

root@hopeseekr:/# php-fpm -v
PHP 5.3.0 (cgi-fcgi) (built: Oct 27 2009 19:31:19)
Copyright (c) 1997-2009 The PHP Group
Zend Engine v2.3.0, Copyright (c) 1998-2009 Zend Technologies

root@hopeseekr:/# php --ini
Configuration File (php.ini) Path: /etc/httpd
Loaded Configuration File:         /etc/httpd/php.ini
Scan for additional .ini files in: /etc/php
Additional .ini files parsed:      (none)

Because it’s not such a good practice to run programs as root, create the following user:

groupadd nginx
useradd -g nginx -d /storage/htdocs -s /bin/false nginx

Open up /etc/php-fpm.conf in your editor of choice. Do some searching and change the users who own the processes to nginx. The file is too big to post in here, but the values we want to change are on lines 51, 52, 63 and 66. Should look something like:

<value name="owner">nginx</value>
<value name="group">nginx</value>
<value name="user">nginx</value>
<value name="group">nginx</value>

Now that we’re done with php, we have to move on to Nginx.

Go to Nginx website and get the latest version of Nginx. In this tutorial I’m using nginx 0.7.63:

cd /usr/local/src
wget http://sysoev.ru/nginx/nginx-0.7.63.tar.gz

First of all let’s create the following folders just to be sure we’re not going to have errors later.

mkdir /etc/nginx
mkdir /var/log/nginx
mkdir /var/run/nginx

Now, we are going to unzip/configure and build nginx.

tar -xzvf nginx-0.7.63.tar.gz
cd nginx-0.7.63
./configure --prefix=/usr \
--conf-path=/etc/nginx/nginx.conf \
--error-log-path=/var/log/nginx/error.log \
--pid-path=/var/run/nginx/nginx.pid

make
make install

A slackware (13.0) package of nginx-0.7.63 is available at the end of this post.

The next step is to edit /etc/nginx/nginx.conf file. Here it is the file i’m using:

user  nginx;
worker_processes  2;

error_log  /var/log/nginx/error.log;

pid /var/run/nginx/nginx.pid;

events {
    worker_connections  1024;
}

http {
    include       mime.types;
    default_type  application/octet-stream;

    log_format  main  '$remote_addr - $remote_user [$time_local] "$request" '
                      '$status $body_bytes_sent "$http_referer" '
                      '"$http_user_agent" "$http_x_forwarded_for"';

    #access_log  logs/access.log  main;

    sendfile        on;
    #tcp_nopush     on;

    #keepalive_timeout  0;
    keepalive_timeout  65;

    gzip  on;

  server {
    listen       86.55.39.34:80 default;
    server_name  _;
    access_log /var/log/nginx/access.log main;
    root /storage/htdocs;
    index  index.php index.html index.htm;
    #autoindex on;

    location ~ .php$ {
       fastcgi_pass 127.0.0.1:9000;
       #fastcgi_index index.php;
       include /etc/nginx/fastcgi_params;
       fastcgi_param SCRIPT_FILENAME $document_root$fastcgi_script_name;
    }

  }

}

If you want to find out more about nginx config, check out http://wiki.nginx.org/Main.

Now we have to set up some FastCGI parameters so that PHP doesn’t choke and you’ll avoid random 503 errors from nginx. Open up /etc/nginx/fastcgi_params and add the following:

fastcgi_connect_timeout 60;
fastcgi_send_timeout 180;
fastcgi_read_timeout 180;
fastcgi_buffer_size 128k;
fastcgi_buffers 4 256k;
fastcgi_busy_buffers_size 256k;
fastcgi_temp_file_write_size 256k;
fastcgi_intercept_errors on;

Now we’re almost ready. Let’s create a nice slackware-like script to start nginx. Save the following in /etc/rc.d/rc.nginx:

#!/bin/sh
#
# /etc/rc.d/rc.nginx
#
# Start/stop/restart the nginx web server.

nginx_start() {
 /usr/sbin/nginx -c /etc/nginx/nginx.conf
}

nginx_stop() {
 killall nginx
 rm -f /var/run/nginx/nginx.pid
}

nginx_restart() {
 nginx_stop
 nginx_start
}

case "$1" in
  'start')
    nginx_start
  ;;
  'stop')
    nginx_stop
  ;;
  'restart')
    nginx_restart
  ;;
  *)
    echo "Usage: $0 {start|stop|restart}"
  ;;
esac

Don’t forget to make the file executable:

chmod 755 /etc/rc.d/rc.nginx

Now we’re ready to start our new web server:

/etc/rc.d/init.d/php-fpm start
/etc/rc.d/rc.nginx start

If everything went well you should see the following processes:

 2733 ?        Ss     0:00 /usr/bin/php-fpm --fpm-config /etc/php-fpm.conf
 2734 ?        S      0:00  \_ /usr/bin/php-fpm --fpm-config /etc/php-fpm.conf
 2735 ?        S      0:00  \_ /usr/bin/php-fpm --fpm-config /etc/php-fpm.conf
 2736 ?        S      0:00  \_ /usr/bin/php-fpm --fpm-config /etc/php-fpm.conf
 2737 ?        S      0:00  \_ /usr/bin/php-fpm --fpm-config /etc/php-fpm.conf
 2738 ?        S      0:00  \_ /usr/bin/php-fpm --fpm-config /etc/php-fpm.conf
 2756 ?        Ss     0:00 nginx: master process /usr/sbin/nginx -c /etc/nginx/nginx.conf
 2757 ?        S      0:00  \_ nginx: worker process
 2758 ?        S      0:00  \_ nginx: worker process

It’s a good idea to use a php cacher. Feel free to use the instructions from apache tutorial in order to install APC.

Here there are the Slackware 13.0 packages of the above programs:

libevent-1412-i486-1.txz
nginx-0763-i486-1.txz
php-530-i486-1.txz

Before you start, make sure you have a working httpd.conf of Apache2 because a detailed configuration is not included in this tutorial. Then, remove the installed packages of Apache2 and PHP using Slackware’s pkgtool.

Go to Apache website and get the latest version of Apache2. In this tutorial I’m using Apache-2.2.9:

cd /usr/local/src
wget http://www.eu.apache.org/dist/httpd/httpd-2.2.9.tar.gz

Go to PHP website and get the latest version of PHP5. In this tutorial I’m using PHP-5.2.6

wget http://www.php.net/get/php-5.2.6.tar.gz/from/de.php.net/mirror

Go to FastCGI website and get the latest version of mod_fastcgi. In this tutorial I’m using mod_fastcgi-2.4.6:

wget http://www.fastcgi.com/dist/mod_fastcgi-2.4.6.tar.gz

Now, we are going to unzip/configure Apache. In this tutorial we are configuring it Slackware style, with as many things as possible included:

tar -xzvf httpd-2.2.9.tar.gz

./configure \
  --prefix=/usr \
  --sysconfdir=/etc/httpd \
  --libdir=/usr/lib/httpd \
  --libexecdir=/usr/lib/httpd/modules \
  --datadir=/srv/httpd \
  --localstatedir=/var\
  --with-mpm=worker \
  --with-apr=/usr \
  --with-apr-util=/usr \
  --enable-mods-shared=all \
  --enable-so \
  --enable-pie \
  --enable-cgi \
  --with-pcre \
  --enable-ssl \
  --enable-rewrite \
  --enable-vhost-alias \
  --enable-proxy \
  --enable-proxy-http \
  --enable-proxy-ftp \
  --enable-proxy-balancer \
  --enable-cache \
  --enable-mem-cache \
  --enable-file-cache \
  --enable-disk-cache \
  --disable-speling \
  --enable-dav \
  --enable-ldap \
  --enable-authnz-ldap \
  --enable-authn-anon \
  --enable-authn-alias

Please notice that we are going to use Apache mpm worker instead of the default prefork:

--with-mpm=worker \

For additional info about mpm-worker, feel free to visit: http://httpd.apache.org/docs/2.2/mod/worker.html

We are going to build apache:

make
make install

Unzip mod_fastcgi:

cd /usr/local/src
tar -xzvf mod_fastcgi-2.4.6.tar.gz

We are going to build mod_fastcgi according to it’s README:

cd mod_fastcgi-2.4.6
apxs -o mod_fastcgi.so -c *.c

Then, we will copy the binary into Apache’s modules folder:

cp .libs/mod_fastcgi.so /usr/lib/httpd/modules/mod_fastcgi.so

Now, you will have to edit /etc/httpd/httpd.conf and add the following line:

LoadModule fastcgi_module lib/httpd/modules/mod_fastcgi.so

Make sure you have the following files:

mkdir /var/run/httpd
mkdir /tmp/fcgi_ipc
chmod 777 /tmp/fcgi_ipc

Before continue with PHP configuration, make sure you have mcrypt/libmcrypt installed. If you don’t want to install mcrypt, just remove the following line from the php configure command:

--with-mcrypt=shared

Anyway, here there are the links where you can get a slackware packed version of mcrypt:

wget http://repository.slacky.eu/slackware-12.0/libraries/libmcrypt/2.5.8/libmcrypt-2.5.8-i486-1sl.tgz
wget http://darkstar.ist.utl.pt/slackware/addon/slacky/slackware-12.0/security/mcrypt/2.6.7/mcrypt-2.6.7-i486-1sl.tgz

installpkg libmcrypt-2.5.8-i486-1sl.tgz mcrypt-2.6.7-i486-1sl.tgz

Now, we are going to unzip/configure PHP. We are using almost the same configuration as Slackware’s default:

EXTENSION_DIR=/usr/lib/php/extensions \
CFLAGS="-O2 -march=i486 -mtune=i686" \
./configure \
--prefix=/usr \
--sysconfdir=/etc \
--enable-fastcgi \
--enable-discard-path \
--enable-force-cgi-redirect \
--disable-safe-mode \
--enable-apc \
--enable-apc-mmap \
--enable-memory-limit \
--enable-suhosin \
--disable-magic-quotes \
--enable-zend-multibyte \
--enable-mbregex \
--enable-tokenizer=shared \
--with-config-file-scan-dir=/etc/php \
--with-config-file-path=/etc/httpd \
--with-mod_charset \
--with-layout=PHP \
--enable-sigchild \
--enable-xml \
--with-libxml-dir=/usr \
--enable-simplexml \
--enable-spl \
--enable-filter \
--disable-debug \
--with-openssl=shared \
--with-pcre-regex=/usr \
--with-zlib=shared,/usr \
--enable-bcmath=shared \
--with-bz2=shared,/usr \
--enable-calendar=shared \
--enable-ctype=shared \
--with-curl=shared \
--with-curlwrappers \
--enable-dba=shared \
--with-gdbm=/usr \
--with-db4=/usr \
--enable-dbase=shared \
--enable-exif=shared \
--enable-ftp=shared \
--with-gd=shared \
--with-jpeg-dir=/usr \
--with-png-dir=/usr \
--with-zlib-dir=/usr \
--with-xpm-dir=/usr \
--with-freetype-dir=/usr \
--with-t1lib=/usr \
--enable-gd-native-ttf \
--enable-gd-jis-conv \
--with-gettext=shared,/usr \
--with-gmp=shared,/usr \
--with-iconv=shared \
--with-ldap=shared \
--enable-mbstring=shared \
--with-hash \
--with-mhash=shared,/usr \
--with-mysql=shared,/usr \
--with-mysqli=shared,/usr/bin/mysql_config \
--enable-pdo=shared \
--with-pdo-mysql=shared,/usr \
--with-pdo-sqlite=shared \
--with-pspell=shared,/usr \
--with-mm=/usr \
--enable-shmop=shared \
--with-snmp=shared,/usr \
--enable-soap=shared \
--enable-sockets \
--with-sqlite=shared \
--enable-sqlite-utf8 \
--with-regex=php \
--enable-sysvmsg \
--enable-sysvsem \
--enable-sysvshm \
--enable-wddx=shared \
--with-xsl=shared,/usr \
--enable-zip=shared \
--with-tsrm-pthreads \
--enable-shared=yes \
--enable-static=no \
--with-gnu-ld \
--with-pic \
--with-mcrypt=shared

make
make install

Edit httpd.conf and add the following (after LoadModule directive):

FastCgiIpcDir /tmp/fcgi_ipc
AddHandler fastcgi-script .fcgi .fcg .fpl
FastCgiConfig -singleThreshold 100 -killInterval 300 -autoUpdate -idle-timeout 240 -pass-header HTTP_AUTHORIZATION

ScriptAlias /php-fcgi "/var/www/cgi-bin/php5.fcgi"

AddHandler application/x-httpd-php .php
Action application/x-httpd-php /php-fcgi

If you want to find more about mod_fastcgi options, visit: http://www.fastcgi.com/mod_fastcgi/docs/mod_fastcgi.html

Create the file /var/www/cgi-bin/php5.fcgi:

#!/bin/sh
PHP_FCGI_CHILDREN=2
export PHP_FCGI_CHILDREN
PHP_FCGI_MAX_REQUESTS=500
export PHP_FCGI_MAX_REQUESTS
exec /usr/bin/php-cgi

Make sure the file is own by apache and is executable:

chown apache:apache /var/www/cgi-bin/php5.fcgi
chmod 755 /var/www/cgi-bin/php5.fcgi

Edit /etc/httpd/httpd.conf and make sure the following line is not commented:

Include /etc/httpd/extra/httpd-mpm.conf

Edit /etc/httpd/extra/httpd-mpm.conf and make sure the following lines are not commented:

StartServers          2
MaxClients          150
MinSpareThreads      25
MaxSpareThreads      75
ThreadsPerChild      25
MaxRequestsPerChild   0

At this point you should be ready to start apache:

apachectl start

Check /var/log/httpd/error_log to see if there are any errors.

[notice] FastCGI: process manager initialized (pid 20046)
[notice] Apache/2.2.9 (Unix) mod_fastcgi/2.4.6 configured -- resuming normal operations

If everything is ok, you should see the following processes after you run ps axf:

20511 ?        Ss     0:00 /usr/bin/httpd -k start
20512 ?        S      0:00  \_ /usr/bin/fcgi- -k start
20571 ?        Ss     0:00  |   \_ /usr/bin/php-cgi
20572 ?        S      0:00  |       \_ /usr/bin/php-cgi
20573 ?        S      0:00  |       \_ /usr/bin/php-cgi
20574 ?        S      0:00  |       \_ /usr/bin/php-cgi
20575 ?        S      0:00  |       \_ /usr/bin/php-cgi
20576 ?        S      0:00  |       \_ /usr/bin/php-cgi
20577 ?        S      0:00  |       \_ /usr/bin/php-cgi
20578 ?        S      0:00  |       \_ /usr/bin/php-cgi
20579 ?        S      0:00  |       \_ /usr/bin/php-cgi
20580 ?        S      0:00  |       \_ /usr/bin/php-cgi
20581 ?        S      0:00  |       \_ /usr/bin/php-cgi
20513 ?        Sl     0:00  \_ /usr/bin/httpd -k start
20541 ?        Sl     0:00  \_ /usr/bin/httpd -k start

If you want to boost the performance of your PHP scripts, you can use a php cacher. In the example below, I’m going to use APC.

Get the latest apc version available:

cd /usr/local/src
wget http://pecl.php.net/get/APC-3.0.19.tgz

Unzip/configure APC:

tar -xvf APC-3.0.19.tgz
cd APC-3.0.19
phpize
EXTENSION_DIR=/usr/lib/php/extensions \
CFLAGS="-O2 -march=i486 -mtune=i686" \
./configure \
--prefix=/usr \
--sysconfdir=/etc \
--enable-apc-mmap \
--with-php-config=/usr/bin/php-config

make
cp modules/apc.* /usr/lib/php/extensions/

Add the following lines in your /etc/php.ini:

extension=apc.so
apc.enabled=1
apc.shm_segments=1
apc.shm_size=128
apc.ttl=7200
apc.user_ttl=7200
apc.num_files_hint=1024
apc.mmap_file_mask=/tmp/apc.XXXXXX

Now, you have to restart apache:

apachectl restart

Later edit:
After successfully running above setup on a box with medium/high traffic for a time, I saw that changing the number of PHP_FCGI_CHILDREN to 2 helped getting better performance and better loading times under high load.