In this second part, I will setup phpUnderControl (using Git for source control) and the installation of all the necessary software… Plus I will make reference to a couple of good tutorials on how to set up a PHP apps to work with Capistrano for deployment.

For the phpUnderControl setup, I pretty much followed this tutorial.

However, I changed some things… such as, using Git instead of SVN and a bit more specific on certain areas that gave me some trouble…

In any decent sized project, the more times you commit code, the bigger the chance is that you will break something. Call it the law of unintended consequences or the butterfly effect, but the fact is that in complex systems, we cannot anticipate all the effects of a change. To deal with this we can either adopt the “release and pay” method of software control, or we can setup systems to help us find the consequences of our actions, so we that can correct them before they become a problem. We usually call these systems Continuous Integration systems.

In this article, we will look at how to set up a Continuous Integration system for PHP using phpUnderControl. After reading this article, you should have a good understanding of the pieces involved in a Continuous Integration system and be able to set up and run your own.

What is Continuous Integration?

Thoroughly explaining Continuous Integration would require an article of its own or possibly a whole book. A good one-sentence definition of Integration is “Delivering a working system”, so Continuous Integration means “Continuously delivering a working system”; after every change made to the code the system can be proven to work.

Obviously, manually deploying and testing a system after every change is a very tedious job; however tedious jobs are what computers are really good at, and Continuous Integration systems are the programs that can do the work for us.

PhpUnderControl?

phpUnderControl is an add-on application for CruiseControl, a Continuous Integration system written in Java. It combines a number of popular PHP development tools like PHPUnit, phpDocumentor and PHP_CodeSniffer.

It can run unit tests, generate the API documentation, check the code for compliance with coding standards, and present you with a web interface to review the results. It can even turn on the lights.

Setting up phpUnderControl

For this tutorial, we will use Ubuntu Server as the reference platform, but the instructions should translate easily to other Linuxes, BSDs or even Windows. You should have a dedicated machine available, but if you don’t, it is possible can also install it on a machine used for other tasks.

As mentioned above, phpUnderControl is an add-on for CruiseControl, which is a Java application, so we install that first:

sudo apt-get install sun-java6-jdk

PHPUnit needs xDebug to generate the code coverage reports:

sudo apt-get install php5-dev php-pear
pear upgrade PEAR

Now install xdebug thru PECL.

sudo pecl install xdebug

Now we need to find where xdebug.so went (the compiled module)

find / -name 'xdebug.so' > /dev/null
/usr/lib/php5/20060613/xdebug.so

Then edit php.ini:

sudo gedit /etc/php/apache2/php.ini

Add the following line:

zend_extension="/usr/lib/php5/20060613/xdebug.so"

Then restart apache for changes to take effect.

You can also, rather than including the xdebug.so extension in your php.ini file, it is probably more appropriate to create an .ini file specifically for this extension in /etc/php5/conf.d/xdebug.ini. The file can be as simple as:

; xdebug debugger
zend_extension="/usr/lib/php5/20060613/xdebug.so"

And then to compliment this setup, add any xdebug configuration directives to this file as well.

This has two benifits:

• 1. It will be automatically included by both cli php5 and apache2 php5
• 2. It will persist regardless of what happens with your php setup.

If your main php.ini file gets changed or modified by some automated process, you don’t risk losing your xdebug setup stuff.

sudo /etc/init.d/apache2 restart

Check phpinfo() to make sure the extension is loaded correctly.

The following line should have been appended to the copyright lines:

with Xdebug v2.0.0, Copyright (c) 2002, 2003, 2004, 2005, 2006, 2007, by Derick Rethans

For more information about xdebug configuration and usage, please read the official documentation, found here: http://xdebug.org/docs/

For PHPUnit, PEAR is the recommended way to install it:

This also installs the php5-cli package which you need to run PHPUnit.

For the graphs we need the ezComponents Graph library:

