At Les-Tilleuls.coop, we built great e-commerce platforms and high-performance web applications with quality and agility in mind.
Most of our applications share the same technical stack:
the PHP language with the Symfony framework and Doctrine for back applications
front applications developed with CoffeeScript or JavaScript, AngularJS and Twitter Bootstrap (Grunt as build system, Yeoman for scaffolding, Karma and Jasmine for tests)
private Git repositories (hosted on GitHub)
private libraries and bundles shared between applications and exposed as Composer packages
phpspec unit tests
Doctrine Data Fixtures (enhanced with Alice and Faker)
Behat scenarios
exhaustive PHPDoc
capifony scripts for deployment
I managed to build a pretty cool CI system allowing us to deliver high quality Symfony applications. In this tutorial, you’ll see how it looks and how to install it step by step. If you aren’t using a CI system, it will increase drastically the quality of your Symfony projects and over the time, it will increase your team your development skills.
Our CI system mostly relies on Jenkins. At every commit (on every branch) it:
updates our private Composer package repository index
runs all tests and scenarios, including web acceptance test trough headless and real browsers
runs a bunch of quality checks on the code: security issues, dead code and code duplication detection, cyclomatic complexity analysis, good structuration and following of Symfony’s best practices
checks Coding Standards conformance
generates a browsable API documentation
instantly deploys the new version of the application on testing and sometimes even production servers (continuous deployment)
Finished feature branches are reviewed and merged in the master branch through GitHub Pull Requests by a lead dev only when all tests and checks are green.
The following tutorial can be followed on Debian (wheezy) and Ubuntu.
Installing Jenkins
The Jenkins team maintains a Debian repository providing up to date binary packages. Add it to your CI box and install the package (as root):
If nothing goes wrong, the Jenkins UI is now available on the port 8080 of your CI box. Open the UI in your favorite web browser. So easy.
Securing the installation
Currently, anyone knowing the URL of your Jenkins install can take the control over it. It’s a good idea to set credentials required to access the CI:
go to “Manage Jenkins” then “Setup Security”
check “Enable security”
in the “Security Realm” section, select your user provider (“Jenkins’ own user database” is a good default if you don’t have a LDAP directory or any other centralized user provider for your organization)
don’t forget checking “Allow users to sign up”, it’s mandatory to be able to log in after enabling the security
in the “Authorization” section, choose “Project-based Matrix Authorization Strategy”, leave all checkboxes for “anonymous” empty and create a super admin user having all rights
enable CSRF protection by checking “Prevent Cross Site Request Forgery exploits”
save and go back to the homepage
you’re prompted to authenticate, click “Sign up” and create an account with the same username you given administration rights earlier
Jenkins is now secured! Go back to security settings to disable the signup form.
Connecting Jenkins with GitHub repositories
Jenkins must be able to pull data from your privates GitHub repository. The best way I found is to create a GitHub machine user with a read-only access to private repositories. You can add users with read only access to your repositories from GitHub by clicking “Settings” then “Collaborators”. For security reasons, remember to give only the read permission to the machine user.
Now, we’ll create private and public SSH keys for the UNIX account running Jenkins (on Debian it is called
):
The last step is adding the public key to the GitHub account of the machine user. From GitHub’s homepage, logged in as your machine user account, go to “Settings” then “SSH Keys”. Add a new key with the content of
.
Jenkins is now able to connect to our GitHub repositories.
Installing PHP
The PHP interpreter is needed to run our projects tests and other tools such as Composer and Satis. Install it:
You noticed that I also installed APC to speed up script execution. I’ve also installed SQLite. I use it as DBMS for the
environment of Symfony applications.
Installing Satis
Satis is the most popular (and the only open source) private Composer package repository. This tool generates a static Composer index. Later, we will add a task in Jenkins to rebuild the repository at each commits. It will allow us to have an always up to date Composer Package Repository. To do that, we must install Satis and make the
user must able to run it.
Satis must be installed through Composer. Switch to the
user and start by installing Composer, then Satis:
Then, create a config file for Satis called
:
This config file will enable 2 privates Composer packages (
and
). Thanks to the SSH keys we configured later, the
user is able to connect to our privates GitHub repositories. Of course those repositories must have a
file at their root. Full configuration options of Satis is documented on the Composer website.
Generate the package repository manually for the first time:
The next and step is exposing our packages over HTTP. We will use nginx to do it. Switch back to the root user (
) and type:
Then change the content of
by the following:
Don’t forget to replace
by the list of IPs allowed to access the package repository. It will prevent exposing your private repository on the whole internet.
Restart nginx:
We should be able to browse the repository through our favorite web browser.
Enabling Git and GitHub support
Git and GitHub support are available through plugins. Go to “Manage Jenkins” then “Manage Plugins” and install plugins called “Git Plugin” and “GitHub Plugin”. Their names should be explicit.
Then, we will setup a GitHub Webhook to trigger a build every time a commit is pushed, in any branch.
Go to your GitHub repository, click on “Settings” then “Webhooks & Services”. Click on the “Add service” select box and choose “Jenkins (GitHub plugin)”. Enter your Jenkins’ webhook endpoint in the box, it should be something like
(just replace the domain part of the URL) and click “Add service”.
The webook is set! Jenkins will be notified every time we push something our GitHub repo. Repeat this step for every GitHub repository you want to trigger builds.
Installing PHP CS Fixer
PHP CS Fixer is an awesome tool provided by SensioLabs. It’s 1.0 version has just been released. It automatically fixes PSR-0, PSR-1, PSR-2 and Symfony coding standard violations.
With its
option, it can be used in our CI to check if the produced code is clean.
PHP CS Fixer is packaged as a PHAR archive. Lets install it:
Installing phpDocumentator
phpDocumentator generates a beautiful HTML documentation based on DocBlocks documenting your classes and methods.
As for PHP CS Fixer, we will install its PHAR version, but before downloading it, we need to install some extra Debian packages:
Web Acceptance Testing with Behat and PhantomJS
We love Behat and Mink. We use them to manage our user stories and to run automated web testing scenarios.
Standards Symfony controllers are tested with the Symfony2 extension. But nowadays, we create more and more Single Page Applications usually composed of a Symfony 2 backed JSON / REST API and an AngularJS client.
It sounds like a good idea to also test interactions between AngularJS clients and Symfony REST API in the CI system. Behat and Mink will help.
I usually use Mink Selenium2 to drive PhantomJS, an awesome headless browser based on Webkit. Unlike the Symfony2 extension, the PhantomJS needs to access the application trough a public URL. We need a front controller exposing the
environment. Lets write it. We will also configure the built-in web server provided by Symfony to avoid configuring a heavier solution like nginx + PHP FPM.
The first step is to create a new front controller for the
environment (Symfony comes with front controllers for
and
environments but not for
).
Create a new front controller called
in the
directory your application. It should contain something like the following:
We also need a custom router for the built-in web server. It will allow to use the
env. Create a file in the
directory of your application called
. Here is the sample code:
The next step is to install PhantomJS. The PhantomJS package is not available in Debian stable. We will fallback to the binary version provided on the official website:
The
file of your project must be changed to specify the base URL and the Selenium2’s WebDriver host to use. Here is a sample file:
You are ready to write scenarios testing the whole app. They will be executed at each commit! To test consistency across browsers and platforms (mobile devices, exotic systems…), you can take a look to SauceLabs. This SaaS platform is well integrated with Behat and can be a good (but more expensive) replacement to PhantomJS!
Checking code quality with SensioLabs Insight
SensioLabs published earlier this year a SaaS platform running quality analysis for PHP and especially Symfony projects. That service is called Insight. It’s user friendly, cool to play with (it provides some gamification with a system of “medals”) and finds a lot of bad practices in bundles and Symfony applications.
The first step is to create an account and register your project on the Insight website. Configure your credentials, set the Git repository to analyse and run manually a first analysis. You will probably find some problems in your app that must be fixed!
SensioLabs Insight provides a tool allowing to run new analysis in a CI system. Like other tools we already installed, the insight command is available as a PHAR. Download it as the
user:
Find the uuid of the project you want to analyse with the following command:
The first time you’ll use
, you’ll be prompted for your user id and API token. You can find them in your SensioLabs Insight account page (“API/SDK” tab). Your credentials will be saved by
.
We are now able to integrate SensioLabs Insight in the Jenkins script. Write the uuid of your project somewhere, we will need it later.
Insight can output violations in the PMD format. You guessed it, Jenkins has a PMD plugin able to display nicely that sort of output.
Go to “Manage Jenkins”, “Plugin Manager”, click on the “Available” tabs and search for “PMD plugin”. Install it.
SensioLabs Insight is free for public open source projects but a subscription is needed to analyse private projects. I think it’s a good investment but I can’t blame you if you prefer using open source softwares. Sebastian Bergmann (the author of phpunit) maintains a great documentation explaining how to set up open source quality checking tools including PHPMD, phploc, PHP_Depend and phpcpd. Fell free to complete your installation with jenkins-php.org.
Note: at the time I write these lines there is some issues with the PMD output and the fail-condition option of the insight command. I’ve submitted fixes to them and I hope they will be integrated soon in the PHAR file.
Continuous Deployment with Capifony
It’s always good to have a testing server running the last version of the project. Sometimes, we go one step beyond and we let Jenkins pushing stable code in production thanks to Git’s tags (not detailed here).
Anyway, I use a tool you probably already know: capifony. It’s a deployment software specialized for Symfony projects built on top of Capistrano. It’s the easy way to deploy your application. It handle copying the source code to the server using Git, setting correct directory permissions, installing project’s dependencies, running database migration scripts, restarting services such as PHP FPM and many more. If you don’t already use it, give it a try, you will love it.
Like most Ruby applications, capifony is available as a gem. There is nothing easier than installing it on Debian:
Creating the Jenkins project
Go back to the Jenkins Dashboard and click on the “create new jobs” button. On the next screen give a name to your project and choose “Freestyle project”.
On the next screen:
fill the “GitHub project” input with the base URL of your GitHub repository
In the “Source Code Management” section:
select “Git” as “Source Code Management”
in “Repository URL”, enter the SSH clone URL of your Git repository (it must be like
)
click the “Add” button below “Credentials”
choose “SSH Username with private key” as “Kind”
choose “From a file on Jenkins master” for “Private Key” and click “Add” (It allows to use SSH keys we created and added to GitHub in the previous step)
set “Branches to build” to empty (to build all branches of the repository)
select “githubweb” as “Repository browser” and enter the URL of your repo’s homepage again
In “Build triggers”:
check “Build when a change is pushed to GitHub”
In “Build”:
Add a new “Execute shell” build step and use the following script as a template to fit your own needs:
Basically, the script run the various tools we installed earlier and don’t stop when an error occurs. Instead, it collect the return status of commands, and returns at the end of the script if the build is successful or not. It allows to always run all checks, even if one fail. The deployment (if enabled) only occurs if the build is successful. The built-in web server and PhantomJS run in background to allow them working simultaneously with Behat. They are killed after Behat exited. Be sure to replace the SensioLabs project identifier with yours.
Why not a XML file? Because I sometimes use other build servers such as Travis CI and Bamboo. Using a simple shell script allows to easily replace Jenkins with another server. Shell scripts can also be versioned directly in the Git repository.
In “Post-build Actions”:
Add the “Set build status on GitHub commit” step
Add “Publish JUnit test result report” and specify
for “Test report XMLs”
Add “Publish PMD analysis results” and specify
for “PMD results”
Add “Publish Javadoc” and set
as “Javadoc directory”
Add other actions you’re interested in (like sending mails)
Troubleshooting GitHub API rate errors
If your start getting errors like “Could not fetch https://api.github.com/[...], enter your GitHub credentials to go over the API rate limit” in the console output, it’s because you exceed GitHub API rates for anonymous users. Just open a shell, switch to the Jenkins user, download something with Composer and enter your machine user credentials when prompted:
Because Composer stocks an OAuth in
, all next calls to GitHub will succeed, even when launched by Jenkins.
Troubleshooting mails
To make Jenkins able to send mails (when a build fails for instance), you need to configure a SMTP server. The easier way is to install a local server on your CI server:
Default options should be OK.
To customize mail parameters, from the Jenkins homepage go to “Manage Jenkins” then “Configure System”. SMTP settings are under the “E-mail notification” section and the address used by Jenkins to send mails in “Jenkins Location”.
Updating automatically the localy installed tools
As any software, all tools used by our CI server get updates fixing bugs and adding new features. Debian and Jenkins can be updated using
. Jenkins plugins updates are managed directly trough the Jenkins user interface. But software we installed locally must be updated “by hand”. We will periodically run a small shell script I’ve written to update those tools.
Create the following
script as the
user in its home directory (
):
Don’t forget to make it executable by executing
. To get the updates every night, run
and add the following line:
You’re CI system is now ready. Your full test suit and quality analysis are running against new produced code in realtime! We also have quality checking and tests specifics for our frontend apps. Maybe If people are interested about that, maybe I’ll write another post detailing our infrastructure.
I’m sure you have your own preferred quality tools and CI best practices for Symfony projects. Share them with us in the comments