0Pricing
DevOps Bootcamp · Leçon

Réglage des performances des pipelines

Identifiez les goulots d’étranglement et appliquez des techniques avancées pour optimiser la vitesse d’exécution et la consommation de ressources de vos flux de travail GitHub Actions.

Réglage des performances des pipelines est une leçon DevOps Bootcamp gratuite sur CoddyKit. Ceci est la leçon 2 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 DevOps Bootcamp, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours DevOps Bootcamp comprend 4 leçons au total.

Accélérer votre chaîne

Bienvenue dans le réglage des performances des chaînes ! Dans le développement moderne, des chaînes CI/CD rapides sont essentielles pour obtenir rapidement des retours et utiliser efficacement les ressources.

Les chaînes lentes font perdre du temps et de l'argent. Cette leçon vous enseignera des techniques avancées pour identifier les goulots d'étranglement et accélérer considérablement vos flux de travail GitHub Actions.

Identifier les goulots d'étranglement des flux de travail

Avant d'optimiser, vous devez savoir quoi optimiser. GitHub Actions fournit d'excellents outils pour repérer les étapes ou les tâches lentes.

  • Interface GitHub : consultez les journaux d'exécution des flux de travail. La vue chronologique indique clairement la durée de chaque tâche et de chaque étape.
  • Récapitulatifs des tâches : recherchez les étapes dont la durée est inhabituellement longue.
  • Journaux des actions : des journaux détaillés peuvent révéler les commandes ou processus précis qui prennent le plus de temps.

Concentrez-vous sur les étapes qui sont constamment les plus longues.

Exécuter en parallèle les tâches indépendantes

Si certaines parties de votre flux de travail ne dépendent pas les unes des autres, exécutez-les en même temps ! Il s'agit d'une méthode simple, mais puissante, pour réduire la durée totale d'exécution.

Définissez plusieurs tâches de niveau supérieur dans votre flux de travail. GitHub Actions les exécutera par défaut en parallèle, tant que vous ne spécifiez pas de dépendances needs entre elles.

name: Parallel Jobs Example
on: [push]
jobs:
  build-frontend:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - name: Build Frontend
        run: echo "Building frontend..."
  build-backend:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - name: Build Backend
        run: echo "Building backend..."

Optimiser l'action d'extraction