sudo pear channel-discover components.ez.no
sudo pear install -a ezc/Graph

Now we get to phpUnderControl itself:

sudo pear config-set preferred_state beta
sudo pear channel-discover pear.phpunit.de
sudo pear install --alldeps phpunit/phpUnderControl

phpUnderControl is still in beta, and by default PEAR does not install components in beta status, so we have to use config-set to make it install.

And, of course, cruisecontrol itself.

To unzip the file we need unzip:

sudo apt-get install unzip

Now we can install CruiseControl:

sudo unzip cruisecontrol-bin-2.8.2.zip -d /opt

To make it easy to upgrade add a link to the current version:

sudo ln -s /opt/cruisecontrol-bin-2.8.2 /opt/cruisecontrol

Configure CruiseControl for phpUnderControl by running the install script:

sudo phpuc install /opt/cruisecontrol

Install the example project:

sudo phpuc example /opt/cruisecontrol

To start, CruiseControl needs the JAVA_HOME variable set. To set it add the lone below to your /etc/environment.

JAVA_HOME="/usr/lib/jvm/java-6-sun"

Additionally, to set JAVA_HOME in your current shell, execute the following command.

JAVA_HOME="/usr/lib/jvm/java-6-sun";export JAVA_HOME

We are now ready to start CruiseControl:

cd /opt/cruisecontrol
sudo -E ./cruisecontrol.sh

If you use the -E option, you retain your own environment variables. You need the JAVA_HOME for cruisecontrol.sh to work properly. You can also run cruisecontrol.sh as a regular user, but then you have to make sure you own the whole CruiseControl tree: (Don’t do this while CruiseControl is still running.)

sudo chown -LR user:user /opt/cruisecontrol

The -R option makes the command recursive. This ensures that the ownership of the link is changed along with all files beneath it. The -L options ensures that if there are symbolic links to directories that they are traversed also.

Configuring phpUnderControl for a sample project.

We can now fire up a browser and go to http://[ip-address of ci server]:8080/cruisecontrol and it should show something like this:

Don’t worry if you see error messages in the ‘coverage’ and ‘metrics’ tags about missing files in the ‘artifacts’ directory. The configuration of the installed example project is not quite correct. You can find a fix here.
We can now stop CruiseControl with:

kill `cat /opt/cruisecontrol/cc.pid`

Setting up a new project

Now you’re ready to set up a new project. In this example I will assume that you already have a working Git project which you can clone… after following the previous tutorial about Gitosis, most likely your project repo is in /home/git/repositories/. For this example we will call this project ‘my_project’.

If you already have a project with some PHPUnit tests perfect, use that! if not, copy this two files in your "my_project" directory

Calculator.php:

<?php
Class Calculator
{
  public static function Add($a, $b)
  {
    return $a + $b;
  }
}

CalculatorTest.php:

<?php

require_once 'PHPUnit/Framework.php';
include 'Calculator.php';

class CalculatorTest extends PHPUnit_Framework_Testcase
{
  public function testAdd()
  {
    $this->assertEquals(3, Calculator::Add(1,2));
  }
}

In order to add a new project to CruiseControl you have to do three main things:

• Create a project configuration.
• Set up a directory structure.
• Add the project to the main configuration.

Cruisecontrol projects live in the subdirectory projects/ in the cruisecontrol/ directory, so the first step is to create a project directory:

cd /opt/cruisecontrol/projects
mkdir my_project
cd my_project

Then make a build.xml file there with the following content:

[/source]

The structure of a project section of build.xml is always the same, a target element with a name attribute that contains an exec element.

 <project>
  ...
  <target>
   <exec>
    <arg/>
   </exec>
  </target>
  ...
 </project>

The exec element has an executable attribute that points to the program to run and a dir attribute that determines the directory in which the program is executed. Within the exec element is an arg element that holds the command line argument.

So the checkout tagged in the exec element below

