Conditions CI/CD: Maximisez l'Efficacité des Pipelines

Les workflows CI/CD inefficaces peuvent entraîner une perte de ressources et de temps.

Cela peut causer des retards dans le développement et augmenter les coûts opérationnels.

L’article explore l’utilisation des conditions pour contrôler l’exécution des jobs, optimisant ainsi les processus.

Table de matière

Conditions de base dans les workflows CI/CD Exécution conditionnelle avec GitHub Actions Conditions avancées avec fonctions YAML Exemples pratiques de conditions CI/CD Conditions pour triggers GitHub branches Utilisation des fonctions dans CI/CD FAQ Conclusion

Formation Maîtriser les Fondamentaux de GitHub Actions

Devenez expert en gestion de dépôts et automatisez avec GitHub Actions!

Les conditions jouent un rôle crucial dans la conception de workflows efficaces et dynamiques. Elles permettent de contrôler le flux d’exécution des jobs et des étapes, en fonction de critères spécifiques. Dans un environnement CI/CD, l’utilisation de conditions peut grandement améliorer la flexibilité et l’efficacité des pipelines, en s’assurant que les tâches ne s’exécutent que lorsque cela est nécessaire.

Conditions de base dans les workflows CI/CD

Les conditions d’exécution des jobs et des étapes peuvent être basées sur des variables d’environnement, l’état d’un job précédent, ou d’autres paramètres prédéfinis. Voici un exemple de condition de base en utilisant le mot clé if dans un workflow.

				
					
 jobs:
build:
runs-on: ubuntu-latest
if: github.ref == 'ref/heads/main'
steps:
- name: Checkout code
uses: actions/Checkout@v2
- name: Build
run: echo"Building because this is the main branch"

Ce code YAML configure un job appelé build pour s’exécuter dans un environnement Ubuntu. Il ne s’exécute que si la branche en cours est main ( github.ref == ‘refs/heads/main’ ).

Exécution conditionnelle avec GitHub Actions

Une autre condition peut également dépendre des résultats des étapes précédentes pour déterminer l’exécution. Voici un exemple pour concretiser ce concept.

				
					
 jobs:
test:
runs-on: ubuntu-latest
steps:
- name: Run test
run: exit 1

deploy:
needs: test
if: github.ref == 'refs/heads/main' && success()
runs-on: ubuntu-latest
steps:
- name: Deploy
run: echo "Deploy because tests passed"

test : Ce job s’exécute sur Ubuntu et lance un test en exécutant la commande exit 1, ce qui signifie que le test échoue.

deploy : Ce job dépend du job test (indiqué par needs: test ) et s’exécute uniquement si le test précédent a réussi ( success()) et si la branche en cours est main (github.ref == ‘refs/heads/main’). Il déploie en affichant le message « deploy because tests passed » si toutes les conditions sont remplies.

Conditions avancées avec fonctions YAML

Les conditions avancées dans les workflows CI/CD permettent une personnalisation plus fine de l’exécution des jobs en utilisant des fonctions spécifiques comme failure (), cancelled () et always (). Ces fonctions permettent de définir des règles plus complexes pour déterminer quand un job doit s’exécuter. Voici un exemple avec la fonction always():

				
					
 jobs:
cleanup:
if: always()
runs-on: ubuntu-latest
steps:
- name: Clean up resources
run: echo "Cleaning up resources"

cleanup : Nom du job.

if: always() : La condition always () indique que le job cleanup s’exécutera toujours, quelle que soit l’issue des jobs précédents (qu’ils réussissent ou échouent).

runs-on: ubuntu-latest : Spécifie que le job s’exécute sur la dernière version d’Ubuntu disponible.

steps : Contient les étapes à exécuter dans ce job.

name: Clean up resources : Nom de l’étape.

run: echo « Cleaning up resources » : La commande echo affiche » Cleaning up resources » pour indiquer que des ressources sont en train d’être nettoyées.

Exemples pratiques de conditions CI/CD

Dans cette section, nous allons réexaminer le workflow que nous avons développé sans la partie précédente pour exécuter des scripts Node.js et le déclencher en fonction de conditions, en incluant les deux jobs build et test .

