Intégration continue avec git, Maven et TeamCity

Quand on ne fait pas des PCB, il nous arrive de discuter d’intégration continue avec Brice. Il m’avait notamment parlé de TeamCity et cet outil avait piqué mon intérêt au vif, mais je n’avais pas pris le temps de tester. Récemment, j’ai lu un tutoriel sur Developpez.com sur « la mise en place d’une petite usine logicielle GitHub, CloudBees et Jenkins« . J’ai eu envie d’essayer de mettre en oeuvre une telle architecture, histoire de voir comment ça marche.

Pour cette expérimentation d’intégration continue, j’ai fait simple niveau code avec une application « hello-world » en Java. Ce projet Java se builde avec Maven. TeamCity permet de lancer automatiquement un build lorsqu’un commit est fait dans le repository Git. J’ai utilisé Eclipse Mars for Java Developers (installé avec Oomph) qui a l’avantage d’avoir des fonctionnalités intégrées pour s’interfacer avec Git et Maven. Le tout est installé dans un Xubuntu virtualisé avec VirtualBox.

Git

La partie Git n’a rien de bien sorcier. On installe Git, on crée son repository avec git init et voilà. On peut ensuite connecter Eclipse à ce repository grâce à EGit. La perspective Git est triviale à prendre en main et la documentation officielle est bien.

Maven

J’avais écrit un article sur mes débuts avec Maven. Vous y trouverez les bases sur cet outil ainsi que la procédure d’installation. Ici, j’ai préféré utilisé le wizzard d’Eclipse plutôt que la ligne de commande pour créer mon projet Java. Dans File / New, on trouve Maven Project. J’ai créé mon projet « hello-world » puis je l’ai partagé dans Git en faisant un clic-droit sur le projet dans le Package Explorer et en choisissant Team / Share Project…. Il est possible de créer des Run Configurations ou d’utiliser la ligne de commande pour le build du projet.

L’étape suivante a été de personnaliser les entrepôts pour le déploiement. Si vous ne modifiez pas la configuration de votre projet ou la configuration globale de Maven, voici ce qu’il se passe si vous tentez de déployer :

$ mvn deploy
[INFO] Scanning for projects...
[INFO] ------------------------------------------------------------------------
[INFO] Building hello-world

(...)

[INFO] Building jar: /home/pgradot/Documents/git/hello-world/hello-world/target/hello-world-1.0.1-SNAPSHOT.jar
[INFO] [install:install {execution: default-install}]
[INFO] Installing /home/pgradot/Documents/git/hello-world/hello-world/target/hello-world-1.0.1-SNAPSHOT.jar to /home/pgradot/.m2/repository/com/gradot/autobuild/hello-world/1.0.1-SNAPSHOT/hello-world-1.0.1-SNAPSHOT.jar
[INFO] ------------------------------------------------------------------------
[ERROR] BUILD ERROR
[INFO] ------------------------------------------------------------------------
[INFO] Failed to configure plugin parameters for: org.apache.maven.plugins:maven-deploy-plugin:2.4

check that the following section of the pom.xml is present and correct:

<distributionManagement>
  <!-- use the following if you're not using a snapshot version. -->
  <repository>
    <id>repo</id>
    <name>Repository Name</name>
    <url>scp://host/path/to/repo</url>
  </repository>
  <!-- use the following if you ARE using a snapshot version. -->
  <snapshotRepository>
    <id>repo</id>
    <name>Repository Name</name>
    <url>scp://host/path/to/repo</url>
  </snapshotRepository>
</distributionManagement>

Cause: Class 'org.apache.maven.artifact.repository.ArtifactRepository' cannot be instantiated
[INFO] ------------------------------------------------------------------------
[INFO] For more information, run Maven with the -e switch
[INFO] ------------------------------------------------------------------------
[INFO] Total time: 2 seconds
[INFO] Finished at: Sat Oct 03 13:09:35 CEST 2015
[INFO] Final Memory: 12M/31M
[INFO] ------------------------------------------------------------------------

Je suis gentil et discipliné, j’ai donc rajouté la section demandée dans mon pom.xml et j’ai créé les dossiers correspondants :

<distributionManagement>
	<!-- The following repositories will be used during the 'deploy' phase. -->
	<repository>
		<id>gradot-repository</id>
		<name>Gradot's Maven Repository</name>
		<url>file:///home/pgradot/Documents/maven/gradot-repository</url>
	</repository>
	<snapshotRepository>
		<id>gradot-repository-snapshots</id>
		<name>Gradot's Maven Repository for snapshots</name>
		<url>file:///home/pgradot/Documents/maven/gradot-repository-snaphots</url>
	</snapshotRepository>
</distributionManagement>

TeamCity

A ce stade, j’avais donc un projet Java versionné sous Git et pouvant être buildé avec Maven, qui va déposer les artefacts au bon endroit. Il ne me restait plus qu’à mettre en place TeamCity pour automatiser le build Maven quand un commit était fait dans Git.

TeamCity (la dernière version à ce jour est la 9.1) est à télécharger sur le site l’éditeur, JetBrains, au format tar.gz. Il suffit de décompresser l’archive à l’endroit souhaité puis de lancer le serveur avec la commande suivante :

./bin/runAll.sh start

Tout se passe ensuite par navigateur à l’adresse http://localhost:8111/. Lors du premier accès, vous devrez configurer quelques trucs et créer le compte administrateur avant d’arriver sur la page principale de TeamCity. TeamCity est un outil assez touffu, ses possibilités semblent gigantesques. On est un peu perdu la première fois mais j’ai réussi assez facilement à faire ce que je voulais, sans avoir à me taper la documentation, à part pour l’installation et le lancement.

J’ai commencé par aller dans le menu Administration (en haut à droite), d’où on peut créer de nouveaux projets, et j’ai créé mon projet « hello-world ». Depuis la page du projet, j’ai ensuite cliqué sur le bouton Create build configuration. Après l’avoir nommé, on m’a demandé à quel VCS je souhaitais connecter cette build configuration. J’ai choisi mon dépôt Git :

Une fois cette configuration créée, on peut cliquer dessus pour la modifier. Dans le menu de gauche, j’ai cliqué sur Build Steps, j’ai choisi Auto detect build steps, et, ô ! magie, il a trouvé Maven ! J’ai modifié la cible pour utiliser clean deploy à la place de clean test. La dernière étape est de configurer TeamCity pour lancer ce build automatiquement. En dessous de Build Steps, on trouve Trigger. J’ai choisi VCS et TeamCity ajoute tout seul un trigger sur check-in.

C’est tout. Oui, ce n’était pas bien compliqué. Maintenant, quand je commit avec Git, TeamCity se déclenche et un nouvel artefact est disponible dans mes entrepôts Maven. On peut voir l’avancement dans le menu Agent :

La page d’accueil montre les projets, on peut cliquer dessus pour voir les historiques de builds, on peut cliquer sur chaque build pour voir les tests JUint passés par Maven, etc :

Je suis séduis par cette expérimentation et notamment par TeamCity. Brice m’avait bien dit que c’était très rapide de faire son build automatique, il avait raison. Le plus long a en fait été d’avoir un projet mavenisé avec les cibles de déploiement correctement configurées. L’automatisation s’est faite presque tout seule 🙂

16 novembre 2015 | Catégories: Java, Outils | Tags: build automatique, git, intégration continue, teamcity | 1 commentaire