<exec executable="git" dir="${basedir}/source">
  <arg line="pull" />
</exec>

is equivalent to:

cd my_project/source
git pull 

A detailed description of the build.xml file can be found here.

This file lists all the steps needed to get a working system to test. Each step is called a ‘target’, and a target can depend on other targets to be finished before they can be executed.
The first step is to update the code:

<?xml version="1.0" encoding="UTF-8"?>
<project name="my_project" basedir=".">
  <target name="checkout">
    <exec executable="git" dir="${basedir}/source">
      <arg line="pull" />
    </exec>
  </target>
</project>

This will run ‘git pull’ (similar to ’svn update’) in the projects/my_project/source directory. To get our project files there, we need to a checkout first:

Git clone /home/git/repositories/my_project.git/  /opt/cruisecontrol/projects/my_project/source

You can now test your build.xml file:

../../apache-ant-1.7.0/bin/ant checkout

Ant is the program that actually runs the builds. The output should look like

this:  </p>

 checkout:
    [exec] At revision 1.

 BUILD SUCCESSFUL
 Total time: 1 second

Now we can add the other targets:

PhpDocumentor:

 <target name="php-documentor">
  <exec executable="phpdoc" dir="${basedir}/source">
   <arg line="-ct type -ue on -t ${basedir}/build/api
         -tb /usr/share/php/data/phpUnderControl/data/phpdoc
         -o HTML:Phpuc:phpuc -d ."/>
  </exec>
 </target>

An explanation for the various arguments can be found by typing

phpdoc -h 

The -tb argument makes sure phpdoc uses a template that looks good with phpUnderControl. Phpdoc stores its output in the build/api directory, which you will have to create manually in the my_project/ directory.

mkdir -p build/api

And as with the checkout target, you can check if it is correct by using Ant again:

../../apache-ant-1.7.0/bin/ant php-documentor

PHPUnit:

<target name="phpunit">
  <exec executable="phpunit" dir="${basedir}/source" failonerror="on">
    <arg line="--log-xml ${basedir}/build/logs/phpunit.xml
          --log-pmd ${basedir}/build/logs/phpunit.pmd.xml
          --log-metrics ${basedir}/build/logs/phpunit.metrics.xml
          --coverage-xml ${basedir}/build/logs/phpunit.coverage.xml
          --coverage-html ${basedir}/build/coverage
          CalculatorTest.php" />
  </exec>
</target>

This target puts its output in build/logs and build/coverage, which also have to be created manually:

mkdir -p build/logs build/coverage

The failonerror=on is needed to signal a failed build when phpunit returns an error. (It returns an error whenever it detects failed test). The command line arguments for PHPUnit are covered extensively in the PHPUnit documentation.

PhpCodeSniffer:

<target name="php-codesniffer">
  <exec executable="phpcs"
     dir="${basedir}/source"
     output="${basedir}/build/logs/checkstyle.xml">
    <arg line="--report=checkstyle
          --standard=PEAR
      ."/>
  </exec>
</target>

The command line arguments are documented in the php-codesniffer manual. A particularly useful parameter is –ignore, which gives you the option to ignore certain files when sniffing the code. Very useful if you have included external code which does not comply to your standards.

Putting the build.xml file together

Now we need to combine the targets to one target

 <target name="build" depends="checkout,php-documentor,php-codesniffer,phpunit" />

And to make sure the build target is the default target, we add the default attribute:

<project name="my_project" default="build" basedir=".">

