Intégration Continue (CI)

Le développement d’une application Web dynamique performante, évolutive, fiable doit se faire avec les meilleures pratiques de développement logiciel. Ces dernières assureront la qualité de l’application tout au long de son évolution.

Méthodologie

Agile

Selon Wikipédia :

L’intégration continue est un ensemble de pratiques utilisées en génie logiciel  consistant à vérifier à chaque modification de code source que le résultat des  modifications ne produit pas de régression dans l’application développée.

Afin de répondre à la commande de l’intégration continue, il devient impératif de mettre en place une série d’outils logiciels afin de tester efficacement le code qui évolue. Idéalement, il faut automatiser un grand nombre d’opérations afin de permettre au développeur de se concentrer sur l’évolution de l’application.

La suite de l’article vise à décrire les outils logiciels nécessaires pour implanter convenablement l’Intégration Continue dans votre projet de moyenne taille.

Outils logiciels pour l’Intégration continue

          Jenkins

Serveur d’intégration continue.

http://jenkins-ci.org/

$ java -jar jenkins.war

          phpUnit

Tests unitaires.

http://phpunit.de/manual/3.7/en/automating-tests.html

$ phpunit Tests

$ php phpunit.php

          phantom.js

Navigateur scriptable basé sur WebKit.

http://phantomjs.org/

$ npm install phantomjs

          Selenium

Tests d’intégration par automatisation de navigateur.

http://docs.seleniumhq.org/

$ java -jar selenium-server.jar -htmlSuite « *firefox » http://10.8.100.106
« C:\mytestsuite\mytestsuite.html » « C:\mytestsuite\results.html »

          Phing

Outil d’automatisation de tâches.

http://www.phing.info/docs/stable/webhelp/sec.commandlineargs.html

$ phing build.xml -Dftp.upload=true

          Vagrant et VirtualBox

Virtualisation des environnements de développement.

http://www.vagrantup.com/

$ vagrant box add base http://files.vagrantup.com/precise32.box

$ vagrant init

$ vagrant up

          Composer

Gestion des dépendances d’un projet PHP.

https://getcomposer.org/

$ php composer.phar install main.json

          Git

Outil de gestion contrôle de code source distribué.

http://git-scm.com/

$ git init

$ git clone

$ git add .

$ git commit –m « mon commentaire »

$ git push origin master

$ git pull

$ git status

          PhpDocumentor

Documentation automatique à partir du code source.

http://www.phpdoc.org/

            $ phpdoc -t /path/to/output -d path/to/directory1 ti My Title -o                                                        HTML:frames:phpedit

          phpCode Sniffer

Valide la qualité du code source selon une série de règles.

http://pear.php.net/package/PHP_CodeSniffer/

http://pear.php.net/manual/en/package.php.php-codesniffer.usage.php

$ phpcs -n /path/to/code/myfile.php
FILE: /path/to/code/myfile.php
--------------------------------------------------------------------------------
FOUND 5 ERROR(S) AFFECTING 5 LINE(S)
--------------------------------------------------------------------------------
  2 | ERROR | Missing file doc comment
 20 | ERROR | PHP keywords must be lowercase; expected "false" but found "FALSE"
 47 | ERROR | Line not indented correctly; expected 4 spaces but found 1
 51 | ERROR | Missing function doc comment
 88 | ERROR | Line not indented correctly; expected 9 spaces but found 6
--------------------------------------------------------------------------------

$ phpcs -i
The installed coding standards are Zend, PEAR, PHPCS, Squiz and MySource

          Code Coverage – phpStorm

https://www.jetbrains.com/phpstorm/webhelp/monitoring-code-coverage-for-php-applications.html

$ phpcs /path/to/code/myfile.inc /path/to/code/my_dir

Exemple de cycle d’intégration continue :

• Un développeur apporte une modification au code.
• Le serveur d’intégration continue récupère le code à tester et prépare son exécution (Jenkins et Phing)
  • Un environnement de tests virtualisé permet l’exécution du code développé (Vagrant et VirtualBox).
  • La base de données est configurée au besoin, elle contient des données de tests. (Phing & MySQL)
  • Les tests unitaires sont exécutés. (phpUnit)
  • Les tests d’intégration sont exécutés. (Selenium et Phanton.js)
  • Les normes de programmation du code sont vérifiées automatiquement. (phpCode Sniffer)
  • La documentation du code est mise à jour automatiquement. (phpDocumentor)
  • Un rapport est produit pour le développeur.
    • Si la création du paquet de déploiement est en échec,
    • le développeur doit corriger l’erreur qu’il a causée.
• Le code est déployé vers un environnement de production et le cycle se répète jusqu’à la prochaine modification de code.

Cette configuration permet aux équipes de développeurs de livrer un logiciel de qualité de façon stable dans le temps. Par contre, la mise en place d’un processus d’intégration continue demande une expertise et du temps.

Il est fortement recommandé de mettre en place un processus d’intégration continue en techniques d’intégration multimédia et au CIMMI. Débuter avec les options critiques et évoluer progressivement vers un processus plus complet.

• Cours touchés
  • Technologies interactives
  • Production multimédia VI
  • Production multimédia V
  • Programmation multimédia 1

Références

• http://www.viewtier.com/images/continuous_integration_memory_map.gif
• http://www.devopscloud.com/01.10.ci.html
• http://en.wikipedia.org/wiki/Jenkins_%28software%29

• Jenkins – Site officiel
• http://jenkins-ci.org/

• Jenkins | lalit
• http://www.site.lalitbhatt.com/jenkins

• People. Paper. Electrons | Branch Management Pattern part 2 of 3: Development on branch / Stemming
• http://www.ronaldwidha.net/2009/10/04/branch-management-pattern-part-2-development-on-branch-stemming/

• CloudMunch | Full Stack DevOps platform | DevOps automation | Cloud hosting
• Always Free for public repos and 1 private repo
• https://www.cloudmunch.com/