# Écosystèmes et référentiels pris en charge par Dependabot
Dependabot prend en charge un large éventail d’écosystèmes et de référentiels
Cet article fournit des informations de référence sur les écosystèmes de package et les types de référentiels qui Dependabot prennent en charge.
Dependabot est un GitHub outil qui permet de sécuriser vos dépendances et de les maintenir à jour. Il détecte automatiquement les dépendances vulnérables ou obsolètes dans vos référentiels et crée des demandes de tirage pour les mettre à jour, ce qui facilite la maintenance de votre sécurité de la chaîne d’approvisionnement logicielle. Pour plus d’informations, consultez « [Guide de démarrage rapide Dependabot](/fr/code-security/tutorials/secure-your-dependencies/dependabot-quickstart) ».
## Écosystèmes pris en charge par GitHub
Vous pouvez configurer les mises à jour pour les référentiels qui contiennent un fichier de verrouillage ou manifeste de dépendance pour l’un des gestionnaires de packages pris en charge. Pour certains gestionnaires de packages, vous pouvez également configurer le placement dans le répertoire fournisseur pour les dépendances. Pour plus d’informations, consultez [`vendor`](/fr/code-security/reference/supply-chain-security/dependabot-options-reference#vendor--).
Dependabot prend également en charge les dépendances dans les registres privés. Pour plus d’informations, consultez « [Configuration de l’accès aux registres privés pour Dependabot](/fr/code-security/how-tos/secure-your-supply-chain/manage-your-dependency-security/configure-access-to-private-registries) ».
> \[!NOTE]
>
> * Lors de l’exécution de mises à jour de sécurité ou de version, certains écosystèmes doivent être capables de résoudre toutes les dépendances de leur source pour vérifier que les mises à jour ont réussi. Si votre manifeste ou vos fichiers de verrouillage contiennent des dépendances privées, Dependabot vous devez pouvoir accéder à l’emplacement où ces dépendances sont hébergées. Les propriétaires d'organisation peuvent accorder à Dependabot l'accès à des référentiels privés contenant les dépendances d'un projet au sein de la même organisation. Pour plus d’informations, consultez « [Gestion des paramètres de sécurité et d'analyse pour votre organisation](/fr/organizations/keeping-your-organization-secure/managing-security-settings-for-your-organization/managing-security-and-analysis-settings-for-your-organization#allowing-dependabot-to-access-private-dependencies) ». Vous pouvez configurer un accès aux registres privés dans le fichier de configuration `dependabot.yml` d’un dépôt. Pour plus d’informations, consultez « [Configuration de l’accès aux registres privés pour Dependabot](/fr/code-security/how-tos/secure-your-supply-chain/manage-your-dependency-security/configure-access-to-private-registries) ».
> *
Dependabot ne prend pas en charge les dépendances privées GitHub pour tous les gestionnaires de package. Pour plus d’informations, consultez le tableau ci-dessous.
Si votre référentiel utilise déjà une intégration pour la gestion des dépendances, vous devez le désactiver avant d’activer Dependabot.
Pour plus d’informations, consultez [À propos des intégrations GitHub](/fr/integrations/concepts/about-integrations).
| Gestionnaire de package | Valeur YAML | Versions prises en charge | Mises à jour de version | Mises à jour de sécurité | Dépôts privés | Registres privés | Vendoring |
| ----------------------- | ----------- | ------------------------- | :----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------: | :---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------: | :----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------: | :---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------: | :---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------: |
| | | | | | | | |
| Bazel | `bazel` | v7, v8, v9 | | | | | |
| | | | | | | | |
[Bun](#bun) | `bun` | >=v1.1.39 | | | | | |
Bundler | `bundler` | v2 | | | | | |
[Cargo](#cargo) | `cargo` | v1 | | | | | |
Composer | `composer` | v2 | | | | | |
\| |
[Conda](#conda) | `conda` | Non applicable | | | | | |
\| |
\| |
[Deno](#deno) | `deno` | >=v2 | | | | | |
\| |
[Conteneurs de développement](#dev-containers) | `devcontainers` | Non applicable | | | | | |
[Docker](#docker) | `docker` | v1 | | | | | Non applicable |
[Docker Compose](#docker-compose) | `docker-compose` | v2, v3 | | | | | Non applicable |
Kit de développement logiciel (SDK) .NET | `dotnet-sdk` | >=.NET Core 3.1 | | | Non applicable | Non applicable | Non applicable |
[Graphiques Helm](#helm-charts) | `helm` |
v3 | | | | | Non applicable |
Hex | `mix` | v1 | | | | | |
\| |
[Julia](#julia) | `julia` | >= v1.10 | | | | | |
\| |
elm-package | `elm` | v0.19 | | | | | |
sous-module git | `gitsubmodule` | Non applicable | | | | | Non applicable |
[GitHub Actions](#github-actions) | `github-actions` | Non applicable | | | | | Non applicable |
Modules Go | `gomod` | v1 | | | | | |
[Gradle](#gradle) | `gradle` | Non applicable | | | | | |
[Maven](#maven) | `maven` | Non applicable | | | | | |
\| |
[Nix](#nix) | `nix` | Non applicable | | | | Non applicable | Non applicable |
\| |
npm | `npm` | v7, v8, v9, v10, v11 | | | | | |
[NuGet](#nuget-cli) | `nuget` | <=6.12.0 | | | | | |
\| |
[OpenTofu](#opentofu) | `opentofu` | Non applicable | | | | | Non applicable |
\| |
[pip](#pip-and-pip-compile) | `pip` | 26.1.1 | | | | | |
pipenv | `pip` | 2024.4.1 | | | | | |
[pip-compile](#pip-and-pip-compile) | `pip` | 7.5.3 | | | | | |
\| pnpm | `npm` | v7, v8, v9, v10 | | | | | |
[Poésie](#poetry) | `pip` | v2 | | | | | |
\| |
[pre-commit](#pre-commit) | `pre-commit` | Non applicable | | | | | |
\| |
[pub](#pub) | `pub` | v2 | | | | | |
\| |
[Chaîne d'outils Rust](#rust-toolchain) | `rust-toolchain` | Non applicable | | | | Non applicable | Non applicable |
\| |
\| |
[sbt](#sbt) | `sbt` | Non applicable | | | | | |
\| |
[Rapide](#swift) | `swift` | v5, v6 | | | | (git uniquement) | |
[Terraform](#terraform) | `terraform` | >= 0,13, <= 1.15.x | | | | | Non applicable |
\| |
uv | `uv` | v0.11 | | | | | Non applicable |
\| |
\| |
[vcpkg](#vcpkg) | `vcpkg` | Non applicable | | | | | Non applicable |
\| |
[yarn](#yarn) | `npm` | v1, v2, v3, v4 | | | | | |
> \[!TIP]
> Pour les gestionnaires de package tels que `pipenv` et `poetry`, vous devez utiliser la valeur YAML `pip`. Par exemple, si vous utilisez `poetry` pour gérer vos dépendances Python et que vous souhaitez que Dependabot surveille votre fichier manifeste de dépendance pour les nouvelles versions, utilisez `package-ecosystem: "pip"` dans votre fichier `dependabot.yml`.
Pour plus d’informations sur la prise en charge de l'écosystème pour Dependabot security updates, consultez également [Écosystèmes de packages pris en charge par le graphe des dépendances](/fr/code-security/reference/supply-chain-security/dependency-graph-supported-package-ecosystems).
### Bun
Dependabot prend en charge le fichier texte `bun.lock` par défaut actuel, mais pas le fichier binaire `bun.lockb` hérité. Le fichier `bun.lock` est pris en charge dans la version 1.1.39 et ultérieures. Pour plus d’informations, consultez [Lockfile](https://bun.sh/docs/install/lockfile) dans la documentation Bun.
### Cargo
La prise en charge des registres privés inclut les registres cargo, ce qui vous permet d’utiliser Dependabot pour maintenir vos dépendances Rust à jour. Pour plus d’informations, consultez « [Aide pour la configuration des registres privés pour Dependabot](/fr/code-security/how-tos/secure-your-supply-chain/manage-your-dependency-security/configure-private-registries#cargo) ».
### Conda
Dependabot La prise en charge de Conda **n’inclut pas de registres privés, de fournisseurs ou de mises à jour de fichiers de verrouillage**.
### Deno
Dependabot peut mettre à jour les dépendances dans les fichiers de configuration `deno.json` et `deno.jsonc`. Les projets Deno peuvent utiliser des dépendances à partir de [JSR](https://jsr.io/) (registre JavaScript) ou du registre npm.
Dependabot la prise en charge de Deno **n’inclut pas de registres privés ou de fournisseurs**.
### Conteneurs de développement
Vous pouvez utiliser `devcontainers` comme `package-ecosystem` dans votre fichier `dependabot.yml` afin de mettre à jour les fonctionnalités dans vos fichiers de configuration `devcontainer.json`. Pour plus d’informations sur cette prise en charge et pour obtenir des exemples de fichiers de configuration, consultez [la disponibilité générale de l’intégrationDependabot](https://containers.dev/guide/dependabot) dans la documentation des conteneurs de développement.
Les conteneurs de développement sont utilisés dans plusieurs outils et services, notamment Codespaces. Pour plus d’informations sur les fonctionnalités et les services pris en charge, consultez respectivement [Fonctionnalités](https://containers.dev/implementors/features/) et [Outils et services de prise en charge](https://containers.dev/supporting) dans la documentation sur les conteneurs de développement.
Cette mise à jour garantit que les fonctionnalités sont épinglées à la dernière version `major` du fichier `devcontainer.json` associé. Si un conteneur de développement a un fichier de verrouillage, ce fichier est également mis à jour. Pour plus d’informations sur les spécifications d’un fichier de verrouillage, consultez [Fichiers de verrouillage](https://github.com/devcontainers/spec/blob/main/docs/specs/devcontainer-lockfile.md) dans le dépôt `devcontainers/spec`.
Les fonctionnalités de n’importe quel emplacement de conteneur de développement valide sont mises à jour dans une demande de tirage unique. Pour plus d’informations sur les spécifications de conteneur de développement, consultez [Spécification](https://containers.dev/implementors/spec/#devcontainerjson) dans la documentation sur les conteneurs de développement.
### Docker
Dependabot peut ajouter des métadonnées à partir d’images Docker aux pull requests pour les mises à jour de version. Les métadonnées incluent les notes de publication, les journaux de modifications et l’historique des validations. Les administrateurs de référentiels peuvent utiliser les métadonnées pour évaluer rapidement le risque de stabilité de la mise à jour des dépendances.
Pour Dependabot récupérer les métadonnées Docker, les responsables de maintenance d’images Docker doivent ajouter l’étiquette `org.opencontainers.image.source` à leur fichier Dockerfile et inclure l’URL du référentiel source. Par ailleurs, les responsables doivent étiqueter le référentiel avec les mêmes étiquettes que les images Docker publiées. Pour obtenir un exemple, consultez le dépôt [`dependabot-fixtures/docker-with-source`](https://github.com/dependabot-fixtures/docker-with-source). Pour plus d’informations sur les étiquettes Docker, consultez [Étiquettes d’image d’extension](https://docs.docker.com/desktop/extensions-sdk/extensions/labels/) et [BUILDX\_GIT\_LABELS](https://docs.docker.com/build/building/env-vars/#buildx_git_labels) dans la documentation Docker.
Dependabot peut mettre à jour des balises d’image Docker dans des manifestes Kubernetes. Ajoutez une entrée à l’élément Docker `package-ecosystem` de votre fichier `dependabot.yml` pour chaque répertoire contenant un manifeste Kubernetes qui fait référence à des étiquettes d’images Docker. Les manifestes Kubernetes peuvent être des fichiers YAML de déploiement Kubernetes ou des graphiques Helm. Pour plus d’informations sur la configuration de votre fichier `dependabot.yml` pour `docker`, consultez « `package-ecosystem` » dans [Référence des options Dependabot](/fr/code-security/reference/supply-chain-security/dependabot-options-reference#package-ecosystem-).
Dependabot prend en charge les registres Docker publics et privés. Pour obtenir la liste des registres pris en charge, consultez « `docker-registry` » dans [Configuration de l’accès aux registres privés pour Dependabot](/fr/code-security/how-tos/secure-your-supply-chain/manage-your-dependency-security/configure-access-to-private-registries#docker-registry).
Dependabot analyse les balises d’image Docker pour le contrôle de version sémantique ([SemVer](https://semver.org/)). Si Dependabot elle détecte une balise avec une préversion, elle suggère uniquement une mise à jour vers la dernière version avec une préversion correspondante, et elle ne suggère pas une version plus récente qui utilise une autre étiquette de préversion. Pour plus d’informations, consultez le fichier `dependabot-docker`[README.md](https://github.com/dependabot/dependabot-core/blob/main/docker/README.md) dans le dépôt `dependabot/dependabot-core`.
### Docker Compose
Dependabot prend en charge Docker Compose de la même façon que Docker. Pour plus d’informations, consultez [Docker](#docker).
### GitHub Actions
Dependabot prend en charge les mises à jour de version pour GitHub Actions avec les réserves suivantes.
* Dependabot prend uniquement en charge les mises à jour de GitHub Actions à l’aide de la syntaxe de dépôt GitHub, comme `actions/checkout@v6` ou `actions/checkout@` .
Dependabotignore les actions ou les flux de travail réutilisables référencés localement (par exemple). `./.github/actions/foo.yml`
* Dependabot met à jour la documentation de la version de GitHub Actions lorsque le commentaire se trouve sur la même ligne, comme `actions/checkout@ #` ou `actions/checkout@ #`.
* Si la validation que vous utilisez n’est associée à aucune balise, Dependabot met à jour la GitHub Actions validation la plus récente (qui peut différer de la dernière version).
* Docker Hub et les URL GitHub PackagesContainer registry ne sont actuellement pas pris en charge. Par exemple, les références aux actions de conteneur Docker à l'aide de la syntaxe `docker://` ne sont pas prises en charge.
* Dependabot prend en charge les dépôts publics et privés pour GitHub Actions. Pour connaître les options de configuration du registre privé, consultez « `git` » dans [Configuration de l’accès aux registres privés pour Dependabot](/fr/code-security/how-tos/secure-your-supply-chain/manage-your-dependency-security/configure-access-to-private-registries#git).
Pour plus d’informations sur l’utilisation Dependabot version updates avec GitHub Actions, consultez [Informations de référence sur l’utilisation sécurisée](/fr/actions/reference/security/secure-use#keeping-the-actions-in-your-workflows-secure-and-up-to-date).
### Gradle
Dependabot prend en charge les mises à jour des fichiers suivants sans avoir à exécuter Gradle :
* `build.gradle`, `build.gradle.kts` (pour les projets Kotlin)
* `gradle/libs.versions.toml` (pour les projets utilisant un catalogue de versions Gradle standard)
* `gradle.lockfile` (pour les projets utilisant le verrouillage des dépendances Gradle)
* Les fichiers inclus via la déclaration `apply` qui ont `dependencies` dans le nom de fichier. Notez que `apply` ne prend pas en charge `apply to`, la récursivité ou les syntaxes avancées (par exemple, les noms de fichier `apply` avec `mapOf` Kotlin définis par propriété).
Pour mettre à jour le wrapper Gradle, Dependabot exécute Gradle et met à jour :
* `gradle/wrapper/gradle-wrapper.properties`
* `gradlew`
* `gradlew.bat`
* `gradle/wrapper/gradle-wrapper.jar`
Dependabot utilise des informations du fichier de dépendances `pom.xml` pour ajouter des liens vers des informations de publication dans les requêtes de tirage de mise à jour. Si les informations sont omises dans le `pom.xml` fichier, elles ne peuvent pas être incluses dans Dependabot les demandes de tirage, consultez [Métadonnées de package Java pour les mises à jour de Dependabot](/fr/code-security/reference/supply-chain-security/java-package-metadata-dependabot).
Pour Dependabot security updates, la prise en charge de Gradle est limitée aux chargements manuels des données du graphe de dépendances à l’aide du API de soumission de dépendances. Pour plus d’informations sur API de soumission de dépendances, consultez [Utilisation de l’API de soumission de dépendances](/fr/code-security/how-tos/secure-your-supply-chain/secure-your-dependencies/use-dependency-submission-api).
> \[!NOTE]
>
> * Lorsque vous chargez des dépendances Gradle dans le graphique de dépendances à l’aide du API de soumission de dépendances, toutes les dépendances de projet sont chargées, même les dépendances transitives qui ne sont pas explicitement mentionnées dans un fichier de dépendances. Lorsqu’une alerte est détectée dans une dépendance transitive, Dependabot elle ne peut pas trouver la dépendance vulnérable dans le référentiel et ne crée donc pas de mise à jour de sécurité pour cette alerte.
> *
Dependabot version updates crée toutefois des requêtes de tirage lorsque la dépendance parente est explicitement déclarée comme dépendance directe dans le fichier manifeste du projet.
### Graphiques Helm
Dependabot prend en charge l’utilisation d’un nom d’utilisateur et d’un mot de passe pour les registres. Pour plus d’informations, consultez « [Configuration de l’accès aux registres privés pour Dependabot](/fr/code-security/how-tos/secure-your-supply-chain/manage-your-dependency-security/configure-access-to-private-registries#helm-registry) ».
Le `helm-registry` type prend uniquement en charge l’authentification HTTP De base et ne prend pas en charge les registres conformes à OCI. Si vous devez accéder à un registre compatible OCI pour les schémas Helm, configurez un `docker-registry` à la place. Pour plus d’informations, consultez « [Configuration de l’accès aux registres privés pour Dependabot](/fr/code-security/how-tos/secure-your-supply-chain/manage-your-dependency-security/configure-access-to-private-registries#docker-registry) ».
Lors de la configuration Dependabot des graphiques Helm, il met également automatiquement à jour les images Docker référencées dans ces graphiques, ce qui garantit que les versions de graphique et leurs images contenues restent à jour.
### Maven
Dependabot n’exécute pas Maven, mais prend en charge les mises à jour des `pom.xml` fichiers.
Dependabot utilise des informations du fichier de dépendances `pom.xml` pour ajouter des liens vers des informations de publication dans les requêtes de tirage de mise à jour. Si les informations sont omises dans le `pom.xml` fichier, elles ne peuvent pas être incluses dans Dependabot les demandes de tirage, consultez [Métadonnées de package Java pour les mises à jour de Dependabot](/fr/code-security/reference/supply-chain-security/java-package-metadata-dependabot).
### Nix
Dependabot surveille votre `flake.lock` fichier et ouvre des demandes de tirage lorsque des validations plus récentes sont disponibles en amont pour vos entrées flake.
GitHub les entrées GitLab, SourceHut et Git brut sont toutes prises en charge. La mise à jour des références épinglées dans `flake.nix` lui-même (par exemple, pour changer `github:cachix/devenv/v0.5` en une balise plus récente) n’est pas prise en charge.
Dependabot ne prend actuellement pas en charge les dépôts privés pour l’écosystème `nix` .
### NuGet CLI
Dependabot n’exécute pas l’interface CLI NuGet, mais prend en charge la plupart des fonctionnalités jusqu’à la version 6.8.0.
### pip et pip-compile
Dependabot prend en charge les mises à jour de n’importe quel `.txt` fichier.
En outre, Dependabot prend en charge les mises à jour des `pyproject.toml` fichiers s’ils suivent la norme PEP 621.
### poetry
Dependabot prend en charge la poésie v2.
### pre-commit
Dependabot peut mettre à jour les révisions de hooks dans `.pre-commit-config.yaml` fichiers. Lorsqu’un hook épingle un SHA de commit spécifique, Dependabot résout la dernière balise correspondante et met à jour en conséquence la `rev` valeur.
Vous pouvez utiliser un `# frozen:` commentaire après la `rev` valeur pour fixer un hook à une version ou un préfixe de version particulier.
Dependabot utilise ce commentaire pour déterminer si une mise à jour est nécessaire et quelle balise résoudre.
| Scénario | Comportement |
| ----------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------ |
| `rev: # frozen: 7.3.0` et 7.3.0 est la dernière version | Aucune mise à jour. La dépendance est déjà actuelle. |
| `rev: # frozen: 7.3.0` et 8.0.0 a été publié | Mise à jour vers le SHA pour la balise `8.0.0`. Le commentaire est mis à jour à `# frozen: 8.0.0`. |
| `rev: # frozen: v1` et `v1.43.5` sont la dernière `v1.x` version | Mise à jour vers le SHA pour la balise `v1.43.5`. Le commentaire est mis à jour à `# frozen: v1.43.5`. |
| `rev: ` sans `# frozen:` commentaire | Mise à jour vers HEAD SHA de la branche par défaut. |
Outre la mise à jour des révisions de hook, Dependabot peut mettre à jour `additional_dependencies` pour les hooks qui utilisent les langues suivantes : Python, Node, Go, Rust, Ruby et Dart.
La prise en charge du registre privé utilise des registres Git. Vous pouvez configurer l’accès aux dépôts Git privés en spécifiant un registre Git dans votre fichier `dependabot.yml`. Pour plus d’informations, consultez « [Configuration de l’accès aux registres privés pour Dependabot](/fr/code-security/how-tos/secure-your-supply-chain/manage-your-dependency-security/configure-access-to-private-registries#git) ».
> \[!NOTE]
> Les registres privés ne sont pas pris en charge pour `additional_dependencies`.
### Chaîne d'outils Rust
Dependabot prend en charge les mises à jour automatiques pour les versions de la chaîne d'outils Rust définies dans les fichiers `rust-toolchain.toml` et `rust-toolchain`.
Les modèles de Dependabot mise à jour pris en charge peuvent être mis à jour :
* Chaînes d’outils versionnées telles que `channel = "1.xx.yy"` et `channel = "1.xx"`.
* Chaînes d’outils datées telles que `channel = "nightly-YYYY-MM-DD"` et `channel = "beta-YYYY-MM-DD"`.
### sbt
Dependabot prend en charge les mises à jour des fichiers de dépendance sbt. sbt résout les artefacts des référentiels Maven et utilise le même ordre de version que Maven.
Les fichiers manifestes suivants sont pris en charge :
* `build.sbt` (racine) : récupéré comme fichier requis.
* `project/plugins.sbt`: récupéré s’il est présent.
* `project/build.properties`: récupéré s’il est présent.
* `project/*.scala`: tous les `.scala` fichiers du `project/` répertoire.
* `{subdir}/build.sbt`: analyse les sous-répertoires au niveau racine (à l’exception `project/`, `target/`, `.git`, `.github`).
### Swift
La prise en charge du registre privé s’applique uniquement aux registres Git. Les registres Swift ne sont pas pris en charge. Les manifestes non déclaratifs ne sont pas pris en charge. Pour plus d’informations sur les manifestes non déclaratifs, consultez [Modification de manifestes non déclaratifs](https://github.com/apple/swift-evolution/blob/7003da1439ad60896ec14657dfce829f04b0632c/proposals/0301-package-editing-commands.md#editing-non-declarative-manifests) dans la documentation Swift Evolution.
### Terraform
La prise en charge de Terraform comprend :
* Modules hébergés sur le registre Terraform ou sur un référentiel Git accessible au public.
* Fournisseurs Terraform.
* Registre Terraform privé. Vous pouvez configurer l’accès aux dépôts Git privés en spécifiant un registre Git dans votre fichier `dependabot.yml`. Pour plus d’informations, consultez [`git`](/fr/code-security/how-tos/secure-your-supply-chain/manage-your-dependency-security/configure-access-to-private-registries#git).
### vcpkg
La prise en charge de vcpkg comprend la mise à jour du commit SHA `builtin-baseline` à partir du dépôt de ports vcpkg dans votre fichier manifeste `vcpkg.json`. Pour plus d’informations, consultez le référentiel [`microsoft/vcpkg`](https://github.com/microsoft/vcpkg) sur GitHub.com et consultez [ Quel est le mode manifeste ?](https://learn.microsoft.com/vcpkg/concepts/manifest-mode) dans la documentation Microsoft.
### yarn
Dependabot prend en charge les dépendances fournisseur pour les versions v2 et ultérieures.
## Écosystèmes gérés par la communauté pris en charge
Les écosystèmes suivants sont maintenus par leurs gardiens de la communauté en amont. GitHub intègre Dependabot avec ces écosystèmes, mais ne les gère pas directement.
* [Julia](#julia) - Maintenue par la communauté Julia
* [OpenTofu](#opentofu) - Géré par la communauté OpenTofu
* [Pub](#pub) - Géré par the Dart Community
### Julia
Dependabot prend en charge les projets Julia qui incluent des fichiers `Project.toml`/`Manifest.toml`.
Dependabot utilise le gestionnaire de package de Julia pour résoudre et mettre à jour les dépendances.
### OpenTofu
Dependabot prend en charge la mise à jour des modules et fournisseurs OpenTofu dans les fichiers de configuration `.tf`, `.tofu`, y compris les fichiers `terragrunt.hcl`. Si le `.terraform.lock.hcl` lockfile pour les sommes de contrôle du fournisseur est présent, Dependabot le mettra également à jour.
### Pub
Dependabot n’effectue pas de mise à jour lorsque `pub` la version qu’elle tente de mettre à jour est ignorée, même si une version antérieure est disponible.
Vous pouvez utiliser Dependabot pour maintenir à jour les dépendances Dart si vous utilisez des dépôts Pub hébergés privés. Pour plus d’informations sur l’autorisation Dependabot d’accéder aux dépendances privées GitHub , consultez [Autoriser Dependabot l’accès aux dépendances privées](/fr/organizations/keeping-your-organization-secure/managing-security-settings-for-your-organization/managing-security-and-analysis-settings-for-your-organization#allowing-dependabot-to-access-private-dependencies).