The final build.xml file should look like this:

 <?xml version="1.0" encoding="UTF-8"?>
 <project name="my_project" default="build" basedir=".">
 <target name="build" depends="checkout,php-documentor,php-codesniffer,phpunit" />

 <target name="checkout">
 <exec executable="git" dir="${basedir}/source">
  <arg line="pull" />
 </exec>
 </target>

 <target name="php-documentor">
 <exec executable="phpdoc" dir="${basedir}/source">
  <arg line="-ct type -ue on -t ${basedir}/build/api
  -tb /usr/share/php/data/phpUnderControl/data/phpdoc
  -o HTML:Phpuc:phpuc -d ."/>
 </exec>
 </target>

 <target name="php-codesniffer">
 <exec executable="phpcs"
  dir="${basedir}/source"
  output="${basedir}/build/logs/checkstyle.xml">
  <arg line="--report=checkstyle
  --standard=PEAR
  ."/>
 </exec>
 </target>

 <target name="phpunit">
 <exec executable="phpunit" dir="${basedir}/source" failonerror="on">
  <arg line="--log-xml ${basedir}/build/logs/phpunit.xml
  --log-pmd ${basedir}/build/logs/phpunit.pmd.xml
  --log-metrics ${basedir}/build/logs/phpunit.metrics.xml
  --coverage-xml ${basedir}/build/logs/phpunit.coverage.xml
  --coverage-html ${basedir}/build/coverage
  CalculatorTest.php" />
 </exec>
 </target>
 </project>

Configuring CruiseControl

The central configuration file for CruiseControl is config.xml, which in our example can be found in /opt/cruisecontrol/config.xml For a detailed overview of the options available for this file, check the Cruisecontrol documentation. I am going to configure our project so that it periodically runs the build, even if nothing has changed.

First, rename the old config.xml file and replace it with an empty config.xml file:

<?xml version="1.0" encoding="UTF-8"?>
  <cruisecontrol>
    <project name="my_project" buildafterfailed="false">

    </project>
  </cruisecontrol>

The buildafterfailed=false attribute tells CruiseControl not to attempt a build if the previous one has failed and no changes have been found. If your tests depend on an external source that can fail, like a SOAP service or a database, it might be useful to set this value to ‘true’.

Then add the modification set:

<modificationset>
  <alwaysbuild/>
</modificationset>

The modificationset element lists the checks to find if anything has changed in the project. In this case we don’t check and always build.

Now we tell CruiseControl what to do:

  <schedule interval="60">
    <ant anthome="apache-ant-1.7.0" buildfile="projects/${project.name}/build.xml"/>
  </schedule>

In the schedule element is a list with tasks to do on each build. In this case, run Ant on the build.xml file we just created. The ant element also has an optional target attribute, where you can choose the target to build. The interval attributes specifies how many seconds to wait between builds. To enable the front-end to show the status of the build, we have to add a listener:

<listeners>
  <currentbuildstatuslistener file="logs/${project.name}/status.txt"/>
</listeners>

The listener element holds elements that can communicate the status of the build to other parts of the system. In this case the currentbuildstatus puts the status in an HTML snippet that the CruiseControl webserver can read.

Now we need a place to put all the information gathered during the build process:

<log dir="logs/${project.name}">
  <merge dir="projects/${project.name}/build/logs/"/>
</log>

To publish the results of the build we need a publisher:

 <publishers>
  <artifactspublisher dir="projects/${project.name}/build/api"
            dest="artifacts/${project.name}"
            subdirectory="api"/>
  <artifactspublisher dir="projects/${project.name}/build/coverage"
            dest="artifacts/${project.name}"
            subdirectory="coverage"/>
  <execute command="phpuc graph logs/${project.name}
           artifacts/${project.name}"/>
 </publishers>
 

The two arifactpublishers take the information from the build and puts them in a publicly accessible directory. The first one takes the files from build/api, which holds the api documentation generated by phpDocumentor. The second one is for the code coverage information. The execute element generates the nice-looking graphs for your manager.

