Jobs et steps

---

Table des matières

1. Architecture d'exécution
2. Configuration des jobs
3. Dépendances entre jobs
4. Configuration des steps
5. Partage de données
6. Exercices pratiques

---

1 - Architecture d'exécution

Flux d'exécution

Caractéristiques

Élément	Environnement	Exécution
Workflow	Repository	Déclenché par event
Job	Runner dédié	Parallèle par défaut
Step	Même runner	Séquentiel

Isolation

jobs:
  job1:
    runs-on: ubuntu-latest  # Runner A
    steps:
      - run: echo $HOME     # /home/runner
      
  job2:
    runs-on: ubuntu-latest  # Runner B (différent!)
    steps:
      - run: echo $HOME     # /home/runner (autre machine)

Important

Chaque job s'exécute sur un runner différent. Les fichiers ne sont pas partagés entre jobs.

🔝 Retour à la table des matières

---

2 - Configuration des jobs

Structure complète

jobs:
  build:
    name: Build Application      # Nom affiché
    runs-on: ubuntu-latest       # Runner
    
    timeout-minutes: 30          # Timeout
    
    permissions:                 # Permissions GITHUB_TOKEN
      contents: read
      packages: write
    
    env:                         # Variables d'environnement
      NODE_ENV: production
    
    defaults:                    # Défauts pour les steps
      run:
        shell: bash
        working-directory: ./src
    
    steps:
      - uses: actions/checkout@v4

Permissions

jobs:
  build:
    permissions:
      contents: read       # Lecture du repo
      packages: write      # Écriture packages
      issues: write        # Écriture issues
      pull-requests: write # Écriture PR
      id-token: write      # OIDC token

Permission	Usage
contents	Lecture/écriture du repo
packages	GitHub Packages
issues	Issues et comments
pull-requests	PR et reviews
id-token	OIDC (cloud auth)

Concurrency

jobs:
  deploy:
    concurrency:
      group: deploy-${{ github.ref }}
      cancel-in-progress: true
    
    runs-on: ubuntu-latest
    steps:
      - run: ./deploy.sh

Environment

jobs:
  deploy:
    environment:
      name: production
      url: https://myapp.com
    
    runs-on: ubuntu-latest
    steps:
      - run: echo "Deploying to production"

🔝 Retour à la table des matières

---

3 - Dépendances entre jobs

needs

jobs:
  build:
    runs-on: ubuntu-latest
    steps:
      - run: npm run build
  
  test:
    needs: build  # Attend que build soit terminé
    runs-on: ubuntu-latest
    steps:
      - run: npm test
  
  deploy:
    needs: [build, test]  # Attend build ET test
    runs-on: ubuntu-latest
    steps:
      - run: ./deploy.sh

Visualisation

Conditions sur needs

jobs:
  build:
    runs-on: ubuntu-latest
    steps:
      - run: npm run build
  
  notify-success:
    needs: build
    if: success()  # Seulement si build réussi
    runs-on: ubuntu-latest
    steps:
      - run: echo "Build succeeded!"
  
  notify-failure:
    needs: build
    if: failure()  # Seulement si build échoué
    runs-on: ubuntu-latest
    steps:
      - run: echo "Build failed!"
  
  cleanup:
    needs: build
    if: always()  # Toujours exécuté
    runs-on: ubuntu-latest
    steps:
      - run: echo "Cleaning up..."

Outputs entre jobs

jobs:
  build:
    runs-on: ubuntu-latest
    outputs:
      version: ${{ steps.version.outputs.version }}
    steps:
      - id: version
        run: echo "version=1.0.${{ github.run_number }}" >> $GITHUB_OUTPUT
  
  deploy:
    needs: build
    runs-on: ubuntu-latest
    steps:
      - run: echo "Deploying version ${{ needs.build.outputs.version }}"

🔝 Retour à la table des matières

---

4 - Configuration des steps

Types de steps

steps:
  # Action depuis le Marketplace
  - uses: actions/checkout@v4
  
  # Action avec paramètres
  - uses: actions/setup-node@v4
    with:
      node-version: '18'
      cache: 'npm'
  
  # Commande shell
  - run: npm install
  
  # Commande multi-lignes
  - run: |
      npm install
      npm run build
      npm test
  
  # Action locale
  - uses: ./.github/actions/my-action

Options des steps

