0Pricing
DevOps Bootcamp · Leçon

Mise en cache des dépendances pour accélérer l’exécution

Mettez en œuvre la mise en cache pour accélérer considérablement l’exécution de vos flux de travail en réutilisant les dépendances générées et les sorties de compilation.

Mise en cache des dépendances pour accélérer l’exécution 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 les flux de travail grâce à la mise en cache

Avez-vous déjà remarqué que votre flux de travail télécharge à nouveau les mêmes dépendances à chaque exécution ? Cela le ralentit !

La mise en cache dans GitHub Actions vous permet de stocker et de réutiliser des fichiers provenant d’exécutions précédentes. Cela accélère considérablement les exécutions ultérieures du flux de travail.

Découvrez l’action de mise en cache

GitHub fournit une action spéciale appelée actions/cache@v3. Cette action est conçue pour enregistrer et restaurer des fichiers afin d’accélérer vos flux de travail.

Elle est intelligente : elle vérifie si le cache existe déjà avant d’essayer de le restaurer et l’enregistre s’il n’existe pas.

Clé et chemin du cache

Deux paramètres essentiels de actions/cache sont key et path :

  • key : chaîne unique qui identifie votre cache. Si un cache associé à cette clé est trouvé, il est restauré.
  • path : chemins des fichiers ou répertoires que vous souhaitez mettre en cache. Cela indique à l’action *quoi* enregistrer ou restaurer.

La clé contient souvent une empreinte des fichiers de dépendances afin de garantir l’invalidation du cache lorsque les dépendances changent.

Mise en cache des dépendances de Node.js

Mettons en cache node_modules pour un projet Node.js. Nous utiliserons hashFiles pour créer une clé dynamique basée sur package-lock.json.

Essayez d’exécuter cet extrait de flux de travail simple :

name: Node.js CI with Cache

on: [push]

jobs:
  build:
    runs-on: ubuntu-latest
    steps:
    - uses: actions/checkout@v4
    - name: Cache Node.js modules
      uses: actions/cache@v3
      with:
        path: node_modules
        key: npm-${{ hashFiles('package-lock.json') }}
        restore-keys: |
          npm-
    - name: Install dependencies
      run: npm ci
    - name: Run tests
      run: npm test

Solution de repli avec les clés de restauration

Que se passe-t-il si votre key exacte ne correspond à aucun cache ? C’est là que les restore-keys sont utiles !

Les restore-keys fournissent une liste de clés de repli à rechercher. Si la clé principale, par exemple npm-${{ hashFiles(...) }}, ne correspond à aucun cache, GitHub Actions tente d’en trouver un à l’aide des restore-keys, dans l’ordre.

Dans notre exemple, npm- cherche un cache commençant par « npm- », ce qui est utile si seules des versions mineures des dépendances ont changé.

Mise en cache des dépendances Python

La mise en cache ne se limite pas à Node.js ! Vous pouvez appliquer le même principe à d’autres langages, comme Python. Ici, nous mettons en cache l’environnement virtuel de Python et le cache de pip.

La clé utilise hashFiles('requirements.txt'), tandis que le chemin pointe vers l’environnement virtuel et le répertoire du cache de pip.

name: Python CI with Cache

on: [push]

jobs:
  build:
    runs-on: ubuntu-latest
    steps:
    - uses: actions/checkout@v4
    - name: Set up Python
      uses: actions/setup-python@v5
      with:
        python-version: '3.x'
    - name: Cache Python dependencies
      uses: actions/cache@v3
      with:
        path: |
          ~/.cache/pip
          .venv
        key: pip-${{ hashFiles('requirements.txt') }}
        restore-keys: |
          pip-
    - name: Install dependencies
      run: |
        python -m venv .venv
        .venv/bin/pip install -r requirements.txt
    - name: Run tests
      run: .venv/bin/python -m unittest discover

Quand invalider le cache

Un cache n’est utile que s’il est suffisamment à jour. Si vos dépendances changent, votre cache doit changer lui aussi !

Le cache est automatiquement invalidé si votre key principale, par exemple npm-${{ hashFiles('package-lock.json') }}, change. Si package-lock.json est mis à jour, l’empreinte change et un nouveau cache est créé.

Vous pouvez également forcer la reconstruction d’un cache en modifiant manuellement la clé, par exemple en ajoutant un suffixe de version tel que npm-v2-${{ hashFiles(...) }}.

Portée et limites du cache

Il est utile de savoir comment fonctionne la mise en cache en arrière-plan :

  • Portée : les caches sont associés à chaque dépôt et à chaque branche. Un cache de la branche main ne sera pas utilisé sur une branche de fonctionnalité, sauf si vous configurez explicitement lookup-path.
  • Limite de taille : chaque cache peut atteindre 10 Go.
  • Durée de conservation : les caches sont conservés pendant 7 jours après leur dernier accès. Les anciens caches inutilisés sont automatiquement supprimés.

Bonnes pratiques de mise en cache

Pour tirer le meilleur parti de la mise en cache :

  • Utilisez hashFiles : associez toujours votre clé de cache aux fichiers manifestes des dépendances, par exemple package-lock.json et requirements.txt.
  • Soyez précis avec path : ne mettez en cache que ce qui est nécessaire, par exemple node_modules et ~/.cache/pip.
  • Utilisez restore-keys : fournissez des solutions de repli pour améliorer le taux de réussite des récupérations du cache.
  • Évitez de mettre en cache les données volatiles : ne mettez pas en cache les fichiers qui changent fréquemment ou qui sont très volumineux et propres à chaque exécution, par exemple les artefacts de compilation destinés au déploiement.

Défi : clé du cache

Vous avez un projet Java qui utilise Maven. Ses dépendances sont définies dans pom.xml, et Maven stocke généralement les fichiers JAR téléchargés dans ~/.m2/repository.

Quelle configuration du cache garantit le mieux la mise en cache des dépendances Maven et leur invalidation correcte lorsque pom.xml change ?

Récapitulatif : le cache pour gagner en rapidité !

Excellent travail ! Vous avez appris à mettre en œuvre la mise en cache dans GitHub Actions afin d’accélérer considérablement vos flux de travail CI/CD.

  • L’action actions/cache est votre outil.
  • Utilisez key et path pour définir quoi mettre en cache et comment.
  • hashFiles crée des clés dynamiques pour une invalidation intelligente.
  • restore-keys fournit de précieuses solutions de repli.

En mettant intelligemment les dépendances en cache, vous réduisez le temps de compilation et la consommation de ressources informatiques, ce qui rend vos chaînes plus efficaces !

Questions Fréquemment Posées

La leçon « Mise en cache des dépendances pour accélérer l’exécution » est-elle gratuite ?

Oui — le texte complet de « Mise en cache des dépendances pour accélérer l’exécution » 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 « Mise en cache des dépendances pour accélérer l’exécution » ?

Mettez en œuvre la mise en cache pour accélérer considérablement l’exécution de vos flux de travail en réutilisant les dépendances générées et les sorties de compilation. 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 « Mise en cache des dépendances pour accélérer l’exécution » ?

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. Générations matricielles pour plusieurs environnements
  2. Mise en cache des dépendances pour accélérer l’exécution
  3. Flux de travail et actions réutilisables
  4. Exécution conditionnelle et dépendances entre tâches
← Retour à DevOps Bootcamp