The total config.xml file should look like this:

 <?xml version="1.0" encoding="UTF-8"?>
 <cruisecontrol>
 <project name="my_project" buildafterfailed="false">
  <modificationset>
  <alwaysbuild/>
  </modificationset>

  <schedule interval="60">
  <ant anthome="apache-ant-1.7.0" buildfile="projects/${project.name}/build.xml"/>
  </schedule>

  <listeners>
  <currentbuildstatuslistener file="logs/${project.name}/status.txt"/>
  </listeners>

  <log dir="logs/${project.name}">
  <merge dir="projects/${project.name}/build/logs/"/>
  </log>

  <publishers>
  <artifactspublisher dir="projects/${project.name}/build/api"
       dest="artifacts/${project.name}"
       subdirectory="api"/>
  <artifactspublisher dir="projects/${project.name}/build/coverage"
       dest="artifacts/${project.name}"
       subdirectory="coverage"/>
  <execute command="phpuc graph logs/${project.name}
       artifacts/${project.name}"/>
  </publishers>
 </project>
 </cruisecontrol>

You can now test your phpUndercontrol system.

To start CruiseControl:

cd /opt/cruisecontrol
./cruisecontrol.sh

And to stop it:

kill `cat /opt/cruisecontrol/cc.pid`

If you start up your browser go to http://[ip-address of ci server]:8080/cruisecontrol And click on the my_project link, you should see something similar to this:

Now we’re going to change the configuration file to only do the build after we have made change in the code.

Here you can find more information about how to use Git with CruiseControl

To enable CruiseControl to check Git we first have to add a plugin to the project:

 <plugin name="git" classname="net.sourceforge.cruisecontrol.sourcecontrols.git" />

And change the modification set:

 <modificationset quietperiod="60">
  <git localWorkingCopy="projects/${project.name}/source/"/>
 </modificationset>

The quietperiod attribute tells CruiseControl to wait with running a build for a minute after the last change to the repository. This gives you the opportunity to commit parts to the code without running the risk of breaking the build while you are still busy committing.

The final config.xml file should look like this:

<?xml version="1.0" encoding="UTF-8"?>
<cruisecontrol>
<project name="my_project" buildafterfailed="true">
  <plugin name="git" classname="net.sourceforge.cruisecontrol.sourcecontrols.GIT" />
  <modificationset>
   <git localWorkingCopy="projects/${project.name}/source/"/>
  </modificationset>
...
...
 

If you now run CruiseControl for a while, you will see that the last build time will not change. When you make a change to the code, commit it and wait for a minute or two, you will see that a new build has been run.

Two nice features

In this section I will briefly describe two of the very many nice features available in CruiseControl, sending out an email when things break, and setting up and tearing down a database.

Sending mails when things break

You can make CruiseControl send an email on build failure by adding a publisher to config.xml:

<publishers>
  <email mailhost="smtp.your.company"
      returnaddress="builder@your.company"
      returnname="My Project Build Status"
      defaultsuffix="@your.company"
      spamwhilebroken="false"
      buildresultsurl="http://[ci server]:8080/cruisecontrol">
    <failure address="you@your.company" reportWhenFixed="true"/>
    <failure address="yourboss@your.company" reportWhenFixed="true"/>
  </email>
 ......
 

This sends out an email to you and your boss when the build breaks and one when it’s fixed.

Setting up a database

CruiseControl can set up and tear down a database for you. Below the set-up of the database. The tear-down is left as an exercise.

Simply add a new target:

<target name="db-create">
  <sql driver="com.mysql.jdbc.Driver"
     url="jdbc:mysql://localhost:3306"
     userid="root"
     password="root"
     classpath="/usr/share/java/mysql.jar"
     src="${basedir}/db-create.sql"
     delimiter=";"/>
</target>

And add the target to de dependencies of the build target:

<target name="build" depends="checkout,db-create,php-documentor,php-codesniffer,phpunit" />

This uses the java mysql library, so we have to install that:

sudo apt-get install libmysql-java

To make the target work you also have to add a db-create.sql file to your project. I used this for the example:

DROP DATABASE IF EXISTS my_project;
CREATE DATABASE my_project;

And you can check if it is working by calling the target from Ant:

../../apache-ant-1.7.0/bin/ant db-create

