GitHub Actions : GPU Runners et Workflow Artifacts 2.0

GitHub a annoncé le 23 octobre 2025 des améliorations majeures à GitHub Actions : des GPU Runners pour CI/CD ML/AI, Artifacts 2.0 avec 10x plus de stockage et des Composite Actions améliorées. Le CI/CD s'adapte aux workloads modernes.

GPU Runners : CI/CD pour ML/AI

Hardware Dédié pour Machine Learning

GitHub introduit des runners avec GPUs NVIDIA pour entraîner, tester et déployer des modèles ML :

Configurations disponibles :

Exemple workflow :

name: Train Model
on: [push]

jobs:
  train:
    runs-on: gpu-a10-large  # GPU runner !

    steps:
    - uses: actions/checkout@v4

    - name: Setup Python
      uses: actions/setup-python@v5
      with:
        python-version: '3.11'

    - name: Install dependencies
      run: |
        pip install torch torchvision accelerate wandb

    - name: Train model
      run: |
        python train.py \
          --model resnet50 \
          --epochs 10 \
          --batch-size 128 \
          --device cuda

    - name: Upload model
      uses: actions/upload-artifact@v4
      with:
        name: trained-model
        path: ./outputs/model.pth

Use cases :

• Entraînement de modèles PyTorch/TensorFlow/JAX
• Tests de performance GPU
• Génération d'embeddings (LLMs, vision)
• Rendering 3D, traitement vidéo

CUDA Toolkit Préinstallé

Drivers et outils disponibles :

• CUDA 12.3
• cuDNN 9.0
• TensorRT 9.2
• NCCL 2.20 (multi-GPU)

Pas de setup manuel nécessaire !

- name: Verify CUDA
  run: |
    nvidia-smi
    nvcc --version

# Output :
# +-----------------------------------------------------------------------------+
# | NVIDIA-SMI 545.23       Driver Version: 545.23       CUDA Version: 12.3     |
# |-------------------------------+----------------------+----------------------+
# | GPU  Name        Persistence-M| Bus-Id        Disp.A | Volatile Uncorr. ECC |
# | 0    NVIDIA A10    On          | 00000000:00:04.0 Off |                    0 |

Caching de Modèles

Cache Artifacts pour modèles volumineux :

- name: Cache model weights
  uses: actions/cache@v4
  with:
    path: ~/.cache/huggingface
    key: model-cache-${{ runner.os }}-${{ hashFiles('requirements.txt') }}

- name: Download pretrained model
  run: |
    # Cache hit → téléchargement skipped
    python -c "from transformers import AutoModel; AutoModel.from_pretrained('bert-base-uncased')"

Économie de temps :

• Téléchargement BERT (500MB) : 2min → 5s
• GPT-2 (1.5GB) : 5min → 10s

Artifacts 2.0 : Stockage Étendu

10x Plus de Stockage

Limites augmentées :

Rétention :

• Free/Pro : 90 jours
• Team/Enterprise : 400 jours

Compression Automatique

Artifacts compressés intelligemment :

- name: Upload build artifacts
  uses: actions/upload-artifact@v4
  with:
    name: dist
    path: |
      dist/
      build/
    compression-level: 9  # Maximum compression

# Avant (v3) : 450MB uploaded
# Maintenant (v4) : 120MB uploaded (-73%)

Formats supportés :

• Auto-détection (ZIP, TAR.GZ, ZSTD)
• Décompression automatique au download

Artifacts Partagés entre Jobs

Parallélisation optimisée :

