Explorer les emplois

Les tâches sont les éléments de base des flux de travail GitHub Actions. Chaque travail est une collection d’étapes qui s’exécutent séquentiellement sur le même exécuteur, en partageant le système de fichiers et les variables d’environnement.

Comprendre l’exécution des tâches

Caractéristiques clés des travaux

• Étapes séquentielles : étapes au sein d’un travail exécutées l’une après l’autre
• Environnement partagé : toutes les étapes partagent le même exécuteur et le même système de fichiers
• Exécution isolée : chaque travail obtient un nouvel environnement virtuel
• Journaux consultables : les sorties de travail sont automatiquement capturées et consultables
• Prise en charge des artefacts : les travaux peuvent enregistrer et partager des fichiers entre les exécutions de flux de travail

Structure de travail de base

jobs:
  build:
    runs-on: ubuntu-latest
    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 ci

      - name: Run tests
        run: npm test

Exécution parallèle par rapport à l'exécution séquentielle

Exécution parallèle (valeur par défaut)

Par défaut, plusieurs travaux s’exécutent simultanément pour réduire la durée du flux de travail :

jobs:
  lint:
    runs-on: ubuntu-latest
    steps:
      - name: Checkout code
        uses: actions/checkout@v4
      - name: Run linter
        run: npm run lint

  test:
    runs-on: ubuntu-latest
    steps:
      - name: Checkout code
        uses: actions/checkout@v4
      - name: Run tests
        run: npm test

  # Both lint and test jobs run simultaneously

Exécution séquentielle avec dépendances

Utilisez le needs mot clé pour créer des dépendances de travail :

jobs:
  build:
    runs-on: ubuntu-latest
    steps:
      - name: Build application
        run: ./build.sh

  test:
    needs: build
    runs-on: ubuntu-latest
    steps:
      - name: Run integration tests
        run: ./test.sh

  deploy:
    needs: [build, test] # Waits for multiple jobs
    runs-on: ubuntu-latest
    steps:
      - name: Deploy to production
        run: ./deploy.sh

Modèles de travail avancés

Stratégie de matrice pour plusieurs configurations

Exécutez simultanément des travaux dans plusieurs environnements :

jobs:
  test:
    strategy:
      matrix:
        os: [ubuntu-latest, windows-latest, macos-latest]
        node-version: [18, 20, 22]
    runs-on: ${{ matrix.os }}
    steps:
      - uses: actions/checkout@v4
      - name: Setup Node.js ${{ matrix.node-version }}
        uses: actions/setup-node@v4
        with:
          node-version: ${{ matrix.node-version }}
      - run: npm test

Exécution du travail conditionnel

Exécutez des travaux uniquement lorsque des conditions spécifiques sont remplies :

jobs:
  deploy:
    if: github.ref == 'refs/heads/main' && github.event_name == 'push'
    runs-on: ubuntu-latest
    steps:
      - name: Deploy to production
        run: echo "Deploying to production"

  notify:
    needs: deploy
    if: failure() # Only runs if deploy job fails
    runs-on: ubuntu-latest
    steps:
      - name: Send failure notification
        run: echo "Deployment failed!"

Gestion des échecs de travail

Comportement par défaut

• En cas d’échec d’une étape, la tâche entière échoue
• Les travaux dépendants ne s’exécutent pas si leurs prérequis échouent
• Le flux de travail est marqué comme ayant échoué

Gestion du comportement en cas de défaillance

jobs:
  test:
    runs-on: ubuntu-latest
    steps:
      - name: Run tests (continue on error)
        run: npm test
        continue-on-error: true

      - name: Upload test results
        if: always() # Runs regardless of previous step outcome
        uses: actions/upload-artifact@v4
        with:
          name: test-results
          path: test-results.xml

Meilleures pratiques pour les travaux

• Garder les tâches ciblées : chaque tâche doit avoir une responsabilité spécifique
• Utiliser des noms descriptifs : rendre clairs les objectifs des tâches dans l’interface utilisateur du flux de travail
• Optimiser les dépendances : créez uniquement des dépendances quand cela est vraiment nécessaire
• Choisir les exécuteurs appropriés : Adapter le système d’exploitation de l’exécuteur aux besoins de votre application.
• Gérer correctement les défaillances : utiliser l’exécution conditionnelle et poursuivre l’erreur de manière stratégique
• Partager efficacement des données : utiliser des artefacts ou des sorties pour transmettre des données entre des travaux

Pour obtenir des options complètes de configuration des travaux, consultez Utilisation de travaux dans un flux de travail.