In this example we hardcode the classpath in the target, but you can also add the CLASSPATH environment variable.

See the MySQL documentation for details.

This is how the phpUnderControl admin dashboard looks like, very nice!

You now have a working Continuous Integration system. Systems like this always take time to get setup and working properly. Now however, you have a powerful tool that will help you create better software faster. The return on investment in your time will be stable code and your client’s confidence in your work. Go and play around with phpUnderControl and discover more of its features and uses; spend the time to understand the system and customize it for your specific needs. The time you spend will be well worth it when you go to roll your next version into production.

If you are interested in Continuous Integration and want to read more about it, Continuous Integration by Paul M. Duval is a very good book on the subject.

More resources:

• Setting up phpUnderControl

• How to install cruisecontrol/phpUnderControl in Debian Etch

• Cruise Control and PHPUnderControl on Ubuntu 9.04

• Getting started with CruiseControl

• Zend webinar Continuous Integration with PHPUnderControl – Part 1 (English)

Last, but not least, Capistrano…

Now we can install Capistrano for our apps deployments… It is fairly simple; you can follow this couple of how-tos to get up and running!

• Deploying a CakePHP app with Capistrano
• DEPLOYING CAKEPHP APPLICATIONS USING CAPISTRANO

• Ubuntu server: for the OS & Git (Part 1)
1. Ubuntu server
2. Git (Gitosis for users admin)
3. Apache2, PHP (5 & 4) & MySql
4. PhpMyadmin
5. Cakephp configuration
• phpUnderControl: for source controls (Git), custom continuous builds, notifications schemes, documentation, code sniffing, etc… Plus Capistrano: for deployment …(Part 2)

Ubuntu server configuration: (Ubuntu Jaunty Jackalope (Ubuntu 9.04))

Most of the how-to is a compilation from various how-to’s I used… (Check them for further reference)
First, I pretty much follow this tut till page # 3:

The Perfect Server – Ubuntu Jaunty Jackalope (Ubuntu 9.04)

Installing Git

Now that we have a fairly simple and stable environment I prefer to configure Git and the SSH requires just in case something goes wrong it wouldn’t be such a pain to reinstall everything…
I pretty much only installed openssh-server and set up the keys so I don’t need to use password authentication (which is a requirement for Git). Don’t continue if you don’t have this set up because that’s why I was talking about reinstalling the whole thing again…

I also wrote on this previews post, a how-to about how to set up RSA key authentication in Eclipse or Aptana IDE

However, here are some good resources for SSH:

• Top 20 OpenSSH Server Best Security Practices
• SSH
• OpenSSH
• Keys
• Public and Private Keys
• HOWTO: SSH & Public Keys
• Secure your SSH server with Public/Private key authentification

This is the best tutorial I’ve found so far, and it has very good links references…

Installing Git on a server (Ubuntu or Debian)

Step 1: Install Git. You’ll have to do this ON BOTH YOUR SERVER AND LOCAL MACHINE. If you’re running a different OS for your client find and check out instructions for installing git on that OS instead. See this link for OS X if you don’t have Mac Ports.

sudo  apt-get update
sudo  apt-get dist-upgrade
sudo  apt-get install git-core

Step 2: Set up the server. We’ll have to do some work on the server. We’re going to use Gitosis which needs python and a python setup tool to get running. Grabbing the python setup tool in Debian/Ubuntu will grab all the requirements if you don’t already have them:

sudo  apt-get install python-setuptools

Step 3: Gitosis. Now it’s time to get Gitosis. For the most part I followed the instructions on scie.nti.st, so full credit and many thanks to them. Once you’re done with my instructions, I recommend you go visit them and read more details on adding users and some other advanced topics.
From your home directory on your server, create a new directory called src, and from there grab the gitosis code.

mkdir  ~/src
cd  ~/src
git  clone git://eagain.net/gitosis.git

