Affichage des articles dont le libellé est git. Afficher tous les articles
Affichage des articles dont le libellé est git. Afficher tous les articles

mardi 29 juin 2010

Intégration Continue php avec hudson/jenkins et git

L'intégration continue en PHP

Le but de cet article est d'expliquer comment mettre en place, à minima, un processus d'intégration continue en php, en se basant sur le serveur d'intégration continue Hudson, et le SCM git.

Le processus d’intégration continue a pour objectif de vérifier que chaque mise à jour du code source ne génère pas de régressions ou d’anomalies. Le concept est très lié à la vision eXtreme Programming (XP).

Globalement, le serveur d'intégration continue scrute le dépôt de code (SVN, GIT, ...) à la recherche de modifications, et le cas échéant, il descend ces modifications, et lance une construction du projet.
Une fois le projet construit, il peut lancer plusieurs étapes de validation du code produit :
  • Tests unitaires (junit, phpunit, ...)
  • Tests fonctionnels
  • Vérification de style (checkstyle)
  • Vérification de duplication de code
  • Génération de la documentation

Le serveur génère et/ou envoi un rapport contenant toutes les statistiques sur son build (tests échoués, qualité du code, ...)

Il peut même aller jusqu'à déployer l'application si tous les tests ont été passés avec succès.


Les éléments mis en place ici seront :
  • Installation du server d'intégration continue Hudson, maintenant Jenkins
  • Ecriture d'un build Phing pour automatiser nos tâches
  • Génération automatique de la documentation API avec phpDocumentor
  • Automatisation de test unitaires avec PHPUnit
  • Vérification automatique de bonnes pratiques de développement avec PHP_CodeSniffer
  • Détection de code dupliqué avec phpcpd

Présentation des outils

Hudson
Phing

Installation et utilisation

Pour l'installation, tout a été fait sur une debian squeeze, donc il vous faudra peut être adapté un peu selon votre distribution.
Installation d'Hudson
On commence par installer java et daemon, dont a besoin hudson
apt-get install sun-java6-jre daemon
wget -O /tmp/key http://hudson-ci.org/debian/hudson-ci.org.key
apt-key add /tmp/key
wget -O /tmp/hudson.deb http://hudson-ci.org/latest/debian/hudson.deb
dpkg --install /tmp/hudson.deb

Attention, par défaut, sous squeeze, Hudson écoutera sur les adresses ipv6, pour contrer cela, il faut ajouter au fichier /etc/default/hudson :
JAVA_ARGS="-Djava.net.preferIPv4Stack=true"
Voilà, Hudson est maintenant installé, et accessible via http://localhost:8080
On va tout de suite installer les plugins dont on va avoir besoin par a suite, via la page "plugins" d'Hudson.
Voilà, avant d'aller plus loin dans la configuration de Hudson, nous allons préparer le code et le SCM à utiliser.

Ecriture du code
Vous pouvez télécharge ce petit morceau de code qui implémente très succinctement une gestion de compte bancaire, avec les tests unitaires adéquats.

Phing
Afin de pouvoir permettre à Hudson de construire notre projet, nous allons écrire le script phing qui fera toutes les étapes décrites précédemment :

  
  
  

  
    
    
  

  
    
    
    
    
    
  

  
  
    
      
        
      
    
  

  
  
    
    
  

  
  
    
    
  

  
  
    
    
  

  
  
    
    
  



Installation du serveur git
N'importe quel serveur git fera la faire, vous pouvez par exemple suivre l'installation de gitolite

Il faut faire en sorte que Hudson puisse descendre le projet git, on va donc ajouter sa clef publique au serveur git.
Pour la générer, avec le compre hudson :
ssh-keygen -t rsa
Il faut ensuite ajouter la clef à la liste des clefs autorisées sur le serveur git
su - gitadmin
cd gitolite-admin
echo "..." > keydir/hudson.pub
git add keydir/hudson.pub
Et autoriser hudson à accéder au projet :
vi conf/gitolite.conf
  repo bank
    RW = gitadmin
    R = hudson
git commit -m "hudson"
git push
Voilà, maintenant Hudson peut enfin accéder aux sources.

Création du build hudson
On a maintenant toutes les clefs pour créer notre projet Hudson.
Rendez-vous donc sur http://localhost:8080 pour créer le build.



Ensuite, on va dire à Hudson comment récupérer les sources du projet :

Puis fournir la commande qui permettra de lancer le build phing :



Et enfin la configuration des rapports à produire grâce aux différents plugins installés :

Voilà, la configuration est à peu près terminé, on peut maintenant lancer le build et voir la qualité du code produit :).