steps:
  - name: Install dependencies    # Nom affiché
    id: install                   # ID pour référencer
    if: success()                 # Condition
    continue-on-error: true       # Ne pas échouer le job
    timeout-minutes: 10           # Timeout
    env:                          # Variables d'environnement
      NODE_ENV: production
    working-directory: ./app      # Répertoire de travail
    shell: bash                   # Shell à utiliser
    run: npm install

Shells disponibles

Shell	OS	Commande
bash	Linux, macOS	bash --noprofile --norc
sh	Linux, macOS	sh -e
pwsh	Tous	PowerShell Core
powershell	Windows	PowerShell Desktop
cmd	Windows	cmd /D /E:ON
python	Tous	Script Python

steps:
  - name: Bash script
    shell: bash
    run: echo "Hello from bash"
  
  - name: PowerShell script
    shell: pwsh
    run: Write-Host "Hello from PowerShell"
  
  - name: Python script
    shell: python
    run: |
      import os
      print(f"Hello from Python on {os.name}")

🔝 Retour à la table des matières

---

5 - Partage de données

Entre steps (même job)

jobs:
  build:
    runs-on: ubuntu-latest
    steps:
      # Méthode 1: Fichiers
      - name: Create file
        run: echo "data" > myfile.txt
      
      - name: Read file
        run: cat myfile.txt
      
      # Méthode 2: Outputs
      - name: Set output
        id: step1
        run: echo "result=success" >> $GITHUB_OUTPUT
      
      - name: Use output
        run: echo "${{ steps.step1.outputs.result }}"
      
      # Méthode 3: Environment
      - name: Set env
        run: echo "MY_VAR=value" >> $GITHUB_ENV
      
      - name: Use env
        run: echo "$MY_VAR"

Entre jobs (artifacts)

jobs:
  build:
    runs-on: ubuntu-latest
    steps:
      - run: echo "content" > artifact.txt
      
      - uses: actions/upload-artifact@v4
        with:
          name: my-artifact
          path: artifact.txt
  
  test:
    needs: build
    runs-on: ubuntu-latest
    steps:
      - uses: actions/download-artifact@v4
        with:
          name: my-artifact
      
      - run: cat artifact.txt

Entre jobs (outputs)

jobs:
  job1:
    runs-on: ubuntu-latest
    outputs:
      data: ${{ steps.generate.outputs.data }}
    steps:
      - id: generate
        run: echo "data=hello" >> $GITHUB_OUTPUT
  
  job2:
    needs: job1
    runs-on: ubuntu-latest
    steps:
      - run: echo "${{ needs.job1.outputs.data }}"

🔝 Retour à la table des matières

---

6 - Exercices pratiques

Exercice 1 : Pipeline séquentiel

Créez un pipeline build → test → deploy :

Solution

name: Pipeline

on: push

jobs:
  build:
    runs-on: ubuntu-latest
    steps:
      - run: echo "Building..."
  
  test:
    needs: build
    runs-on: ubuntu-latest
    steps:
      - run: echo "Testing..."
  
  deploy:
    needs: test
    runs-on: ubuntu-latest
    steps:
      - run: echo "Deploying..."

Exercice 2 : Partage d'outputs

Passez une version entre deux jobs :

Solution

name: Version

on: push

jobs:
  generate:
    runs-on: ubuntu-latest
    outputs:
      version: ${{ steps.ver.outputs.version }}
    steps:
      - id: ver
        run: echo "version=1.0.0" >> $GITHUB_OUTPUT
  
  use:
    needs: generate
    runs-on: ubuntu-latest
    steps:
      - run: echo "Version is ${{ needs.generate.outputs.version }}"

Quiz

Q1. Comment faire qu'un job attende deux autres jobs ?

Réponse

needs: [job1, job2]

Q2. Quelle est la différence entre jobs et steps pour le partage de fichiers ?

Réponse

Steps partagent le même filesystem, jobs nécessitent des artifacts.

🔝 Retour à la table des matières

---

Points clés à retenir

• Jobs s'exécutent en parallèle par défaut
• needs pour créer des dépendances
• Steps s'exécutent séquentiellement dans un job
• $GITHUB_OUTPUT pour outputs de steps
• Artifacts pour partager entre jobs
• continue-on-error: true pour ignorer les échecs
• timeout-minutes pour limiter l'exécution

🔝 Retour à la table des matières

---

← Chapitre précédent | Chapitre suivant : Actions du Marketplace →