Accueil > Devops > Intégration continue : Docker, Jenkins, Azure, apk

Intégration continue : Docker, Jenkins, Azure, apk

L’objectif de cet article est de présenter la mise en place d’un serveur d’intégration continue dans le cloud azure avec le gestionnaire de conteneurs linux docker. Une première partie consiste en l’installation des logiciels nécessaires à l’utilisation de docker ( boot2docker, docker machine ) sur un poste fonctionnant sous Windows 7 Professionnel.

Une deuxième partie consiste en la création de la machine virtuelle sous azure et nous verrons comment déployer jenkins avec des plugin gradle, git et un sdk dans le cloud azure.
Dans une troisième partie, nous verrons comment paramétrer le serveur jenkins pour générer nos apks et le déployer sur notre compte de stockage azure.

Installation des logiciels nécessaires pour l’utilisation de docker sur un poste windows

 

Docker

Docker est un gestionnaire de conteneurs linux. Celui-ci va nous permettre de définir des environnements logiciels de développement, de test, d’intégration, de production de manière identique. Nous construisons une image docker depuis laquelle nous pouvons déployer notre conteneur docker sur n’importe quelle plateforme, grâce aux commandes docker. De plus, un serveur peut exécuter plusieurs conteneurs.
Pour construire ou stocker ces images docker, il existe un référentiel : https://registry.hub.docker.com Illustration de l’architecture docker :

Img1

Boot2docker

Boot2docker est l’outil que nous allons démarrer pour pouvoir utiliser docker sur notre poste windows.
C’est à l’intérieur de cette machine virtuelle que nous allons utiliser le client docker pour windows pour construire une image docker, la lancer…
Voici deux liens qui vont nous assister dans cette étape, n’oubliez pas d’installer MINGW si celui-ci fait défaut sur votre poste.
https://youtu.be/TjMU3bDX4vo et https://github.com/boot2docker/windows-installer/releases/latest A la fin de l’installation, vous obtiendrez en lançant la commande « boot2docker ssh », l’écran suivant :

Img2

Docker machine

Nous allons utiliser docker machine pour déployer une machine virtuelle sur azure.
Pour installer cet outil : lancez MINGW et exécutez les commandes.

$ curl -L https//get.docker.com/builds/Windows/x86_64/docker-latest.exe > /bin/docker
$ curl -L https//github.com/docker/machine/releases/download/v0.2.0/docker-machine_windows-amd64.exe > /bin/docker-machine

 

Le dockerfile

FROM jenkins
# deploy a jenkins to build android sample https://github.com/googlesamples/android-TextLinkify
MAINTAINER REGLY# update to be able to run aapt under jenkins
USER root
RUN dpkg –add-architecture i386 && apt-get update && apt-get install -y lib32z1 libstdc++6:i386# install necessary plugins under jenkins
RUN mkdir -p /usr/share/jenkins/ref/plugins
ADD https://updates.jenkins-ci.org/download/plugins/scm-api/latest/scm-api.hpi /usr/share/jenkins/ref/plugins/scm-api.hpi
ADD https://updates.jenkins-ci.org/download/plugins/git-client/latest/git-client.hpi /usr/share/jenkins/ref/plugins/git-client.hpi
ADD https://updates.jenkins-ci.org/download/plugins/git/latest/git.hpi /usr/share/jenkins/ref/plugins/git.hpi
ADD https://updates.jenkins-ci.org/download/plugins/credentials/latest/credentials.hpi /usr/share/jenkins/ref/plugins/credentials.hpi
ADD https://updates.jenkins-ci.org/download/plugins/ssh-credentials/latest/ssh-credentials.hpi /usr/share/jenkins/ref/plugins/ssh-credentials.hpi
ADD https://updates.jenkins-ci.org/download/plugins/gradle/latest/gradle.hpi /usr/share/jenkins/ref/plugins/gradle.hpi
ADD https://updates.jenkins-ci.org/download/plugins/windows-azure-storage/latest/windows-azure-storage.hpi /usr/share/jenkins/ref/plugins/windows-azure-storage.hpiRUN mkdir -p /usr/share/jenkins/android
RUN chown -R jenkins « $JENKINS_HOME » /usr/share/jenkins/androidUSER jenkins
# Install Android SDK
RUN cd /usr/share/jenkins/android && wget -nv -O – http://dl.google.com/android/android-sdk_r24.1.2-linux.tgz | tar –no-same-permissions –no-same-owner -xvzf – && chmod -R a+rX android-sdk-linuxENV ANDROID_HOME /usr/share/jenkins/android/android-sdk-linux
ENV PATH $PATH:$ANDROID_HOME/tools
ENV PATH $PATH:$ANDROID_HOME/platform-tools

# Install Android SDK components
ENV ANDROID_SDK_COMPONENTS platform-tools,build-tools-22.0.1,android-22,extra-android-m2repository,extra-google-m2repository
RUN echo y | /usr/share/jenkins/android/android-sdk-linux/tools/android update sdk –no-ui –all –filter « ${ANDROID_SDK_COMPONENTS} »

USER root
RUN chown -R jenkins /usr/share/jenkins/ref/plugins

Ce dockerfile se base sur l’image officielle jenkins. Il contient les plugins nécessaires pour faire de l’intégration continue avec jenkins. Il contient également les mises à jour utiles à la réussite du build gradle de l’apk sous jenkins.