jobs:
  build:
    runs-on: ubuntu-latest
    steps:
    - uses: actions/checkout@v4
    - run: npm run build
    - uses: actions/upload-artifact@v4
      with:
        name: webapp
        path: dist/

  test-e2e:
    needs: build
    runs-on: ubuntu-latest
    strategy:
      matrix:
        browser: [chrome, firefox, safari]
    steps:
    - uses: actions/download-artifact@v4
      with:
        name: webapp  # Téléchargé 1 seule fois puis caché
    - run: npm run test:e2e -- --browser ${{ matrix.browser }}

  deploy:
    needs: [build, test-e2e]
    runs-on: ubuntu-latest
    steps:
    - uses: actions/download-artifact@v4
      with:
        name: webapp
    - run: |
        aws s3 sync dist/ s3://my-bucket/ --delete

Cache intelligent :

• Artifact téléchargé 1 fois même si utilisé par 10 jobs
• Économie de bande passante et temps

Composite Actions : Améliorées

Inputs et Outputs Typés

Nouveau : validation de types

# .github/actions/deploy/action.yml
name: Deploy to AWS
description: Deploy application to AWS with validations

inputs:
  environment:
    description: 'Target environment'
    required: true
    type: choice  # Nouveau !
    options:
      - dev
      - staging
      - production

  instance-count:
    description: 'Number of instances'
    required: false
    type: number  # Nouveau !
    default: 2
    minimum: 1
    maximum: 10

  enable-monitoring:
    description: 'Enable CloudWatch monitoring'
    required: false
    type: boolean  # Nouveau !
    default: true

outputs:
  deployment-url:
    description: 'URL of deployed application'
    value: ${{ steps.deploy.outputs.url }}

runs:
  using: composite
  steps:
  - name: Validate inputs
    shell: bash
    run: |
      # Type validation automatique par GitHub !
      echo "Deploying to ${{ inputs.environment }}"
      echo "Instance count: ${{ inputs.instance-count }}"

  - name: Deploy
    id: deploy
    shell: bash
    run: |
      # Deployment logic
      echo "url=https://app-${{ inputs.environment }}.example.com" >> $GITHUB_OUTPUT

Utilisation :

- uses: ./.github/actions/deploy
  with:
    environment: production
    instance-count: 5  # Type number → validé
    enable-monitoring: true  # Type boolean → validé

# Erreurs automatiques si types incorrects :
# ❌ instance-count: "five" → Error: Expected number
# ❌ environment: prod → Error: Must be one of [dev, staging, production]

Marketplace : Versioning Amélioré

SemVer strict appliqué :

# Avant : versions imprécises
- uses: actions/checkout@v3  # Quelle minor/patch?

# Maintenant : versions exactes recommandées
- uses: actions/checkout@v4.2.1

# OU pinning par commit (sécurité maximale)
- uses: actions/checkout@c85c95e3d7251135ab7dc9ce3241c5835cc595a9  # v4.2.1

Dependabot pour Actions :

# .github/dependabot.yml
version: 2
updates:
  - package-ecosystem: "github-actions"
    directory: "/"
    schedule:
      interval: "weekly"

# Dependabot ouvre automatiquement des PRs
# quand nouvelles versions d'actions disponibles

Reusable Workflows : Enhanced

Workflow Calls avec Secrets

Partager workflows entre repos :

# .github/workflows/reusable-deploy.yml
name: Reusable Deploy

on:
  workflow_call:
    inputs:
      environment:
        required: true
        type: string
    secrets:
      AWS_ACCESS_KEY_ID:
        required: true
      AWS_SECRET_ACCESS_KEY:
        required: true
    outputs:
      url:
        description: "Deployment URL"
        value: ${{ jobs.deploy.outputs.url }}

jobs:
  deploy:
    runs-on: ubuntu-latest
    outputs:
      url: ${{ steps.deploy.outputs.url }}
    steps:
    - name: Configure AWS
      uses: aws-actions/configure-aws-credentials@v4
      with:
        aws-access-key-id: ${{ secrets.AWS_ACCESS_KEY_ID }}
        aws-secret-access-key: ${{ secrets.AWS_SECRET_ACCESS_KEY }}
        aws-region: eu-west-1

    - name: Deploy
      id: deploy
      run: |
        # Deploy logic
        echo "url=https://app.example.com" >> $GITHUB_OUTPUT

