Apache2, FastCGI & Multiple PHP Versions (Ubuntu/Lucid-10.04)

Update # Some minor mistakes solved, tnx a lot for the emails #

—

A little guide I’ve made for those who would like to develop with multiple PHP versions on a local server without restarting the Apache server every time you wish to change the PHP version. If you would like to read more about FastCGI, take a look here.

I’m still perfecting this guide bit by bit, any suggestions or comments are welcome.

I’m using Lucid 10.04 (2.6.32-21-generic). This guide would surely work on most Debian based systems. If not, for testing purposes, Sun’s Virtualbox is ideal for setting up a testing environment that equals this guide.

This guide is terminal-based. In Lucid the terminal is bound by default under the shortcut CTRL+ALT+T or located in the menu under Accessories->Terminal

• Preparation
  

I assume you have Apache2, MySQL-5.0/5.1 and PHP5 already installed and working, if not, go find another guide ;). Create a file on the http root (mine is the default /var/www) and name it phpinfo.php with the following source:

<?php phpinfo(); // ?> ending is not needed, it's pure PHP

You will use this file over and over again to test if the PHP module is loaded through the FastCGI handler. I will install two different PHP versions. The latest 5.2.13 and 5.3.2. phpfarm will be used to install PHP from source because this will save me a lot of time explaining how to build something from source.

First we need to get phpfarm from the repository, you need to use SVN (subversion). If you do not have subversion installed (or svn command is not recognized), simply run:

sudo apt-get install subversion

I’ve made a seperate directory for all the different php versions in the /etc/php/. When using svn co command, the files will be stored in the directory where you are currently located. So when you want these phpfarm files to be saved in /etc/php/, you have to first create /etc/php/ (if it does not exist) and then cd into it. You can ofcourse choose any location of your likings, but just remember to change every path to /etc/php/ during the course of this guide:

sudo mkdir /etc/php/ && sudo chmod 0775 /etc/php/ && cd /etc/php/

Now get phpfarm from the repository:

svn co http://svn.php.net/repository/pear/ci/phpfarm/trunk/ phpfarm

To install PHP 5.2.x with fastcgi support, we have to change some settings in the options.sh file located in /etc/php/phpfarm/src/. cd into the directory and use nano to edit options.sh or the custom-options.sh:

cd /etc/php/phpfarm/src

Because the configuration for 5.2 and 5.3 are different, I suggest creating two files, one 5.2 (for all 5.2.x versions you install) and 5.3 (for all 5.3.x versions you install). If you need a specific options file for a certain version, you can just create another file, for example custom-options-5.2.1.sh which only gets included when running ./compile.sh 5.2.1. This makes it very easy to customize group or individual configurations.

I added MySQL support, which needs the libmysql++-dev package for the mysql_config binary.

sudo apt-get install libmysql++-dev

I suggest to create the two custom-options-5.2.sh and custom-options-5.3.sh files and place only the options you need to add.
Create a custom-options-$version.sh file in /etc/php/phpfarm/src/ where version can be either 5.2 or 5.3, e.g (assuming you are in the /etc/php/phpfarm/src/ directory):

sudo nano custom-options-5.2.sh

and give it the following content (or any prefix you like)

configoptions="\
  --with-mysql=/usr/bin/mysql_config \
  --with-mysqli \
  --with-pdo-mysql \
  --enable-fastcgi \
  --enable-force-cgi-redirect \
"

To save and quit nano, press CTRL+X, press Y, enter 😉
For the 5.3 file, I added:

configoptions="\
  --with-mysql=/usr/bin/mysql_config \
  --with-mysqli=shared,mysqlnd \
  --with-pdo-mysql=shared,mysqlnd \
"

In PHP 5.3.x FastCGI is enabled by default. You can specifiy additional configuration parameters, I only added mysql support. You can always reconfigure and recompile the PHP installation afterwards using ./compile $version where version is again the version you wish to recompile.

• PHP Installation

For this demonstration I’m going to install two PHP versions with phpfarm. The PHP 5.3.x will install without any problems. The 5.2.x may stop at the ./configure process because of some default libxml2 config that isn’t set up right (I have no clue why). The fastest and simplest workaround I found was installing libxml2-dev:

sudo apt-get install libxml2-dev

Now we simply run (assuming you are still in the /etc/php/phpfarm/src/ directory):

./compile.sh 5.3.2

This will start downloading, configure and compile PHP 5.3.2. After completion (or simultaneously in a separate terminal), install 5.2.13:

./compile.sh 5.2.13

Both PHP versions are installed, and ready to be used. The installations are located in /etc/php/phpfarm/inst/php-$version where $version is the version you installed; e.g. 5.2.13 You can check on the PHP 5.2.13 binary if cgi-fcgi is enabled by running:

/etc/php/phpfarm/inst/php-5.2.13/bin/php-cgi -v

This should output something like:

PHP 5.2.13 (cgi-fcgi) (built: Dec 12 2128 12:12:12) (DEBUG)
Copyright (c) 1997-2010 The PHP Group
Zend Engine v2.2.0, Copyright (c) 1998-2010 Zend Technologies

Notice the (cgi-fcgi), this means it’s enabled and ready to be used in a FastCGI/Apache configuration. Same goes for PHP 5.3.2. Just change the version number you have installed and the output would be similar. I suggest completing this guide first before installing any additional versions. You can do so and repeat the configuration for every PHP version you wish to install (it’s almost a copy/paste job).

• FastCGI installation & configuration

