Configurer manuellement les étapes de développement logiciel peut être fastidieux et sujet aux erreurs.
Ces erreurs peuvent entraîner des retards, des bugs non détectés, et une qualité de code médiocre, compliquant le déploiement.
L’article explore comment utiliser GitLab pour automatiser ces étapes, garantissant ainsi un processus de développement plus fluide et fiable.
Développez des applications Android solides, fiables et efficaces avec une approche TDD
Ce chapitre a pour objectif de vous expliquer comment configurer et automatiser les étapes de build, de test, de vérification de code, et de déploiement en utilisant GitLab. Un pipeline est une suite de tâches automatisées permettant de garantir la qualité du code et d’assurer un déploiement fluide. Nous allons détailler comment configurer un pipeline en utilisant les templates fournis par GitLab et comment ajuster ces pipelines en fonction de vos besoins, notamment pour des projets Android.
Commandes Git pour GitLab CI/CD
Commande | Description |
|---|---|
git init | Initialise un nouveau repository Git. |
git add . | Ajoute tous les fichiers au suivi de Git. |
git commit -m « Message » | Enregistre les changements localement avec un message décrivant la modification. |
git push | Envoie les changements locaux vers un repository GitLab distant. |
Création de Repository GitLab
Une fois votre projet créé dans Android Studio, vous devez l’initialiser en tant que repository Git pour pouvoir pousser vos sources sur GitLab. Voici les étapes à suivre :
Une fois cette configuration terminée, votre projet est lié à GitLab, et vous pouvez commencer à configurer des pipelines pour automatiser vos tâches.
Cette figure montre l’interface de gestion d’un projet sur GitLab, où les utilisateurs peuvent voir les différents fichiers et dossiers du dépôt. Chaque élément de la liste, comme .idea , gradle/wrapper , et tracker_domain , indique le dernier commit effectué, avec des informations sur la date de mise à jour. Le projet semble être à ses débuts, tous les fichiers affichant un « Initial commit » , tandis que le fichier .gitlab-ci.yml a été mis à jour récemment, suggérant des ajustements pour l’intégration continue.
Pipelines GitLab : Introduction
Un pipeline dans GitLab est un ensemble de tâches automatisées organisées en étapes. Ces étapes peuvent inclure :
- La compilation du code (build).
- L’exécution des tests.
- La vérification de la qualité du code.
- Le déploiement.
Cette figure illustre les étapes clés d’un pipeline GitLab , qui est un processus automatisé pour le développement logiciel. Le pipeline commence par la compilation du code , garantissant que le code source est transformé en un format exécutable, suivie de l’ exécution des tests pour valider le comportement du code et s’assurer qu’il fonctionne comme prévu. Enfin, si toutes les étapes précédentes réussissent, le processus se termine par le déploiement , où le code est mis en production, rendant les nouvelles fonctionnalités accessibles aux utilisateurs finaux.
Chaque pipeline est défini dans un fichier spécifique : .gitlab-ci.yml.
Structure d’un Pipeline
Voici un exemple simple de pipeline pour une application Android :
Ce code YAML définit un pipeline GitLab avec deux étapes principales : build et test . Dans la première étape, build_job , le script exécute la commande ./gradlew assembleDebug pour assembler l’application en mode débogage, ce qui permet de compiler le code source et de générer les fichiers nécessaires pour l’exécution. Dans la deuxième étape, test_job , la commande ./gradlew testDebug est utilisée pour exécuter les tests unitaires associés à l’application, garantissant que toutes les fonctionnalités fonctionnent comme prévu avant de passer à la production.
stages : -build - test build_job : stage : build script : -./
gradlew assembleDebug test_job : stage : test script : -./
gradlew testDebug
Cette figure montre l’interface des pipelines dans GitLab, où deux pipelines récents sont affichés avec leurs statuts respectifs : l’un a réussi (passed) tandis que l’autre a échoué (failed). Le pipeline réussi a duré 6 minutes et 6 secondes, tandis que le pipeline échoué a pris 5 minutes et 13 secondes, indiquant une éventuelle erreur qui nécessite une attention particulière pour identifier et résoudre le problème.
Dans cet exemple, le pipeline se compose de deux étapes (build et test) qui utilisent Gradle pour compiler l’application et exécuter les tests.
Configurer un Pipeline GitLab Android
Création du Fichier .gitlab-ci.yml
Lorsque vous configurez un pipeline dans GitLab, le fichier clé est .gitlab-ci.yml. Ce fichier contient la configuration de votre pipeline et peut être basé sur des templates préexistants dans GitLab, facilitant ainsi la création de pipelines adaptés à vos projets.
Cette figure présente un tableau récapitulatif des fichiers et dossiers d’un projet sur GitLab, indiquant le nom de chaque élément ainsi que la date de leur dernier commit.
Utilisation de Templates
GitLab propose des templates pour plusieurs types de projets, y compris des applications Android. Voici comment créer un pipeline à partir d’un template Android :
- Allez dans l’interface de votre projet GitLab.
- Cliquez sur CI/CD puis Editor pour éditer ou créer le fichier .gitlab-ci.yml.
Ajouter des Jobs au Pipeline
Les jobs sont des tâches spécifiques qui composent chaque étape. Par exemple, pour une application Android, vous pouvez configurer un job pour compiler (assembleDebug) et un autre pour exécuter les tests (testDebug).
Exemples de Pipelines Android GitLab
Voici un exemple de pipeline complet pour une application Android :
Ce code YAML définit une configuration de pipeline pour un projet Android utilisant GitLab CI/CD. Il commence par spécifier l’image Docker à utiliser, ici OpenJDK 17, et définit des variables environnementales pour le SDK et les outils de construction Android. Dans la section before_script, le script met à jour les paquets, télécharge les outils de ligne de commande Android, les décompresse et accepte les licences requises. Ensuite, deux étapes de pipeline sont définies : la première, build, exécute la tâche assembleDebug pour compiler le projet, tandis que la seconde, test, exécute les tests unitaires avec la tâche testDebug.
image : openjdk : 17 variables : ANDROID_COMPILE_SDK : "33" ANDROID_BUILD_TOOLS
: "33.0.0" ANDROID_SDK_ROOT : "/sdk" before_script
: -apt -
get update &&apt - get install - y wget -
wget https
: // dl.google.com/android/repository/commandlinetools-linux-7583922_latest.zip
-unzip commandlinetools -
linux - 7583922_latest.zip - d ${ANDROID_SDK_ROOT} / cmdline - tools -
yes |
sdkmanager-- licenses stages : -build - test build_job : stage
: build script
: -./ gradlew assembleDebug test_job : stage : test script : -./
gradlew testDebug
Ce pipeline comprend les étapes suivantes :
- Installation des outils Android.
- Compilation du code.
- Exécution des tests.
Cette figure montre un extrait de fichier .gitlab-ci.yml, qui configure un pipeline CI/CD pour un projet dans GitLab. Elle définit plusieurs étapes, notamment une étape de construction où le code est compilé, une étape de test unitaire, une étape de linting pour vérifier la qualité du code et enfin une étape de déploiement qui s’exécute après que toutes les étapes précédentes aient réussi. Chaque tâche a un script associé qui détaille les actions à réaliser, incluant des échos pour indiquer le progrès et des pauses simulées pour représenter des temps d’exécution.
Tests et Déploiements GitLab Android
GitLab permet de configurer des étapes de tests et de déploiement en fonction de vos besoins. Par exemple, vous pouvez ajouter des vérifications de couverture de code avec des outils comme JaCoCo pour garantir que votre code est bien testé.
Voici un exemple de job pour vérifier la couverture de code :
Ce code configure une étape de test dans un pipeline CI/CD pour un projet utilisant Gradle. Dans cette étape, le script exécute les tests unitaires en mode débogage (testDebug) tout en générant un rapport de couverture de code à l’aide de Jacoco (jacocoTestReport). Les résultats des tests et les rapports de couverture sont ensuite collectés en tant qu’artefacts, spécifiant le chemin vers les résultats des tests JUnit (build/test-results/testDebugUnitTest.xml) et le fichier de couverture de Jacoco (build/reports/jacoco/testDebugUnitTest.exec), permettant ainsi de consulter facilement les résultats après l’exécution du pipeline.
stage : test script : -./
gradlew testDebug jacocoTestReport artifacts : reports : junit : build /
test -
results / testDebugUnitTest.xml paths : -build / reports / jacoco /
testDebugUnitTest.exec
Voici le résultat dans GitLab
Ce code dans GitLab définit plusieurs tâches dans un pipeline CI/CD, toutes exécutées dans la phase de test. La première tâche vérifie le code pour détecter d’éventuelles erreurs, tandis que la deuxième tâche exécute les tests unitaires et génère un rapport de couverture de code avec Jacoco, en spécifiant les artefacts à conserver, tels que les résultats des tests et le fichier de couverture, qui seront disponibles pendant une semaine.
Formez-vous gratuitement avec Alphorm !
Maîtrisez les compétences clés en IT grâce à nos formations gratuites et accélérez votre carrière dès aujourd'hui.
FAQ
Comment configurer un pipeline GitLab pour un projet Android ?
Quels sont les avantages de l'automatisation avec GitLab pipelines ?
Quelles sont les étapes d'un pipeline typique dans GitLab ?
Comment utiliser les templates GitLab pour créer un pipeline ?
Comment ajouter des jobs dans un pipeline GitLab ?
Conclusion
La configuration des pipelines dans GitLab est essentielle pour automatiser les processus de développement Android. Comment envisagez-vous d’adapter votre pipeline pour maximiser l’efficacité de votre équipe?