Si tout se passe bien vous devriez avoir un bel écran plein de vert :

mardi 8 juin 2010

Installation de gitolite sur debian

Git

Citation : Wikipédia (fr)
Git est un logiciel de gestion de versions décentralisé. C'est un logiciel libre créé par Linus Torvalds, le créateur du noyau Linux, et distribué sous la GNU GPL version 2.
Git seul permet de créer et d'utiliser pleinement un dépot privé (local), ou un dépot public sans gestion des droits d'accès) via git-daemon.

Pour héberger un dépot git, et avoir une gestion plus fine des droits d'accès, il faudra passer par un serveur tiers : gitosis, ou comme ici, gitolite, une réécriture du premier.

Gitolite

Gitolite permet d'héberger des dépôts git, en y ajoutant une gestion des droits d'accès, non seulement par dépôt (comme le fait déjà gitosis) mais aussi par branche et par tag. Il permet notamment de préciser si un utilisateur (ou groupe d'utilisateur) a le droit de push sur une branche.

Gitolite permet de gérer un grand nombre de dépôt et d'utilisateurs, sans même avoir besoin de leur donner un compte sur le serveur, mais juste en intégrant leur clef publique.

Installation


Pré-requis


Pour ces explications, je me base sur une Debian Squeeze, mais le principe reste le même pour une autre distribution. Attention cependant aux distributions un peu anciennes : la version packagée de git sur Lenny est trop ancienne pour gitolite.

Préparation


Gitolite nécessite un utilisateur particulier pour gérer les dépots, il est possible d'utiliser root, mais je préfère créer un compte gitadmin.
L'utilisateur gitadmin doit pouvoir se connecter sur le compte git, il faut donc jouer un peu avec les clef ssh :
adduser --system --shell /bin/bash --password gitadmin --gecos 'git version control' --group --home /home/gitadmin gitadmin
adduser --system --shell /bin/bash --password git --gecos 'git version control' --group --home /home/git git

Se connecter avec le compte gitadmin, créer sa clef publique et ajouter la clef de gitadmin à la liste des clefs autorisées de git:
su - gitadmin
ssh-keygen
ssh-copy-id -i ~/.ssh/id_rsa.pub git@localhost


Installation de gitolite


La première chose à installer est bien entendu git :
apt-get install git-core

Ensuite, pour installer gitolite, nous allons cloner le dépot :
git clone git://github.com/sitaramc/gitolite.git
cd gitolite
src/gl-easy-install git localhost gitadmin

Le script d'installation va poser plusieurs questions, la réponse par défaut ira très bien.

Configuration


La configuration de Gitolite est très simple. Elle se fait via un dépôt de configuration gitolite-admin, clôneé dans le répertoire personnel de gitadmin. C'est dans celui-ci que nous configurerons les dépôts.
Cette configuration comprend un fichier et un dossier :
  • conf/gitolite.conf : fichier de configuration de Gitolite, contenant les dépôts, leurs utilisateurs/groupes et leurs droits associés.
  • keydir/ : dossier contenant les clés publiques des utilisateurs, sous la forme username.pub.:

La configuration de Gitolite utilisant un dépôt Git spécifique, il sera nécessaire de commiter les changements effectués pour qu'ils prennent effet, c'est pour cela qu'il est nécessaire de se situer dans le dossier de configuration pour appliquer des changements.

Rendez-vous donc dans le dépôt gitolite-admin de votre utilisateur admin :
cd ~/gitolite-admin


Utilisation


Nous allons créer un dépôt, ou gitadmin aura les droits lecture/écriture, mais où un utilisateur gituser (utilisateur non lié au serveur), n'aura que le droit de lecture.
vi conf/gitolite.conf
repo test
RW+ = gitadmin
R = gituser

git add conf/gitolite.conf


Ensuite, on doit importer le clef publique de gituser (créé sur son poste), et la commiter.
vi keydir/gituser.pub

git add keydir/gituser.pub
git commit -m "add repo test and user gituser"
git push

Le push permet de réellement mettre les modifications en production.

Ensuite, il nous reste à tester sur notre poste que tout va bien :
git clone git@localhost/test.git
cd test
touch README
git add README
git commit -m "readme file"
git push
=> W access for test DENIED to gituser


On voit donc bien que gituser n'a pas le droit d'ecrire sur le dépôt.

Voilà, on a maintenant un serveur git disponible, sur lequel on peut gérer finement les droits d'accès.
Pour plus d'informations, je vous invite à vous rendre sur le site de gitolite.

Ma prochaine étape sera d'essayer de pousser plus loin la gestion des droits, notamment sur les branches.