Install it using the python setup tool we grabbed earlier.

cd  gitosis
  sudo  python setup.py install

Step 4: Setup some security. We’re next going to add a new user called git. This is the guy that will do all the heavy lifting for us!

sudo  adduser \
  --system \
  --shell /bin/sh \
  --gecos 'git version control' \
  --group
  --disabled-password \
  --home /home/git \
  git

IMPORTANT: If you have locked down ssh, don’t forget to go into your /etc/ssh/ssh_config file and add git to the list of Allowed Users that can login. That list of users is separated by a space not a comma.
I always encourage the use of public/private key exchange and in the case of gitosis it looks to be required. Generate a key if you haven’t already. See instructions for public/private key here. I’m going to assume that from this point on you can access your server from your local machine using a public key exchange!
Next, copy your id_rsa.pub file over to your server somewhere (in our example we’re using /tmp) and then run this command:

sudo  -H -u git gitosis-init < /tmp/id_rsa.pub

You’ll see output like this:

Initialized  empty Git repository in ./<br />
  Initialized  empty Git repository in .//source]<br />

  Others have reported seeing that 3  times but when I did it on Ubuntu Hardy Heron I only saw it twice.<br />
  <strong>Step 5: Minor permissions tweak.</strong> Just in case, let's make sure permissions are set  correctly: <br />

  [source='bash']sudo  chmod 755 /home/git/repositories/gitosis-admin.git/hooks/post-update

We’re now done with the server config! From your local machine, test it out with this:

git  clone git@YOUR_SERVER:gitosis-admin.git

If all went well you have a gitosis-admin directory with a gitosis.conf file and keydir directory. We’re basically setup now. We just need to create a new repository and push it to the server.

Also, as promised here are some resources: (I added a couple more)

• scie.nti.st
• Git Official site
• Railscast 96
• Peepcode
• Urban Puddle
• Installing Gitosis on Dreamhost
• Setting Up Git ACL Using gitosis
• Installing gitosis
• Installing a git server using gitosis
• “gitosis“ — software for hosting “git“ repositories

Now we can continue with the rest of the system configuration.

Set system locale:

sudo locale-gen en_US.UTF-8
sudo /usr/sbin/update-locale LANG=en_US.UTF-8

Install PHP with php client and without apache (one long line):

 sudo aptitude -y install php5-common php5-dev php5-mysql php5-sqlite php5-tidy  php5-xmlrpc php5-xsl php5-cgi php5-mcrypt php5-curl php5-gd php5-memcache  php5-mhash php5-pspell php5-snmp php5-sqlite libmagick9-dev php5-cli

Fix issues with imagick:

sudo aptitude -y install make php-pear
sudo pecl install imagick

(Just press <ENTER> at prompt)

Adjust php.ini memory limit:

 sudo vim /etc/php5/cgi/php.ini

Find line:

memory_limit = 16M and change it to: memory_limit = 48M

Append to the end of this file this line:

extension=imagick.so

For installing Apache2, PHP (5 & 4) & MySql check this tut

After the MySql install

mysql-server libapache2-mod-auth-mysql php5-mysql

I like to run

mysql_secure_installation

Phpmyadmin and mysql-admin

PhpMyAdmin is a very famous MySQL management software package. To use it you should install and configure PHP, Apache and php mysql (or mysqli) extension see ApacheMySQLPHP for instructions.

Install phpMyAdmin From Package
(source)

Install phpMyAdmin from the Universe repository see InstallingSoftware for detailed instructions on using repositories and package managers.

From console:

sudo apt-get install phpmyadmin

• If you’re using Ubuntu 7.10 (Gutsy) or later select Apache2 from the "Configuring phpmyadmin" dialog box.

To set up under Apache all you need to do is include the following line in /etc/apache2/apache2.conf.

Include /etc/phpmyadmin/apache.conf