Donc toujour dans le fichier buil-and-test-nodejs.yml , voyons l les modifications.

				
					
 name: index.js build and test
on: [push, pull_request]

jobs:
build:
runs-on: ubuntu-latest
if: github.ref == 'ref/heads/main'
steps:
- name: Checkout code
uses: actions/checkout@v4
- name: Setup Node.js
uses: actions/setup-node@v4
with:
node-version: '20'
- name: Install dependencies
run: npm install
- name: Run build
run: npm run build

test:
runs-on: ubuntu-latest
if: github.ref == 'ref/heads/main'
steps:
- name: Checkout code
uses: actions/checkout@v4
- name: Setup Node.js
uses: actions/setup-node@v4
with:
node-version: '20'
- name: Install dependencies
run: npm install
- name: Run tests
run: npm run test

Nous avons juste modifié la structure de on comme ceci :

				
					
 on: [push, pull_request]

Ensuite, nous avons ajouté une condition à chaque job stipulant que les jobs seront exécutés uniquement si la branche ciblée est main.

				
					
 if: github.ref == 'ref/heads/main'

La modification est maintenant prête à être poussée. Cependant, pour mieux illustrer cette condition, nous allons remplacer la branche main par une nouvelle branche. Créons donc la nouvelle branche dans l’éditeur VS Code. Pour ce faire, cliquez sur « main » en bas à gauche de VS Code.

Une fois la création de branche proposée, nous pourrons nommer la nouvelle branche. Nous allons la nommer : feat/test-condition-in-workflow .

Après avoir donné le nom de la branche, tapons sur Entrée. Nous verrons que la branche a été créée avec succès et que la branche active a changé automatiquement, comme indiqué ci-dessous :

Parfait, nous allons effectuer le commit et push maintenant pour déclencher le workflow. Nous commentons le commit maintenant avec la phrase : Add condition in workflow

Information : Après avoir effectué le push, vérifions dans la branche feat/test-condition-in-workflow de notre repository. Nous constaterons que le script Node.js n’a pas été exécuté, car les conditions définies dans le workflow ne sont pas satisfaites.

Question : Vous vous demandez si le script Python a été exécuté . Oui, bien sûr, car nous n’avons pas défini de conditions pour ce script.

Voilà pour le push. Passons maintenant aux pull requests pour bien comprendre ce concept. Créons donc une pull request dans notre repository.

Il est important de vérifier soigneusement la branche de base et la branche à comparer. Dans notre cas, elles sont respectivement main et feat/test-condition-in-workflow.

Après avoir cliqué sur » Create pull request « , nous verrons comme suivant la liste des fichiers dans la branche. Nous pourrons alors constater que notre script Nodejs est bien présent.

Passons maintenant à la section pour vérifier si les workflows ont été déclenchés. Comme indiqué ci-dessous, le workflow n’a pas été activé, et les jobs n’ont pas été exécutés.

Astuce pratique : Pour corriger cette erreur, nous allons vérifier le code. Après révision, nous avons remarqué que la syntaxe correcte pour la condition de la pull request est la suivante :

				
					
 if: github.base_ref == 'main'

mais pas comme ceci:

				
					
 if: github.ref == 'ref/heads/main'

Information : Effectuons maintenant le push et recréons une nouvelle pull request en suivant les étapes habituelles que nous avons déjà pratiquées pour vérifier si l’erreur a été résolue.

Après avoir complété ces actions, nous constaterons que le workflow est activé :

Et enfin, tous les jobs sont exécutés avec succès.

Parfait, nous avons terminé cette partie avec succès. Nous savons désormais comment utiliser des conditions et corriger les erreurs associées.

Conditions pour triggers GitHub branches

Dans cette section, nous allons revoir le script Node.js en mettant l’accent sur les conditions basées sur les déclencheurs. Voici les modifications apportées :

Réorganisation et ajout de déclencheurs :Nous avons réorganisé le code et ajouté les déclencheurs du workflow, y compris workflow_dispatch.
Conditions pour les jobs build et test :Nous avons appliqué des conditions pour que les jobs build et test s’exécutent si l’événement est push ou pull_request.
Ajout d’un troisième job deploy :Ce job est similaire au job build, mais avec une condition différente : il s’exécute si l’événement est un push et que la branche est main.

