Atelier intégration continue

Le groupe Calcul propose un atelier de trois jours pour vous sensibiliser aux outils utilisés pour faire de l’intégration continue. Cet atelier se tiendra en salle 314 à l’IHP à Paris les 29, 30 et 31 mai 2017.

Lorsqu’on développe un code de calcul, seul ou à plusieurs, il est primordial de vérifier que chaque modification ne produit pas de régression dans l’ensemble de l’application. Il est donc nécessaire d’employer des tests unitaires, des tests d’intégration ou des tests du système complet. Ces tests s’intègrent dans un système de gestion de versions pour sauvegarder les modifications.

L’intégration continue fournit des outils permettant de valider l’intégrité du code à chaque soumission de modifications via github, gitlab, etc. Si, auparavant, il était assez fastidieux de mettre en oeuvre et d’administrer une chaîne d’intégration continue, les outils actuels sont très faciles à déployer. Ils offrent de plus des fonctionnalités qui permettent d’aller bien plus loin que la simple exécution de tests : la couverture du code, la validation syntaxique, la construction d’images de conteneurs et leur déploiement sur un dépôt, etc.

Durant cet atelier de trois jours, nous vous familiariserons à trois outils d’intégration continue : Jenkins, Travis CI et Gitlab CI, en commençant par une introduction à deux outils couramment utilisés dans une chaîne d’intégration continue : Git pour gérer les versions et les publier vers un dépôt distant, puis Docker pour exécuter les tâches de compilation et de tests.

Organisateurs

 Matthieu Boileau (IRMA/CNRS)
 Loic Gouarin (LMO/CNRS)
 Pierre Navaro (IRMAR/CNRS)

Lieu

salle 314 à l’IHP.

Horaires

Lundi 29 mai 2017 : 9h30 - 18h
Mardi 30 mai 2017 : 9h - 18h
Mercredi 31 mai 2017 : 9h - 17h

Inscription

Les inscriptions pour cet atelier sont gratuites mais obligatoires.
Du fait de la taille de la salle, le nombre de participants est limité à 30 personnes.
Les inscriptions sont actuellement closes.

Programme

Lundi 29 mai 2017

  9:30-10:00 : Accueil
  10:00-11:30 : Introduction à Git, Alexandre Ancel (IRCAD)
  11:45-12:30 : Docker [1/3], Alexandre Ancel (IRCAD)
  14:00-18:00 : Docker [2/3], Alexandre Ancel (IRCAD)

Mardi 30 mai 2017

  9:00-10:00 : Docker [3/3], Alexandre Ancel (IRCAD)
  10:15-12:30 : Jenkins [1/2] Johan Moreau (IRCAD),
  14:00-15:30 : Jenkins [2/2] Johan Moreau (IRCAD),
  15:45-18:00 : GitLab CI [1/2], Benoît Bayol (CentraleSupélec)

Mercredi 31 mai 2017

  9:00-10:45 : GitLab CI [1/2], Benoît Bayol (CentraleSupélec)
  11:00-12:30 : Travis CI [1/2], Loïc Estève (INRIA)
  14:00-16:30 : Travis CI [2/2], Loïc Estève (INRIA)
  16:30-17:00 : Synthèse sur les outils

Résumés

Docker et Jenkins : Alexandre Ancel et Johan Moreau

Depuis quelques années, les méthodes agiles ont fait évoluer la manière de réaliser des logiciels. Entre les valeurs (communication, simplicité, …) et les pratiques (petites livraisons, tests, …) de ces méthodes, l’intégration continue joue un rôle fondamental dans ces processus. Se basant sur la possibilité d’accéder au code à tout moment et la
possibilité de construire l’application de manière automatique, cet outil devient le chef d’orchestre de la cadence de développement. De nombreux outils existent depuis quelques années, mais un changement récent dans les infrastructures informatiques redistribuent profondément les cartes. En effet l’arrivée des conteneurs logiciels modifient la manière de créer des applications, avec la notion d’architecture micro-services, et donc par effet de bord, la manière donc l’intégration continue fonctionne. Après une introduction sur ces éléments, nous verrons le principal outil pour la gestion des conteneurs logiciels (Docker) puis un outil très répandu pour l’intégration continue
(Jenkins). Nous évoquerons ensuite par évoquer la mise en production avec la problématique du déploiement continu. Nous finirons par une comparaison des outils d’intégration continue

GitLab-CI : Benoît Bayol

Pourquoi et comment faire de l’intégration continue dans un environnement scientifique à l’aide de gitlab ?

L’intégration continue est une bonne pratique de développement logiciel permettant notamment d’améliorer la qualité des simulateurs et modèles numériques écrits collaborativement en automatisant les passages de tests unitaires, d’intégration et de non-régression. C’est une étape importante à maîtriser afin de tendre vers une meilleure reproductibilité des expériences virtuelles en limitant l’introduction de régression notamment.

Gitlab est un logiciel open-source qui a vu le jour en 2011 et qui possède des fonctionnalités permettant de faire de l’intégration continue au moyen d’un simple fichier ".gitlab-ci.yml" à la racine de votre dépôt git. Ce fichier contient des instructions permettant d’effectuer des tâches sur des serveurs distants ("runner") afin de construire le logiciel et de le tester.

Dans cet atelier nous verrons donc :

 le flux de développement général au moyen de gitlab dans le cadre de l’intégration continue
 les bases de l’intégration continue au moyen du fichier ".gitlab-ci.yml"
 l’utilisation d’un "runner partagé" et d’un "runner privé" ainsi que les questions de sécurité que cela pose.
 l’utilisation de Docker sur les "runners" afin d’avoir des environnements de tests distincts

Travis : Loïc Esteve

Travis est une plateforme d’intégration continue utilisée par un grand nombre de projets open-source.

Après une court exposé sur comment configurer Travis, la séance sera en majeure partie un TP qui couvrira :

 matrices de build
 cache Travis
 utilisation de docker

Prérequis à installer

 Git : pas de version minimale nécessaire. Git est natif ou très bien empaqueté pour Linux et Mac. Pour Windows, ce projet devrait vous permettre de l’installer
 Docker : si possible la version 1.13, voire 17.03-ce.