• If you are using Ubuntu 9.04 (Jaunty), there is no need to modify /etc/apache2/apache2.conf as the package installer already copied the file phpmyadmin.conf into /etc/apache2/conf.d directory. You can also skip the set up step and go directly to http://<hostname>/phpmyadmin and login with the user and password you set up during install.

Once phpMyAdmin is installed point your browser to http://localhost/phpmyadmin to start using it. You should be able to login using any users you’ve setup in MySQL. If no users have been setup, use admin with no password to login.

Should you get a 404 "Not Found" error when you point your browser to the location of phpMyAdmin (such as: http://localhost/phpmyadmin) this is likely caused by not checking the ‘Apache 2′ selection during installation. To redo the installation run the following:

sudo dpkg-reconfigure -plow phpmyadmin

Then select Apache 2 for the webserver you wish to configure.

If this does not work, then you can do the following to include the phpMyadmin-shipped Apache configuration into Apache:

sudo ln -s /etc/phpmyadmin/apache.conf /etc/apache2/conf.d/phpmyadmin.conf
sudo /etc/init.d/apache2 reload

Troubleshooting Phpmyadmin & mysql-admin

If you get blowfish_secret error: Choose and set a phrase for cryptography in the file /etc/phpmyadmin/blowfish_secret.inc.php and copy the line (not the php tags) into the file /etc/phpmyadmin/config.inc.php or you will receive an error.

If you get a 404 error upon visiting http://localhost/phpmyadmin: You will need to configure apache2.conf to work with Phpmyadmin.

sudo vim /etc/apache2/apache2.conf

Include the following line at the bottom of the file, save and quit.

Include  /etc/phpmyadmin/apache.conf

These are the steps I followed in order to get cakephp working on my user public_html folder. (Source)
as many of you probably know, if you have apache’s userdir module loaded, you can put your web pages on /home/user/public_html , and access them with the url: http://localhost/~user/ . I really prefer this, so all my web pages are on my personal home, but how to configure cakephp to work with these paths, i got a hard time with this, but finally got it!. here’s how:

In case you don’t have apache2’s userdir module:

sudo ln -s /etc/apache2/mods-available/userdir.load /etc/apache2/mods-enabled/userdir.load
sudo ln -s /etc/apache2/mods-available/userdir.conf  /etc/apache2/mods-enabled/userdir.conf

You need the rewrite module also… (this could be done with the same method used for userdir)

sudo a2enmod rewrite

Now lets edit some apache files…

sudo vim  /etc/apache2/sites-enabled/mysite

Inside the first two <directory></directory> tags, change the AllowOverride lines:

	<Directory />
        Options FollowSymLinks
        AllowOverride All // change here
    </Directory>

    <Directory /var/www/>
        Options Indexes FollowSymLinks MultiViews
        AllowOverride All // change here
        Order allow,deny
        allow from all
        # This directive allows us to have apache2's default start page
        # in /apache2-default/, but still have / go to the right place
        #RedirectMatch ^/$ /apache2-default/
	</Directory>

Do the same on /etc/apache2/mods-enabled/userdir.conf

<Directory /home/*/public_html>
                AllowOverride All        // change here
                Options MultiViews Indexes SymLinksIfOwnerMatch IncludesNoExec
  </Directory>

Now you need to restart you apache2 server…<

sudo  /etc/init.d/apache2 restart

I’ll assume you’ve already downloaded cakephp latest release or that you know where you can find it

Unpack the downloaded file in /home/user/public_html/
rename the extracted folder (thats the name of your application)

cd /home/user/public_html/application_name

edit the .htaccess file so it look like these:

<IfModule mod_rewrite.c>
   RewriteEngine on
   RewriteRule    ^$ app/webroot/    [L]
   RewriteRule    (.*) app/webroot/$1 [L]
   RewriteBase  /~user/application_name/
</IfModule>

now point your browser to http://localhost/~user/application_name and you show see cakephp’s default page

Here you can find the second part of this how-to…