Voyons maintenant les modifications apportées ci-dessous.

				
					
 name: Node.js Build and Test
on:
push:
pull_request:
workflow_dispatch:
jobs:
build:
runs-on: ubuntu-latest
if: github.event_name == 'push' || github.event_name == 'pull_request'
steps:
- name: Checkout code
uses: actions/checkout@v4
- name: Setup Node.js
uses: actions/setup-node@v4
with:
node-version: '20'
- name: Install dependencies
run: npm install
- name: Run build
run: npm run build
test:
runs-on: ubuntu-latest
if: github.event_name == 'push' || github.event_name == 'pull_request'
steps:
- name: Checkout code
uses: actions/checkout@v4
- name: Setup Node.js
uses: actions/setup-node@v4
with:
node-version: '20'
- name: Install dependencies
run: npm install
- name: Run tests
run: npm run test
deploy:
runs-on: ubuntu-latest
if: (github.event_name == 'push' && github.ref == 'refs/heads/main') || github.event_name == 'workflow_dispatch'
steps:
- name: Checkout code
uses: actions/checkout@v4
- name: Setup Node.js
uses: actions/setup-node@v4
with:
node-version: '20'
- name: Install dependencies
run: npm install
- name: Deploy
run: npm run deploy

Informations : effectuons maintenant le push dans la branche feat/test-condition-in-workflow pour vérifier le résultat. Après ce push, nous constaterons que les deux jobs, build et test, sont exécutés, tandis que le troisième job, deploy, ne l’est pas.

Les résultats ici sont attendus, car le workflow n’a pas été exécuté dans la branche main. Par conséquent, la condition du job deploy n’a pas été remplie.

Informations : Pour exécuter ce job, nous devons fusionner la pull request. Pour ce faire, accédez à la section des pull requests et effectuons la fusion. Ensuite, nous verrons que le job deploy est exécuté. Bien qu’il apparaisse en rouge, les étapes sont bien réalisées.

Super, nous avons terminé cette partie avec succès.

Utilisation des fonctions dans CI/CD

Reprenons le workflow NodeJS que nous avons développé précédemment et modifions la structure des conditions en utilisant des fonctions natives de YAML pour mieux gérer ces conditions. Pour cela, examinons les modifications apportées dans ce fichier :

				
					
 name: Node.js Build and Test
on:
push:
pull_request:
workflow_dispatch:
jobs:
build:
runs-on: ubuntu-latest
if: contains(fromJSON('["push","pull_request"]'), github.event.name)
steps:
- name: Checkout code
uses: actions/checkout@v4
- name: Setup Node.js
uses: actions/setup-node@v4
with:
node-version: '20'
- name: Install dependencies
run: npm install
- name: Run build
run: npm run build
test:
runs-on: ubuntu-latest
if: contains(fromJSON('["push","pull_request"]'), github.event.name)
steps:
- name: Checkout code
uses: actions/checkout@v4
- name: Setup Node.js
uses: actions/setup-node@v4
with:
node-version: '20'
- name: Install dependencies
run: npm install
- name: Run tests
run: npm run test
deploy:
runs-on: ubuntu-latest
if: ${{ (github.event_name == 'push' && github.ref == 'refs/heads/main') || github.event_name == 'workflow_dispatch' }}
steps:
- name: Checkout code
uses: actions/checkout@v4
- name: Setup Node.js
uses: actions/setup-node@v4
with:
node-version: '20'
- name: Install dependencies
run: npm install
- name: Deploy
run: npm run deploy
- name: Post-deploy check
if: ${{ success() }}
run: echo "The deploy job was run successfully"

Voilà, nous avons changé la structure de la condition au niveau du job test et build comme ceci :

				
					
 if: contains(fromJSON('["push","pull_request"]'), github.event.name)

Le job ne s’exécute que si l’événement qui a déclenché le workflow est soit un événement de type push , soit un événement de type pull_request en utilisant la fonction contains() avec la fonction formJSON() qui convertit une chaîne de caractères JSON en un tableau réel contennant les noms des évènements à vérifier.

