CI/CD with GitHub Actions & DevOps Pipelines · Leçon

Flux de travail et actions réutilisables

Créez et exploitez des flux de travail et des actions personnalisées réutilisables afin de modulariser vos pipelines et de favoriser la cohérence entre les dépôts.

Flux de travail et actions réutilisables est une leçon CI/CD with GitHub Actions & DevOps Pipelines gratuite sur CoddyKit. Ceci est la leçon 3 sur 4. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage CI/CD with GitHub Actions & DevOps Pipelines, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours CI/CD with GitHub Actions & DevOps Pipelines comprend 4 leçons au total.

Introduction à la réutilisation des flux de travail

Dans le développement logiciel moderne, l’efficacité et la cohérence sont essentielles. À mesure que vos projets grandissent, vos besoins en automatisation augmentent eux aussi.

Les flux de travail réutilisables et les actions personnalisées de GitHub Actions vous évitent de vous répéter et rendent vos chaînes CI/CD plus faciles à maintenir et plus robustes.

Pourquoi réutiliser les flux de travail ?

Imaginez que vous ayez plusieurs applications qui nécessitent toutes les mêmes étapes de compilation, de test ou de déploiement. Copier-coller le code du flux de travail entraîne :

Duplication : davantage de code à maintenir.
Incohérence : il est facile de ne pas répercuter les mises à jour dans tous les flux de travail.
Difficultés de maintenance : les modifications nécessitent de mettre à jour de nombreux fichiers.

La réutilisabilité résout ces problèmes !

Définir un flux de travail réutilisable

Un flux de travail réutilisable est un flux de travail complet qui peut être appelé par d’autres flux de travail. Il est stocké dans votre dépôt et sert de modèle.

Pour rendre un flux de travail réutilisable, vous utilisez l’événement workflow_call. Cela indique à GitHub Actions que ce flux de travail est destiné à être appelé et non à être déclenché par des événements classiques comme push ou pull_request.

Exemple de flux de travail réutilisable

Voici un flux de travail réutilisable simple qui simule une compilation. Enregistrez-le dans .github/workflows/reusable-build.yml.

Il définit une output appelée build_id, que les flux de travail appelants peuvent utiliser.

name: Reusable Build Component

on:
  workflow_call:
    outputs:
      build_id:
        description: "The ID of the build operation"
        value: ${{ jobs.build.outputs.build_id }}

jobs:
  build:
    runs-on: ubuntu-latest
    outputs:
      build_id: ${{ steps.generate_id.outputs.id }}
    steps:
      - name: Checkout code
        uses: actions/checkout@v4
      - name: Generate build ID
        id: generate_id
        run: echo "id=$(date +%s)" >> "$GITHUB_OUTPUT"
      - name: Simulate build
        run: echo "Building project with ID ${{ steps.generate_id.outputs.id }}..."

Appeler un flux de travail réutilisable

Pour utiliser un flux de travail réutilisable, un autre flux de travail, appelé « l’appelant », utilise le mot-clé uses, de la même manière que vous utiliseriez une action GitHub.

Vous indiquez le chemin vers le fichier du flux de travail réutilisable dans votre dépôt, ou même depuis un autre dépôt ou une version spécifique.

Exemple de flux de travail appelant

Ce flux de travail, enregistré sous .github/workflows/main-app-ci.yml, appelle notre flux de travail reusable-build.yml.

Remarquez comment il accède à la sortie build_id du flux de travail appelé à l’aide de jobs.call-build.outputs.build_id.

name: Main App CI

on: [push]

jobs:
  call-build:
    uses: ./.github/workflows/reusable-build.yml
    outputs:
      build_id: ${{ jobs.call-build.outputs.build_id }}
  
  deploy:
    needs: call-build
    runs-on: ubuntu-latest
    steps:
      - name: Deploy app
        run: echo "Deploying app built with ID ${{ needs.call-build.outputs.build_id }}"

Transmettre des entrées à des flux de travail réutilisables

Les flux de travail réutilisables ne sont pas de simples modèles statiques ; ils peuvent accepter des entrées, ce qui les rend très flexibles.

Vous définissez les entrées attendues dans la section on: workflow_call: inputs: du flux de travail réutilisable, en indiquant leur type, si elles sont obligatoires et leur description. Le flux de travail appelant transmet ces entrées à l'aide du mot-clé with:.

Flux de travail réutilisable avec des entrées

Voici une version mise à jour de reusable-build.yml qui accepte une entrée target_env. Cela permet de personnaliser la même logique de compilation pour différents environnements.