L'action actions/checkout récupère le code de votre dépôt. Pour les dépôts volumineux ou ceux qui possèdent un historique conséquent, cette opération peut être lente. Optimisez-la :

  • Clone superficiel : utilisez fetch-depth: 1 pour récupérer uniquement le dernier commit, ce qui permet de gagner beaucoup de temps pour la plupart des tâches CI/CD.
  • Extraction partielle : si vous n'avez besoin que d'un sous-ensemble de fichiers, envisagez une extraction partielle (bien qu'elle soit souvent plus complexe à configurer).

Évitez fetch-depth: 0 sauf en cas d'absolue nécessité, car cette option télécharge l'intégralité de l'historique.

name: Optimized Checkout
on: [push]
jobs:
  build:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
        with:
          fetch-depth: 1 # Only fetch the latest commit
      - name: Run Build
        run: echo "Code checked out and building..."

Réduire la taille des artefacts de compilation

Si votre flux de travail téléverse ou télécharge des artefacts (comme des fichiers binaires compilés ou des rapports de tests), leur taille a une incidence directe sur les performances.

Pour accélérer les opérations :

  • Incluez uniquement les fichiers nécessaires : ne téléversez pas les répertoires de compilation temporaires ni les journaux dont vous n'avez pas besoin.
  • Compressez les artefacts : si possible, compressez les artefacts volumineux avant leur téléversement. L'action actions/upload-artifact gère automatiquement la compression, mais veillez à ce que vos fichiers sources soient réduits au minimum.

Filtrer les chemins pour gagner en efficacité

Chaque modification du code ne doit pas nécessairement déclencher chaque tâche. Utilisez le filtrage par chemin pour exécuter les tâches uniquement lorsque les fichiers concernés sont modifiés.

Cette méthode est particulièrement utile dans les dépôts volumineux, où une modification de la documentation ne devrait pas déclencher une compilation complète du serveur principal.

Spécifiez paths ou paths-ignore dans le déclencheur on de votre flux de travail.

name: Path Filter Example
on:
  push:
    paths:
      - 'frontend/**'
      - 'shared/**'
jobs:
  build-frontend:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - name: Build Frontend
        run: echo "Frontend files changed, building..."

Des exécuteurs plus rapides et une allocation des ressources adaptée

Les machines virtuelles (exécuteurs) qui exécutent vos flux de travail existent en différentes tailles et différents types. Pour les tâches qui sollicitent fortement le CPU, un exécuteur plus puissant peut réduire considérablement la durée d'exécution.

  • Exécuteurs GitHub hébergés de grande taille : GitHub propose des exécuteurs plus grands (par exemple, ubuntu-latest-xlarge) pour les charges de travail plus exigeantes.
  • Exécuteurs autohébergés : si vous avez des besoins matériels très spécifiques ou souhaitez réduire la latence réseau vers des ressources internes, les exécuteurs autohébergés peuvent être optimisés pour répondre précisément à vos exigences.

Stratégies avancées de mise en cache

La mise en cache des dépendances (comme les paquets npm ou les artefacts Maven) est essentielle. Allez au-delà de la mise en cache de base grâce à ces conseils :

  • Clés de cache précises : utilisez des clés de cache plus spécifiques pour éviter les échecs de cache inutiles. Par exemple, incluez une empreinte d'un fichier de verrouillage précis et du système d'exploitation.
  • Caches multiples : ne placez pas tout dans un seul cache volumineux. Des caches séparés pour les différents types de dépendances (par exemple, node_modules et les paquets pip) peuvent améliorer le taux d'utilisation.
  • Clés de restauration : utilisez restore-keys pour essayer plusieurs clés de cache si la clé principale ne correspond pas, ce qui augmente les chances d'une correspondance partielle.
name: Advanced Caching
on: [push]
jobs:
  build:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - name: Cache Node Modules
        uses: actions/cache@v4
        with:
          path: ~/.npm
          key: ${{ runner.os }}-node-${{ hashFiles('**/package-lock.json') }}
          restore-keys: | # Try less specific keys if primary misses
            ${{ runner.os }}-node-
      - name: Install Dependencies
        run: npm ci

Optimisez ce flux de travail

Imaginez un flux de travail qui compile à la fois le code du frontend et celui du serveur principal. Actuellement, il s'exécute de manière séquentielle et l'extraction récupère l'intégralité de l'historique. Quelles sont les deux modifications qui amélioreraient considérablement ses performances ?

name: Inefficient Workflow
on: [push]
jobs:
  build-all:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - name: Install Frontend Deps
        run: npm install
      - name: Build Frontend
        run: npm run build
      - name: Install Backend Deps
        run: pip install -r requirements.txt
      - name: Build Backend
        run: python setup.py build

Récapitulatif : régler les performances

Vous avez appris des techniques puissantes pour optimiser vos flux de travail GitHub Actions !

  • Identifier les goulots d'étranglement : utilisez l'interface GitHub et les journaux.
  • Exécuter les tâches en parallèle : exécutez simultanément les tâches indépendantes.
  • Optimiser l'extraction : utilisez des clones superficiels.
  • Réduire les artefacts : limitez la taille des téléversements et des téléchargements.
  • Filtrer les chemins : exécutez les tâches uniquement lorsque les fichiers concernés sont modifiés.
  • Utiliser des exécuteurs plus rapides : choisissez des ressources d'exécution adaptées.
  • Mettre en œuvre une mise en cache avancée : utilisez des clés précises et plusieurs caches.

En appliquant ces stratégies, vous pouvez rendre vos chaînes plus rapides et plus efficaces, tout en économisant un temps et des ressources précieux.

Questions Fréquemment Posées

La leçon « Réglage des performances des pipelines » est-elle gratuite ?

Oui — le texte complet de « Réglage des performances des pipelines » 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 DevOps Bootcamp, passe à CoddyKit PRO. Le cours DevOps Bootcamp comprend 4 leçons au total.

Qu'est-ce que j'apprendrai dans « Réglage des performances des pipelines » ?

Identifiez les goulots d’étranglement et appliquez des techniques avancées pour optimiser la vitesse d’exécution et la consommation de ressources de vos flux de travail GitHub Actions. Tu pratiques DevOps Bootcamp 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 DevOps Bootcamp ?

Aucune expérience préalable n'est requise. DevOps Bootcamp 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 2 sur 4.

Combien de temps prend la leçon « Réglage des performances des pipelines » ?

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 DevOps Bootcamp ?

Oui. Chaque leçon DevOps Bootcamp 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

  1. Indicateurs DORA et santé de l’intégration et de la livraison continues
  2. Réglage des performances des pipelines
  3. Tendances futures de l’automatisation DevOps
  4. Optimiser les coûts de l’intégration et du déploiement continus et l’efficacité des exécuteurs
← Retour à DevOps Bootcamp