Appel depuis autre workflow :

# .github/workflows/main.yml
name: Main Pipeline

jobs:
  test:
    runs-on: ubuntu-latest
    steps:
    - run: npm test

  deploy-staging:
    needs: test
    uses: ./.github/workflows/reusable-deploy.yml
    with:
      environment: staging
    secrets:
      AWS_ACCESS_KEY_ID: ${{ secrets.AWS_KEY_STAGING }}
      AWS_SECRET_ACCESS_KEY: ${{ secrets.AWS_SECRET_STAGING }}

  deploy-production:
    needs: deploy-staging
    uses: ./.github/workflows/reusable-deploy.yml
    with:
      environment: production
    secrets:
      AWS_ACCESS_KEY_ID: ${{ secrets.AWS_KEY_PROD }}
      AWS_SECRET_ACCESS_KEY: ${{ secrets.AWS_SECRET_PROD }}

Avantages :

• DRY : pas de duplication de code
• Gouvernance : workflows approuvés et réutilisés
• Maintenance simplifiée

Concurrency Improvements

Queue Management Amélioré

Contrôle de concurrence granulaire :

jobs:
  deploy:
    runs-on: ubuntu-latest

    concurrency:
      group: deploy-${{ github.event.inputs.environment }}
      cancel-in-progress: false  # Ne pas annuler déploiement en cours

  # Si deploy staging en cours et nouveau push :
  # → workflow mis en queue, pas annulé

  test:
    runs-on: ubuntu-latest

    concurrency:
      group: test-${{ github.ref }}
      cancel-in-progress: true  # Annuler tests anciens

  # Si tests en cours et nouveau push :
  # → anciens tests annulés, nouveaux démarrés

Matrix Strategy : Dynamic

Matrices générées dynamiquement :

jobs:
  generate-matrix:
    runs-on: ubuntu-latest
    outputs:
      matrix: ${{ steps.set-matrix.outputs.matrix }}
    steps:
    - id: set-matrix
      run: |
        # Générer matrice en fonction de fichiers modifiés
        CHANGED_SERVICES=$(git diff --name-only HEAD~1 | grep '^services/' | cut -d'/' -f2 | sort -u | jq -R -s -c 'split("\n")[:-1]')
        echo "matrix={\"service\":$CHANGED_SERVICES}" >> $GITHUB_OUTPUT

  test:
    needs: generate-matrix
    strategy:
      matrix: ${{ fromJSON(needs.generate-matrix.outputs.matrix) }}
    runs-on: ubuntu-latest
    steps:
    - run: npm test --workspace=services/${{ matrix.service }}

# Teste uniquement les services modifiés !
# 20 services, 2 modifiés → 2 jobs au lieu de 20
# Économie : 90% de compute

Articles connexes

Pour approfondir le sujet, consultez également ces articles :

• Docker Desktop 5.0 : Extensions IA et Performance Révolutionnaire en 2025
• AWS Graviton 4 : Les Processeurs ARM Révolutionnent le Cloud Computing en 2025
• Docker Compose Watch Mode : Hot Reload pour Microservices

Conclusion

GitHub Actions évolue pour supporter les workloads modernes avec GPU Runners pour ML/AI, Artifacts 2.0 pour stockage étendu et Composite Actions améliorées. Ces améliorations font de GitHub Actions une plateforme CI/CD complète pour tous types de projets.

Pour les équipes ML/AI :

• GPU Runners : entraînement dans CI/CD
• Artifacts volumineux supportés
• Caching intelligent de modèles

Pour les équipes DevOps :

• Reusable workflows : gouvernance simplifiée
• Concurrency améliorée : coûts optimisés
• Type-safe actions : moins d'erreurs

Recommandation : Adopter progressivement les nouvelles features pour maximiser efficacité et réduire coûts.

GitHub Actions = plateforme CI/CD la plus complète en 2025.