name: Reusable Build Component with Input

on:
  workflow_call:
    inputs:
      target_env:
        required: true
        type: string
        description: "The target environment for the build"
    outputs:
      build_id:
        description: "The ID of the build operation"
        value: ${{ jobs.build.outputs.build_id }}

jobs:
  build:
    runs-on: ubuntu-latest
    outputs:
      build_id: ${{ steps.generate_id.outputs.id }}
    steps:
      - name: Checkout code
        uses: actions/checkout@v4
      - name: Generate build ID
        id: generate_id
        run: echo "id=$(date +%s)" >> "$GITHUB_OUTPUT"
      - name: Simulate build for ${{ inputs.target_env }}
        run: echo "Building project for ${{ inputs.target_env }} with ID ${{ steps.generate_id.outputs.id }}..."

Exemple d'appel avec des entrées

À présent, notre flux de travail CI principal peut appeler deux fois le composant de compilation réutilisable, une fois pour la « préproduction » et une fois pour la « production », en transmettant des valeurs target_env différentes.

name: Main App CI with Input

on: [push]

jobs:
  call-build-staging:
    uses: ./.github/workflows/reusable-build-with-input.yml
    with:
      target_env: 'staging'
    outputs:
      build_id: ${{ jobs.call-build-staging.outputs.build_id }}
  
  call-build-prod:
    uses: ./.github/workflows/reusable-build-with-input.yml
    with:
      target_env: 'production'
    outputs:
      build_id: ${{ jobs.call-build-prod.outputs.build_id }}

Flux de travail réutilisables ou actions personnalisées

Bien que les deux favorisent la réutilisation, ils ont des objectifs différents :

Flux de travail réutilisables : ils orchestrent une série de tâches. Ils définissent une structure complète de flux de travail (par exemple, compiler, tester, déployer).
Actions personnalisées : elles effectuent une tâche spécifique et unique au sein d'une tâche (par exemple, configurer Node.js ou publier un paquet). Ce sont les éléments constitutifs à l'intérieur des étapes d'une tâche.

Considérez les flux de travail comme des recettes et les actions comme des ingrédients ou des étapes individuels.

Vérification rapide

Lesquels des éléments suivants sont des avantages clés de l'utilisation de flux de travail réutilisables dans GitHub Actions ?

Récapitulatif : flux de travail et actions réutilisables

Nous avons vu comment les flux de travail réutilisables contribuent à modulariser vos chaînes CI/CD.

Ils sont définis à l'aide de workflow_call.
Ils peuvent accepter des entrées et fournir des sorties.
Les flux de travail appelants utilisent le mot-clé uses.
Ils diffèrent des actions personnalisées, qui sont des éléments constitutifs dédiés à une seule tâche au sein des tâches.

Adopter la réutilisation permet d'obtenir une automatisation plus efficace, cohérente et facile à maintenir dans l'ensemble de vos projets.

Questions Fréquemment Posées

La leçon « Flux de travail et actions réutilisables » est-elle gratuite ?

Oui — le texte complet de « Flux de travail et actions réutilisables » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours CI/CD with GitHub Actions & DevOps Pipelines, passe à CoddyKit PRO. Le cours CI/CD with GitHub Actions & DevOps Pipelines comprend 4 leçons au total.

Qu'est-ce que j'apprendrai dans « Flux de travail et actions réutilisables » ?

Créez et exploitez des flux de travail et des actions personnalisées réutilisables afin de modulariser vos pipelines et de favoriser la cohérence entre les dépôts. Tu pratiques CI/CD with GitHub Actions & DevOps Pipelines avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.

Dois-je avoir de l'expérience pour commencer CI/CD with GitHub Actions & DevOps Pipelines ?

Aucune expérience préalable n'est requise. CI/CD with GitHub Actions & DevOps Pipelines sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 3 sur 4.

Combien de temps prend la leçon « Flux de travail et actions réutilisables » ?

La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.

Peux-tu écrire et exécuter du code dans cette leçon CI/CD with GitHub Actions & DevOps Pipelines ?

Oui. Chaque leçon CI/CD with GitHub Actions & DevOps Pipelines inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.

Toutes les leçons de ce cours

Générations matricielles pour plusieurs environnements
Mise en cache des dépendances pour accélérer l’exécution
Flux de travail et actions réutilisables
Exécution conditionnelle et dépendances entre tâches

← Retour à CI/CD with GitHub Actions & DevOps Pipelines