{"meta":{"title":"Référence sur la mise en cache des dépendances","intro":"Recherchez des informations sur la fonctionnalité de mise en cache des dépendances dans les workflows.","product":"GitHub Actions","breadcrumbs":[{"href":"/fr/actions","title":"GitHub Actions"},{"href":"/fr/actions/reference","title":"Référence"},{"href":"/fr/actions/reference/workflows-and-actions","title":"Flux de travail et actions"},{"href":"/fr/actions/reference/workflows-and-actions/dependency-caching","title":"Mise en cache des dépendances"}],"documentType":"article"},"body":"# Référence sur la mise en cache des dépendances\n\nRecherchez des informations sur la fonctionnalité de mise en cache des dépendances dans les workflows.\n\n## Utilisation de l’action `cache`\n\nL’[`cache`action](https://github.com/actions/cache) tentera d’exécuter la séquence suivante lors de la restauration d’un cache :\n\n1. Tout d’abord, elle recherchera une correspondance exacte avec la `key` que vous avez fournie.\n2. Si aucune correspondance exacte n’est trouvée, elle recherchera des correspondances partielles de la `key`.\n3. Si aucune correspondance n’est trouvée et que vous avez fourni des `restore-keys`, ces clés seront vérifiées séquentiellement pour trouver des correspondances partielles. Pour plus d’informations, consultez [Correspondance des clés de cache](#cache-key-matching).\n\nS’il existe une correspondance exacte avec la clé `key` fournie, cela est considéré comme un accès au cache. Si aucun cache ne correspond exactement à la clé `key` fournie, cela est considéré comme un échec de cache. En cas d’échec d’accès au cache, l’action crée automatiquement un cache si le travail se termine correctement. Le nouveau cache utilise la `key` que vous avez fournie, et contient les fichiers que vous spécifiez dans `path`. Pour plus d’informations sur la façon dont ce processus est géré, consultez [Correspondances dans le cache et échecs](#cache-hits-and-misses).\n\nVous ne pouvez pas modifier le contenu d’un cache existant. Au lieu de cela, vous pouvez créer un cache avec une nouvelle clé.\n\n### Paramètres d’entrée pour l’action `cache`\n\n* `key` : **Obligatoire** Clé créée lors de l’enregistrement d’un cache et clé utilisée pour rechercher un cache. Il peut s’agir de d’une combinaison quelconque de variables, de valeurs de contexte, de chaînes statiques et de fonctions. Les clés ont une longueur maximale de 512 caractères, et les clés dépassant la longueur maximale entraînent l’échec de l’action.\n\n* `path` : **Obligatoire** Chemin(s) d’accès sur l’exécuteur à mettre en cache ou à restaurer.\n  * Vous pouvez spécifier un chemin d’accès unique ou en ajouter plusieurs sur des lignes distinctes. Voici un exemple :\n\n    ```yaml\n    - name: Cache Gradle packages\n      uses: actions/cache@v4\n      with:\n        path: |\n          ~/.gradle/caches\n          ~/.gradle/wrapper\n    ```\n\n  * Vous pouvez spécifier des répertoires ou des fichiers individuels, et les modèles Glob sont pris en charge.\n\n  * Vous pouvez spécifier des chemins d’accès absolus ou relatifs au répertoire de l’espace de travail.\n\n* `restore-keys` : **Facultatif** Chaîne contenant d’autres clés de restauration, chacune placée sur une nouvelle ligne. Si aucune correspondance dans le cache n’a lieu pour `key`, ces clés de restauration sont utilisées séquentiellement dans l’ordre fourni pour trouver et restaurer un cache. Voici un exemple :\n\n  ```yaml\n  restore-keys: |\n    npm-feature-${{ hashFiles('package-lock.json') }}\n    npm-feature-\n    npm-\n  ```\n\n* `enableCrossOsArchive` : **Optional** Valeur booléenne qui, lorsqu’elle est activée, permet aux exécuteurs Windows d’enregistrer ou de restaurer des caches indépendamment du système d’exploitation sur lequel le cache a été créé. Si ce paramètre n’est pas défini, la valeur par défaut est `false`. Pour plus d’informations, consultez [Cache entre systèmes d’exploitation](https://github.com/actions/cache/blob/main/tips-and-workarounds.md#cross-os-cache) dans la documentation sur le Cache Actions.\n\n> \\[!NOTE]\n> Nous vous recommandons de ne pas stocker d’informations sensibles, telles que des jetons d’accès ou des identifiants de connexion, dans les fichiers situés dans le chemin du cache. Toute personne disposant d’un accès en lecture peut créer une demande de tirage sur un dépôt et accéder au contenu d’un cache. De plus, les duplications (forks) d’un dépôt peuvent créer des demandes de tirage sur la branche de base et accéder aux caches sur cette branche.\n\n### Paramètres de sortie pour l’action `cache`\n\n* `cache-hit` : valeur booléenne indiquant une correspondance exacte trouvée pour la clé.\n\n### Correspondances dans le cache et échecs\n\nQuand `key` correspond exactement à un cache existant, il s’agit d’une *correspondance dans le cache*, et l’action restaure les fichiers mis en cache dans le répertoire `path`.\n\nQuand `key` ne correspond pas à un cache existant, il s’agit d’une *absence dans le cache*, et un nouveau cache est automatiquement créé si le travail se termine correctement.\n\nQuand une absence dans le cache se produit, l’action recherche également des correspondances dans vos `restore-keys` spécifiées :\n\n1. Si vous fournissez des `restore-keys`, l’action `cache` recherche de manière séquentielle les caches qui correspondent à la liste de `restore-keys`.\n   * Lorsqu’il existe une correspondance exacte, l’action restaure les fichiers du cache dans le répertoire `path`.\n   * S’il n’existe aucune correspondance exacte, l’action recherche des correspondances partielles des clés de restauration. Lorsque l’action trouve une correspondance partielle, le cache le plus récent est restauré dans le répertoire `path`.\n2. L’action `cache` se termine et l’étape suivante du travail s’exécute.\n3. Si le travail se termine correctement, l’action crée automatiquement un nouveau cache avec le contenu du répertoire `path`.\n\nPour une explication plus détaillée du processus correspondance du cache, consultez  [Correspondance d’une clé de cache](#cache-key-matching).\n\n### Exemple d’utilisation de l’action `cache`\n\nCet exemple crée un cache en cas de changement des packages du fichier `package-lock.json` ou du système d’exploitation de l’exécuteur. La clé de cache utilise des contextes et des expressions pour générer une clé qui inclut le système d’exploitation de l’exécuteur et un hachage SHA-256 du fichier `package-lock.json`.\n\n```yaml copy\nname: Caching with npm\non: push\njobs:\n  build:\n    runs-on: ubuntu-latest\n    steps:\n      - uses: actions/checkout@v6\n\n      - name: Cache node modules\n        id: cache-npm\n        uses: actions/cache@v4\n        env:\n          cache-name: cache-node-modules\n        with:\n          # npm cache files are stored in `~/.npm` on Linux/macOS\n          path: ~/.npm\n          key: ${{ runner.os }}-build-${{ env.cache-name }}-${{ hashFiles('**/package-lock.json') }}\n          restore-keys: |\n            ${{ runner.os }}-build-${{ env.cache-name }}-\n            ${{ runner.os }}-build-\n            ${{ runner.os }}-\n\n      - if: ${{ steps.cache-npm.outputs.cache-hit != 'true' }}\n        name: List the state of node modules\n        continue-on-error: true\n        run: npm list\n\n      - name: Install dependencies\n        run: npm install\n\n      - name: Build\n        run: npm run build\n\n      - name: Test\n        run: npm test\n```\n\n### Utilisation de contextes pour créer des clés de cache\n\nUne clé de cache peut inclure les contextes, fonctions, littéraux et opérateurs pris en charge par GitHub Actions. Pour plus d’informations, consultez « [Référence des contextes](/fr/actions/learn-github-actions/contexts) » et « [Évaluer des expressions dans les workflows et les actions.](/fr/actions/learn-github-actions/expressions) ».\n\nL’utilisation d’expressions pour créer une clé (`key`) vous permet de créer automatiquement un cache lorsque des dépendances changent.\n\nPar exemple, vous pouvez créer une `key` à l’aide d’une expression qui calcule le hachage d’un fichier npm `package-lock.json`. Ainsi, lorsque les dépendances qui composent le fichier `package-lock.json` changent, la clé du cache change et un nouveau cache est automatiquement créé.\n\n```yaml\nnpm-${{ hashFiles('package-lock.json') }}\n```\n\nGitHub évalue l’expression `hash \"package-lock.json\"` pour dériver la clé (`key`) finale.\n\n```yaml\nnpm-d5ea0750\n```\n\n### Utilisation de la sortie de l’action `cache`\n\nVous pouvez utiliser la sortie de l’action `cache` pour effectuer quelque chose en fonction de l’occurrence d’une correspondance dans le cache ou d’une absence dans le cache. Quand une correspondance exacte est trouvée pour un cache pour l’élément `key` spécifié, la sortie `cache-hit` est définie sur `true`.\n\nDans l’exemple de workflow ci-dessus, une étape répertorie l’état des modules Node si une absence dans le cache s’est produite :\n\n```yaml\n- if: ${{ steps.cache-npm.outputs.cache-hit != 'true' }}\n  name: List the state of node modules\n  continue-on-error: true\n  run: npm list\n```\n\n## Correspondance d’une clé de cache\n\nL’action `cache` recherche d’abord des correspondances dans le cache pour `key` et dans le cache *version* dans la branche contenant l’exécution du workflow. Si aucun résultat n’est trouvé, elle recherche des correspondances par préfixe pour `key`, et si aucune correspondance n’est trouvée, elle effectue une recherche pour `restore-keys` et la *version*. S’il n’y a toujours aucun résultat dans la branche actuelle, l’action `cache` retente les mêmes étapes sur la branche par défaut. Notez que les restrictions d’étendue s’appliquent pendant la recherche. Pour plus d’informations, consultez [Restrictions relatives à l’accès à un cache](#restrictions-for-accessing-a-cache).\n\nLa version du cache est un moyen de marquer un cache avec les métadonnées de `path` et de l’outil de compression utilisé lors de la création du cache. Cela garantit que l’exécution du workflow correspond de manière unique à un cache qu’il peut réellement décompresser et utiliser. Pour plus d’informations, consultez [Version du cache](https://github.com/actions/cache#cache-version) dans la documentation Cache Actions.\n\n```\n          `restore-keys` vous permet de spécifier une liste de clés de restauration alternatives à utiliser en cas d’absence dans le cache sur `key`. Vous pouvez créer plusieurs clés de restauration classées de la plus spécifique à la moins spécifique. L’action `cache` recherche les `restore-keys` dans un ordre séquentiel. Lorsqu’une clé n’a pas de correspondance directe, l’action recherche les clés ayant comme préfixe la clé de restauration. S’il existe plusieurs correspondances partielles pour une clé de restauration, l’action retourne le dernier cache créé.\n```\n\n### Exemple utilisant plusieurs clés de restauration\n\n```yaml\nrestore-keys: |\n  npm-feature-${{ hashFiles('package-lock.json') }}\n  npm-feature-\n  npm-\n```\n\nL’exécuteur évalue les expressions, qui sont résolues en ces `restore-keys` :\n\n```yaml\nrestore-keys: |\n  npm-feature-d5ea0750\n  npm-feature-\n  npm-\n```\n\nLa clé de restauration `npm-feature-` correspond à n’importe quelle clé qui commence par la chaîne `npm-feature-`. Par exemple, les deux clés `npm-feature-fd3052de` et `npm-feature-a9b253ff` correspondent à la clé de restauration. Le cache ayant la date de création la plus récente est utilisé. Dans cet exemple, les clés sont recherchées dans l’ordre suivant :\n\n1. ```\n          **\n          `npm-feature-d5ea0750`\n          ** correspond à un hachage spécifique.\n   ```\n2. ```\n          **\n          `npm-feature-`\n          ** correspond aux clés de cache ayant comme préfixe `npm-feature-`.\n   ```\n3. ```\n          **\n          `npm-`\n          ** correspond à n’importe quelle clé ayant comme préfixe `npm-`.\n   ```\n\n#### Exemple de priorité de recherche\n\n```yaml\nkey:\n  npm-feature-d5ea0750\nrestore-keys: |\n  npm-feature-\n  npm-\n```\n\nPar exemple, si une demande de tirage contient une branche `feature` et cible la branche par défaut (`main`), l’action recherche `key` et `restore-keys` dans l’ordre suivant :\n\n1. Clé `npm-feature-d5ea0750` dans la branche `feature`\n2. Clé `npm-feature-` dans la branche `feature`\n3. Clé `npm-` dans la branche `feature`\n4. Clé `npm-feature-d5ea0750` dans la branche `main`\n5. Clé `npm-feature-` dans la branche `main`\n6. Clé `npm-` dans la branche `main`\n\n## Actions `setup-*` pour des gestionnaires de package spécifiques\n\nSi vous mettez en cache les gestionnaires de package répertoriés ci-dessous, l’utilisation de leurs actions setup-\\* respectives nécessite une configuration minimale, et crée et restaure les caches de dépendances pour vous.\n\n| Gestionnaires de package | action setup-\\* pour la mise en cache |\n| ------------------------ | ------------------------------------- |\n| npm, Yarn, pnpm          |                                       |\n\n```\n          [setup-node](https://github.com/actions/setup-node#caching-global-packages-data)                  |\n```\n\n\\| pip, pipenv, Poésie |\n[setup-python](https://github.com/actions/setup-python#caching-packages-dependencies)             |\n\\| Gradle, Maven       |\n[setup-java](https://github.com/actions/setup-java#caching-packages-dependencies)                 |\n\\| RubyGems            |\n[setup-ruby](https://github.com/ruby/setup-ruby#caching-bundle-install-automatically)             |\n\\| Go `go.sum`         |\n[setup-go](https://github.com/actions/setup-go#caching-dependency-files-and-build-outputs)        |\n\\| .NET NuGet          |\n[setup-dotnet](https://github.com/actions/setup-dotnet?tab=readme-ov-file#caching-nuget-packages) |\n\n## Restrictions relatives à l’accès à un cache\n\nLes restrictions d’accès fournissent l’isolement et la sécurité du cache en créant une limite logique entre les différentes branches ou étiquettes.\nLes exécutions de workflow peuvent restaurer les caches créés dans la branche actuelle ou dans la branche par défaut (généralement `main`). Si une exécution de workflow est déclenchée pour une demande de tirage (pull request), elle peut également restaurer les caches créés dans la branche de base, y compris les branches de base des référentiels dupliqués. Par exemple, si la branche `feature-b` a la branche `feature-a` de base, une exécution de workflow déclenchée sur une demande de tirage a accès aux caches créés dans la branche par défaut `main`, la branche `feature-a` de base et la branche `feature-b` actuelle.\n\nLes exécutions de workflow ne peuvent pas restaurer les caches créés pour les branches enfants ou les branches sœurs. Par exemple, un cache créé pour la branche enfant `feature-b` ne serait pas accessible à une exécution de workflow déclenchée sur la branche `main` parente. De même, un cache créé pour la branche `feature-a` avec la branche `main` de base n’est pas accessible à sa branche `feature-c` sœur avec la branche `main` de base. Les exécutions de workflow ne peuvent pas non plus restaurer les caches créés pour différents noms d’étiquettes. Par exemple, un cache créé pour l’étiquette `release-a` (à partir de la base `main`) ne sera pas accessible à une exécution de workflow déclenchée pour l’étiquette `release-b` (avec la base `main`).\n\nLorsqu’un cache est créé par une exécution de workflow déclenchée sur une demande de tirage, le cache est créé pour la référence de fusion (`refs/pull/.../merge`). Pour cette raison, le cache aura une étendue limitée et ne peut être restauré que par les ré-exécutions de la demande de tirage. Il ne peut pas être restauré par la branche de base ou d’autres demandes de tirage ciblant cette branche de base.\n\nPlusieurs exécutions de workflow dans un référentiel peuvent partager des caches. Un cache créé pour une branche au sein d’une exécution de workflow est accessible et peut être restauré à partir d’une autre exécution de workflow pour le même référentiel et la même branche.\n\n## Limites d’utilisation et stratégie d’éviction\n\nGitHub applique des limites au stockage et à la rétention du cache pour gérer les coûts de stockage et empêcher les abus. La compréhension de ces limites vous permet d’optimiser l’utilisation de votre cache.\n\n### Limites par défaut\n\nGitHub supprime toutes les entrées de cache qui n’ont pas été accessibles au cours des 7 derniers jours. Il n’existe aucune limite quant au nombre de caches que vous pouvez stocker, mais la taille totale de tous les caches d’un référentiel est limitée. Par défaut, la limite est de 10 Go par référentiel, mais cette limite peut être augmentée par les propriétaires d’entreprise, les propriétaires d’organisations ou les administrateurs de référentiel. Toute utilisation supérieure à 10 Go est facturée à votre compte. Une fois qu’un référentiel a atteint sa capacité maximale de stockage dans le cache, la stratégie d’éviction du cache libère de l’espace en supprimant les caches par ordre de date d’accès, du plus ancien au plus récent.\n\nSi vous dépassez la limite, GitHub enregistrera le nouveau cache, mais commencera à écarter les caches jusqu’à ce que la taille totale soit inférieure à la limite du dépôt. Le processus d’éviction du cache peut provoquer un vidage du cache, où les caches sont créés et supprimés à une fréquence élevée. Pour réduire ce problème, vous pouvez passer en revue les caches d’un référentiel et prendre des mesures correctives, telles que la suppression de la mise en cache à partir de flux de travail spécifiques ou augmenter la taille de votre cache. Cette fonctionnalité est uniquement disponible pour les utilisateurs disposant d’un mode de paiement sur un fichier qui optent en configurant les paramètres de cache. Consultez [Gestion des caches](/fr/actions/how-tos/managing-workflow-runs-and-deployments/managing-workflow-runs/manage-caches).\n\nVous pouvez créer des entrées de cache à un taux maximal de 200 chargements par minute par dépôt et les télécharger à un taux de 1500 téléchargements par minute par dépôt. Si vous dépassez ce taux, les tentatives de téléchargement ou de chargement du cache suivantes échouent jusqu’à ce que la limite de débit appropriée soit réinitialisée. Le délai avant la réinitialisation de la limite de débit est renvoyé dans l’en-tête `Retry-After` de la réponse. Pour plus d’informations sur les limites de débit des GitHub Actions, consultez la section [Limites d’Actions](/fr/actions/reference/limits).\n\n### Augmentation de la taille du cache\n\nSi vous souhaitez réduire le taux auquel les entrées de cache sont supprimées, vous pouvez augmenter les limites de stockage de votre cache dans les paramètres d’actions. Les dépôts détenus par les utilisateurs peuvent configurer jusqu’à 10 To par référentiel. Pour les référentiels appartenant à des organisations, la limite configurable maximale est déterminée par les paramètres de l’organisation. Pour les organisations appartenant à une entreprise, la limite configurable maximale est déterminée par les paramètres de l’entreprise. L’augmentation de la limite au-delà de la valeur par défaut de 10 Go entraîne des coûts supplémentaires, si ce stockage est utilisé.\n\nPour plus d’informations, consultez :\n\n* [Gestion des paramètres de GitHub Actions pour un référentiel](/fr/repositories/managing-your-repositorys-settings-and-features/enabling-features-for-your-repository/managing-github-actions-settings-for-a-repository#configuring-cache-settings-for-your-repository)\n* [Désactivation ou limitation des GitHub Actions pour votre organisation](/fr/organizations/managing-organization-settings/disabling-or-limiting-github-actions-for-your-organization#managing-github-actions-cache-storage-for-your-organization)\n* [Application de stratégies pour GitHub Actions dans votre entreprise](/fr/enterprise-cloud@latest/admin/enforcing-policies/enforcing-policies-for-your-enterprise/enforcing-policies-for-github-actions-in-your-enterprise#artifact-and-log-retention)\n\nL’utilisation d’un stockage supplémentaire est également contrôlée par les budgets définis pour GitHub Actions ou le SKU de stockage du cache des Actions. Si vous avez des limites configurées et que vous dépassez un budget, votre cache devient en lecture seule jusqu’à ce que votre état de facturation soit résolu ou que votre utilisation dépasse la limite gratuite de 10 Go par expiration ou suppression explicite des caches. Pour plus d’informations sur la configuration des budgets, consultez [Configurer des budgets pour contrôler les dépenses liées aux produits facturés à l’usage](/fr/billing/how-tos/set-up-budgets).\n\nLa définition de vos budgets SKU de stockage du cache Actions à des niveaux inférieurs au coût total de l'utilisation du stockage configuré au cours de votre période de facturation peut souvent placer votre cache en mode lecture seule. Par exemple, si votre budget pour la référence SKU est de 0 $ et que vous avez configuré la taille maximale du cache de votre référentiel à 20 Go, votre cache entre en mode lecture seule dès que le stockage dépasse le seuil gratuit.\n\nVous trouverez ci-dessous des coûts mensuels illustrant les budgets que vous souhaiterez peut-être définir pour la référence SKU Stockage cache Actions.\n\n| Taille du cache | Coût mensuel (s’il est entièrement utilisé) |\n| --------------- | ------------------------------------------- |\n| 50 Go           | 2,80 $                                      |\n| 200 Go          | 13,30 $                                     |\n| 1 000 Go        | 69,30 $                                     |\n\n## Étapes suivantes\n\nPour gérer vos caches de dépendances, consultez [Gestion des caches](/fr/actions/how-tos/managing-workflow-runs-and-deployments/managing-workflow-runs/manage-caches)."}