Nous avons aussi ajouté cette étape :

				
					
 - name: Post-deploy check
if: ${{ success() }}
run: echo "The deploy job was run successfully"

Elle sera exécutée uniquement si le job de déploiement s’est terminé avec succès. Pour que cela fonctionne correctement, il est important de faire un pull , puis de basculer sur la branche main. Cela permettra à l’étape de déploiement de s’exécuter, ainsi que la dernière étape du processus.

Astuce pratique : Pour faire le pull dans VS Code, dans la branche Fest/test-condition-in-workflow, basculer dans l’icone github et cliquer sur les trois points :

Et puis, un onglet s’ouvre et cliquer sur pull

Après avoir effectué le pull, il ne reste plus qu’à faire un push pour déclencher le workflow. N’oublions pas d’ajouter un commentaire au commit. Pour l’instant, nous avons utilisé : » Use functions in workflow « .

Une fois le commit et le push terminés, nous avons obtenu les résultats suivants dans notre repository :

Comme l’indique le visuel ci-dessus, les deux jobs, build et test , se sont bien exécutés, ce qui signifie que les conditions dans la fonction contains () ont été correctement vérifiées. Cependant, le job deploy n’a pas été exécuté, car sa condition d’exécution n’a pas été remplie.

Parfait, nous maîtrisons désormais l’utilisation des fonctions pour les conditions.

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 les conditions influencent-elles les workflows CI/CD?

Les conditions dans les workflows CI/CD permettent une exécution plus flexible et efficace des pipelines. Elles définissent des critères spécifiques pour contrôler le flux des jobs et étapes, assurant que les tâches ne s’exécutent que lorsque nécessaire. Cela optimise l’utilisation des ressources en évitant l’exécution inutile des tâches, ce qui est crucial dans un environnement de développement agile.

Quels types de conditions peut-on utiliser dans GitHub Actions?

Dans GitHub Actions, vous pouvez utiliser des conditions basées sur des variables d’environnement, l’état d’un job antérieur, ou des événements spécifiques comme des push ou pull requests. Les fonctions YAML telles que ‘success’, ‘failure’, et ‘always’ permettent de déterminer si un job doit s’exécuter selon les résultats des jobs précédents, rendant ainsi les workflows plus dynamiques et adaptés aux besoins spécifiques du projet.

Pourquoi utiliser des conditions avancées dans un workflow CI/CD?

Les conditions avancées dans un workflow CI/CD permettent une personnalisation fine, améliorant ainsi la gestion et l’efficacité des processus d’intégration et de déploiement continus. En utilisant des fonctions comme ‘failure’ ou ‘success’, vous pouvez adapter l’exécution des jobs selon les résultats précédents, assurant que seules les étapes nécessaires sont exécutées, ce qui évite les erreurs coûteuses et améliore l’efficacité globale du pipeline.

Comment utiliser les fonctions YAML dans les conditions?

Les fonctions YAML, telles que ‘contains’ et ‘fromJSON’, sont utilisées pour évaluer des conditions complexes dans les workflows GitHub Actions. ‘contains’ vérifie si un événement spécifique a déclenché le workflow, tandis que ‘fromJSON’ convertit une chaîne JSON en tableau pour une vérification plus précise. Cela permet de définir des conditions d’exécution sophistiquées qui réagissent à divers événements, optimisant ainsi le contrôle du flux d’exécution.

Comment corriger les erreurs de conditions dans un workflow?

Pour corriger les erreurs de conditions dans un workflow, il est essentiel de vérifier la syntaxe et la logique des conditions définies. Par exemple, pour une pull request, la condition correcte pourrait être ‘github.base_ref == ‘main ». Assurez-vous que les conditions vérifient correctement les branches ou les événements déclencheurs spécifiés. Tester et ajuster les conditions dans un environnement de développement peut prévenir des erreurs dans un pipeline en production.

Conclusion

En intégrant des conditions dans vos workflows CI/CD, vous optimisez l’efficacité et la réactivité de vos pipelines. Quelles autres stratégies utilisez-vous pour améliorer l’automatisation dans vos projets CI/CD?

Conditions CI/CD: Maximisez l’Efficacité des Pipelines