Pour lancer cette image, il suffira d’exécuter la commande sous boot2docker :

docker run -d -p 8080:8080 regly/jenkinsandroid:v0

Création de la machine virtuelle sous Azure, déploiement du serveur jenkins

 

Gestion des certificats

1) Pour pouvoir créer notre machine virtuelle sous azure, nous devons créer un certificat sur notre poste, que nous allons importer sous le portail azure.
Pour créer ce certificat nous utilisons openssl. Celui-ci étant installé, nous allons exécuter les commandes suivantes dans son répertoire d’installation : C:\openssl

$ openssl req -x509 -nodes -days 365 -newkey rsa:1024 -keyout mycert.pem -out mycert.pem

Voici pour exemple ce que vous pourrez répondre à l’exécution de cette commande :

Img3

$ openssl pkcs12 -export -out mycert.pfx -in mycert.pem -name « My Certificate »
$ openssl x509 -inform pem -in mycert.pem -outform der -out mycert.cer

2) Vous téléchargerez ce certificate “mycert.cert” sous votre compte azure

Img4

Img5

Création de la machine virtuelle

1) Nous récupérons sous azure notre identifiant de souscription et utilisons MINGW pour lancer les commandes suivantes :

$ cd c:/openssl
$ export OPENSSL_CONF=/C/openssl/openssl.cnf
$ docker-machine create -d azure –azure-subscription-id= »ID_SUBSCRIPTION_AZURE » –azure-subscription-cert= »mycert.pem » jenkinsdocker

Résultat sur le portail azure, la machine virtuelle est instanciée :
Sur le portail officiel :

Img6

Sur le portail en mode « bêta » :

Img8

Img7

2) Nous créons le point de terminaison http sous azure pour pouvoir accéder à notre serveur jenkins sur la machine virtuelle pour le port 8080

Img9

3) Nous créons un compte de stockage « jenkinsstorage » pour déposer nos apks

Img10

Img11

Celui-ci propose des conteneurs dans lequel nous pouvons stocker des blobs, nos apks dans notre cas.
Nous utiliserons la clef d’accès principale dans le paramétrage de jenkins.

Construction et lancement de l’image docker

Dans notre éditeur MINGW, lancez la commande précisée suite à la création de la machine virtuelle :

eval « $(/c/Program\ Files\ \(x86\)/Git/bin/docker-machine env jenkinsdocker) »

Cette commande nous permet de faire le lien entre notre client docker et le host sur la machine virtuelle instanciée sous azure. Elle sera utilisée à chaque fois que nous démarrons une nouvelle session pour prendre la main sur ce host.

Ensuite, lancez la commande suivante :

docker run –name=myjenkins -d -p 8080:8080 regly/jenkinsandroid:v0

Cette commande va démarrer le conteneur myjenkins, de manière détachée, sur le port 8080 de la machine virtuelle azure.

Accès au serveur jenkins

Nous accédons au serveur jenkins via l’url jenkinsdocker.cloudapp.net :8080

Img12

Paramétrage du serveur jenkins et transfert de l’apk dans le compte de stockage azure

 

Paramétrage du serveur jenkins

1) Nous vérifions que les plugins définis dans l’image docker sont correctement installés.

Img13

2) Nous devons définir la variable ANDROID_HOME et utiliser le plugin gradle pour définir la version de gradle à utiliser.

Img14

3) Nous utilisons le plugin windows azure storage et pointons sur le compte de stockage « jenkinsstorage » défini précédemment :

Img15

4) Nous créons le job jenkins pour construire notre apk situé sous github :
https://github.com/googlesamples/android-TextLinkify

Img16

Img17

Img18

Etape 1 : ce job jenkins lancé manuellement va récupérer les sources du projet android via git sous github.
Etape 2 : nous allons invoquer la tâche build de gradle sur ce projet.
Etape 3 : nous allons, suite à ce build, faire un upload de tous les apks générés sur notre compte de stockage azure « jenkinsstorage ». Le conteneur dans jenkinsstorage porte le nom « buildandroid ». Pour pouvoir identifier les différents uploads, nous préciserons dans le path l’identifiant du build et son numéro.

5) Exécution du job :

Img19

Img20

Le build a réussi, nous remarquons sous jenkins à plusieurs endroits, des liens précisant l’utilisant du cloud azure pour stocker les apks.

Résultat sous le compte de stockage azure

1) Sur le portail officiel, nous retrouvons nos apks :

Img21

 

 

Img22

2) Sur le nouveau portail, ça fonctionne moins bien…

Img23

Img24

Conclusion

Cette étude nous a permis d’entrevoir les possibilités de plusieurs technologies innovantes.
Nous pourrons retenir que grâce à notre image docker, le déploiement de notre intégration continue peut être effectué en quelques minutes sur n’importe quel type de poste ( windows, linux, mac ), en local ou sur un serveur, voire dans le cloud. Nous avons pris en main jenkins en limitant les efforts d’installation.
Nous avons pu voir un exemple concret de déploiement d’une machine virtuelle dans le cloud azure.

Categories: Devops Tags: , , ,
  1. Pas encore de commentaire
  1. Pas encore de trackbacks


− huit = 0