Installing the FastCGI module (and suexec, which will be explained later on):

sudo apt-get install libapache2-mod-fastcgi apache2-suexec

After the installation, we have to enable & disable a few modules in Apache. This is done with the commands a2enmod (apache2 enable module) and a2dismod (apache2 disable module):

sudo a2enmod fastcgi actions suexec && sudo a2dismod php5

From this point on, two things are needed. We have to make a script alias for the fastcgi-script and we have to modify the default fastcgi.conf file to wrap the PHP instance with suexec instead of the default handler. First we are going to modify fastcgi.conf in /etc/apache2/mods-enabled/

sudo nano /etc/apache2/mods-enabled/fastcgi.conf

and make the content look like this:

<IfModule mod_fastcgi>
  FastCgiWrapper /usr/lib/apache2/suexec
  FastCgiConfig -idle-timeout 110 -killInterval 120 -pass-header
     HTTP_AUTHORIZATION -autoUpdate
  FastCgiIpcDir /var/lib/apache2/fastcgi
</IfModule>

Next step is creating a script alias which is a simple .conf file. You can just create one in Apache’s root directory (default /etc/apache2/) and include it in the apache2.conf file.  I called mine php-fastcgi.conf.

We have several possibilities on how the PHP application can be executed (the binary php-cgi). First is setting the PHP application as a dynamic application. This is done automatically if not specified differently. The second option is defining the PHP application statically.

To be honest, I do not know the real difference between the two, if it is a performance issue, or something else. You can read more details here.

To configure the PHP application statically you can use FastCgiServer. php-fastcgi-.conf should have the following content in which you can comment out FastCgiServer making it statically. If you wish to use FastCgiServer, do use it for all PHP versions installed. That means you have to copy/paste the commented FastCgiServer line for each PHP version installed:

# /php-fcgi/php-cgi-5.3.2 will be the same as /var/www/cgi-bin/ or which directory
# you choose (or perhaps change) to load the shell scripts.

# comment this out to load the PHP application statically.
#FastCgiServer /var/www/cgi-bin/php-cgi-5.2.13
#FastCgiServer /var/www/cgi-bin/php-cgi-5.3.2
ScriptAlias /php-fcgi/ /var/www/cgi-bin/

Include the php-fastcgi.conf in Apache’s apache2.conf file, before the comment lines:

# include FastCGI conf
Include /etc/apache2/php-fastcgi.conf

# Include of directories <..etc..>
# see README.Deabian for details

Now create the shell scripts in /var/www/cgi-bin/.

sudo mkdir /var/www/cgi-bin

Create for every PHP version you install a scripe file, e.g php-cgi-5.2.13, php-cgi-5.3.2, etc.

sudo nano /var/www/cgi-bin/php-cgi-5.2.13

Make the content look similar to this and change the version number to the corresponding PHP version:

#!/bin/sh
# you can change the PHP version here.
version="5.2.13"
# php.ini file location, */php-5.2.13/lib equals */php-5.2.13/lib/php.ini.
PHPRC=/etc/php/phpfarm/inst/php-${version}/lib/php.ini
export PHPRC

PHP_FCGI_CHILDREN=3
export PHP_FCGI_CHILDREN

PHP_FCGI_MAX_REQUESTS=5000
export PHP_FCGI_MAX_REQUESTS

# which php-cgi binary to execute
exec /etc/php/phpfarm/inst/php-${version}/bin/php-cgi

• Configuring Apache2/VirtualHosts

I have configured my setup that every PHP version resembles a sub-domain. For example PHP 5.3.2 resembles 532.localhost and PHP 5.2.13 resembles 5213.localhost, etc.

I also wanted to maintain the default mod_php5 handler to keep the PHP performance at normality. Though for development, the load on the server is minimal, but still I could notice a small degree of performance loss when loading some heavy PHPUnit tests. Second, I develop in only one version and check for backward compatibility on all other versions. This makes it very easy to test backward compatibility by just changing the sub-domain.

I added the VirtualHosts .conf files in /etc/apache2/sites-enabled/. In here they will load automatically. So for every PHP version installed, add a .conf file that looks similar like this one:

<VirtualHost *:80>
  ServerName 5213.localhost
  DocumentRoot /var/www
  <Directory "/var/www">
    AddHandler php-cgi .php
    Action php-cgi /php-fcgi/php-cgi-5.2.13
  </Directory>
</VirtualHost>

We have to do one last thing. 5213.localhost will of course not be resolved by any DNS. We have to add this statically (or if by change you have a local DNS server, add the record for *.localhost, which you probably already did :D):

sudo nano /etc/hosts

and add after the 127.0.0.1 line all the sub-domains resembling a PHP version:

127.0.0.1        localhost 532.localhost 5213.localhost

Now we can restart apache2:

sudo /etc/init.d/apache2 restart

If everything went well, meaning it restarted without any fatal errors, you can open a browser and test the configuration http://5213.localhost/phpinfo.php 🙂

• Enabling mod_php5
  

To work with the mod_php5, you can just enable it with a2enmod.

Enable php5 again:

a2enmod php5

Edit the /etc/apache2/mods-enabled/php5.conf and comment every line between <IfModule .. > and </IfModule>.

Then restart apache:

sudo /etc/init.d/apache2 restart

Apache should restart without any problems. Open the http://localhost/phpinfo.php and you’ll notice at Server API that is says Apache 2.0 Handler instead of CGI/FastCGI

Happy programming .. 😀