{"meta":{"title":"Ecosistemas y repositorios admitidos por Dependabot","intro":"Dependabot admite una variedad de ecosistemas y repositorios","product":"Seguridad y calidad del código","breadcrumbs":[{"href":"/es/code-security","title":"Seguridad y calidad del código"},{"href":"/es/code-security/reference","title":"Referencia"},{"href":"/es/code-security/reference/supply-chain-security","title":"Seguridad de la cadena de suministro"},{"href":"/es/code-security/reference/supply-chain-security/supported-ecosystems-and-repositories","title":"Ecosistemas de Dependabot"}],"documentType":"article"},"body":"# Ecosistemas y repositorios admitidos por Dependabot\n\nDependabot admite una variedad de ecosistemas y repositorios\n\nEn este artículo se brinda información de referencia sobre los ecosistemas de paquetes y los tipos de repositorio que admite Dependabot.\n\nDependabot es una herramienta GitHub que ayuda a mantener las dependencias seguras y actualizadas. Detecta automáticamente dependencias vulnerables o obsoletas en los repositorios y crea solicitudes de incorporación de cambios para actualizarlas, lo que facilita el mantenimiento de la seguridad de la cadena de suministro de software. Para más información, consulta [Guía de inicio rápido de Dependabot](/es/code-security/tutorials/secure-your-dependencies/dependabot-quickstart-guide).\n\n## Ecosistemas compatibles mantenidos por GitHub\n\n\n\nPuede configurar actualizaciones para los repositorios que contengan un archivo de bloqueo o manifiesto de dependencias para alguno de los administradores de paquetes compatibles. Para algunos administradores de paquetes, también puedes configurar la delegación a proveedores para las dependencias. Para obtener más información, vea [`vendor`](/es/code-security/dependabot/working-with-dependabot/dependabot-options-reference#vendor--).\nDependabot también admite dependencias en registros privados. Para más información, consulta [Configuración del acceso a registros privados para Dependabot](/es/code-security/dependabot/working-with-dependabot/configuring-access-to-private-registries-for-dependabot).\n\n> \\[!NOTE]\n>\n> * Cuando ejecutas actualizaciones de versión o de seguridad, algunos ecosistemas deberán poder resolver todas las dependencias de su fuente para verificar que las actualizaciones sean exitosas. Si tus archivos de manifiesto o de bloqueo contienen cualquier dependencia privada, el Dependabot deberá poder acceder a la ubicación en la que se hospedan dichas dependencias. Los propietarios de las organizaciones pueden otorgar acceso al Dependabot para los repositorios privados que contengan dependencias para un proyecto dentro de la misma organización. Para más información, consulta [Administrar la configuración de seguridad y análisis de su organización](/es/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). Puede configurar el acceso a los registros privados en el archivo de configuración `dependabot.yml` de un repositorio. Para más información, consulta [Configuración del acceso a registros privados para Dependabot](/es/code-security/dependabot/working-with-dependabot/configuring-access-to-private-registries-for-dependabot).\n> * El Dependabot no es compatible con dependencias privadas de GitHub para todos los administradores de paquetes. Consulta los detalles en la tabla a continuación.\n\nSi tu repositorio ya utiliza una integración para la administración de dependencias, necesitarás inhabilitarlo antes de habilitar el Dependabot. Para obtener más información, consulte [Acerca de las integraciones de GitHub](/es/get-started/exploring-integrations/about-integrations).\n\n\n\n| Administrador de paquetes | El valor de YAML | Versiones compatibles | Actualizaciones de versiones | Actualizaciones de seguridad | Los repositorios privados | Registros privados | Delegamiento a proveedores |\n| ------------------------- | ---------------- | --------------------- | :----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------: | :---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------: | :----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------: | :---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------: | :---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------: |\n| | | | | | | | |\n| Bazel | `bazel` | v7, v8, v9 | | | | | |\n| | | | | | | | |\n| | | | | | | | |\n\n```\n [Bun](#bun) | `bun` | >=v1.1.39 | | | | | |\n```\n\n\\| |\nBundler | `bundler` |\nv2 | | | | | |\n\n```\n [Cargo](#cargo) | `cargo` | v1 | | | | | |\n```\n\nComposer | `composer` |\nv2 | | | | | |\n\\| |\n\n```\n [Conda](#conda) | `conda` | No aplicable | | | | | |\n```\n\n\\| |\n\n```\n [Contenedores de desarrollo](#dev-containers) | `devcontainers` | No aplicable | | | | | |\n\n [Docker](#docker) | `docker` | v1 | | | | | No aplicable |\n```\n\n\\| |\n\n```\n [Docker Compose](#docker-compose) | `docker-compose` | v2, v3 | | | | | No aplicable |\n```\n\n\\| |\n\\| |\nSDK de .NET | `dotnet-sdk` | >=.NET Core 3.1 | | | No aplicable | No aplicable | No aplicable |\n\\| |\n\n```\n [Gráficos de Helm](#helm-charts) | `helm` | \n v3 | | | | | No aplicable |\n```\n\nHexadecimal | `mix` | v1 | | | | | |\n\\| |\n\n```\n [Julia](#julia) | `julia` | >=v1.10 | | | | | |\n```\n\n\\| |\nelm-package | `elm` | v0.19 | | | | | |\nsubmódulo de git | `gitsubmodule` | No aplicable | | | | | No aplicable |\n[GitHub Actions](#github-actions) | `github-actions` | No aplicable | | | | | No aplicable |\nMódulos de Go | `gomod` | v1 | | | | | |\n\n```\n [Gradle](#gradle) | `gradle` | No aplicable | | | | | |\n\n [Maven](#maven) | `maven` | No aplicable | | | | | |\n```\n\n\\| |\n\n```\n [Nix](#nix) | `nix` | No aplicable | | | | No aplicable | No aplicable |\n```\n\n\\| |\nnpm | `npm` | v7, v8, v9, v10, v11 | | | | | |\n\n```\n [NuGet](#nuget-cli) | `nuget` | \n <=6.12.0 | | | | | |\n```\n\n\\| |\n\n```\n [OpenTofu](#opentofu) | `opentofu` | No aplicable | | | | | No aplicable |\n```\n\n\\| |\n\n```\n [pip](#pip-and-pip-compile) | `pip` | 24,2 | | | | | |\n```\n\npipenv | `pip` | 2024.4.1 | | | | | |\n\n```\n [pip-compile](#pip-and-pip-compile) | `pip` | 7.5.3 | | | | | |\n```\n\n\\| pnpm | `npm` | v7, v8, v9, v10 | | \n\n```\n | | | |\n\n [poesía](#poetry) | `pip` | v2 | | | | | |\n```\n\n\\| |\n\n```\n [confirmación previa](#pre-commit) | `pre-commit` | No aplicable | | | | | |\n```\n\n\\| |\n\n```\n [pub](#pub) | `pub` | v2 | | | | | |\n```\n\n\\| |\n\n```\n [Cadena de herramientas de Rust](#rust-toolchain) | `rust-toolchain` | No aplicable | | | | No aplicable | No aplicable |\n```\n\n\\| |\n\n```\n [Swift](#swift) | `swift` | v5 | | | | \n (solo git) | |\n\n [Terraform](#terraform) | `terraform` | >= 0,13, <= 1.13.x | | | | | No aplicable |\n```\n\n\\| |\nuv | `uv` | v0 | | | | | No aplicable |\n\\| |\n\\| |\n\n```\n [vcpkg](#vcpkg) | `vcpkg` | No aplicable | | | | | No aplicable |\n```\n\n\\| |\n\n```\n [yarn](#yarn) | `npm` | v1, v2, v3, v4 | | | | | |\n```\n\n> \\[!TIP]\n> Para los administradores de paquetes tales como `pipenv` y `poetry`, necesita utilizar el valor `pip` de YAML. Por ejemplo, si usa `poetry` para administrar las dependencias de Python y desea que Dependabot supervise el archivo de manifiesto de dependencias para las nuevas versiones, use `package-ecosystem: \"pip\"` en su archivo `dependabot.yml`.\n\nPara obtener más información sobre la compatibilidad del ecosistema con Dependabot security updates, consulte también [Ecosistemas de paquetes que soportan el gráfico de dependencias](/es/code-security/supply-chain-security/understanding-your-software-supply-chain/dependency-graph-supported-package-ecosystems).\n\n### Bun\n\n```\n Dependabot admite el archivo basado en `bun.lock` texto predeterminado actual, pero no el archivo binario `bun.lockb` heredado. El archivo `bun.lock` se admite en la versión 1.1.39 y posteriores. Para obtener más información, consulte [Lockfile](https://bun.sh/docs/install/lockfile) en la documentación de Bun.\n```\n\n### Cargo\n\nEl soporte de registro privado incluye registros de cargo, por lo que puede usar Dependabot para mantener las dependencias de Rust actualizadas. Para más información, consulta [Guía para la configuración de registros privados para Dependabot](/es/code-security/dependabot/working-with-dependabot/guidance-for-the-configuration-of-private-registries-for-dependabot#cargo).\n\n### Conda\n\n```\n Dependabot La compatibilidad con Conda **no incluye registros privados, proveedores ni actualizaciones de archivos de bloqueo**.\n```\n\n### Contenedores de desarrollo\n\nPuedes usar `devcontainers` como `package-ecosystem` en el archivo `dependabot.yml` para actualizar características en los archivos de configuración de `devcontainer.json`. Para obtener más información sobre esta compatibilidad y ejemplos de archivos de configuración, vea [Disponibilidad general de Dependabot la integración](https://containers.dev/guide/dependabot) en la documentación de contenedores de desarrollo.\n\nLos contenedores de desarrollo se usan en varias herramientas y servicios, como Codespaces. Para obtener más información sobre las características y los servicios compatibles, consulta [Características](https://containers.dev/implementors/features/) y [Compatibilidad de herramientas y servicios](https://containers.dev/supporting) en la documentación de contenedores de desarrollo, respectivamente.\n\nEste actualizador garantiza que las características se anclan a la versión `major` más reciente del archivo `devcontainer.json` asociado. Si un contenedor de desarrollo tiene un archivo de bloqueo, ese archivo también se actualizará. Para obtener más información sobre las especificaciones del archivo de bloqueo, consulta [Archivos de bloqueo](https://github.com/devcontainers/spec/blob/main/docs/specs/devcontainer-lockfile.md) en el repositorio `devcontainers/spec`.\n\nLas características de cualquier ubicación de contenedor de desarrollo válida se actualizarán en una única solicitud de cambios. Para más información sobre la especificación del contenedor de desarrollo, consulta [Especificación](https://containers.dev/implementors/spec/#devcontainerjson) en la documentación sobre contenedores de desarrollo.\n\n### Docker\n\n```\n Dependabot puede agregar metadatos de imágenes de Docker a solicitudes de incorporación de cambios para las actualizaciones de versiones. Los metadatos incluyen notas de la versión, registros de cambios y el historial de confirmaciones. Los administradores del repositorio pueden usar los metadatos para evaluar rápidamente el riesgo de estabilidad de la actualización de dependencias.\n```\n\nPara capturar Dependabot metadatos de Docker, los mantenedores de imágenes de Docker deben agregar la `org.opencontainers.image.source` etiqueta a su Dockerfile e incluir la dirección URL del repositorio de origen. Además, los mantenedores deben etiquetar el repositorio con las mismas etiquetas que las imágenes de Docker publicadas. Para ver un ejemplo, consulte el repositorio [`dependabot-fixtures/docker-with-source`](https://github.com/dependabot-fixtures/docker-with-source). Para más información sobre las etiquetas de Docker, consulta [Etiquetas de imagen de extensión](https://docs.docker.com/desktop/extensions-sdk/extensions/labels/) y [BUILDX\\_GIT\\_LABELS](https://docs.docker.com/build/building/env-vars/#buildx_git_labels) en la documentación de Docker.\n\n```\n Dependabot puede actualizar etiquetas de imagen de Docker en manifiestos de Kubernetes. Agrega una entrada al elemento `package-ecosystem` de Docker del archivo `dependabot.yml` para cada directorio que contenga un manifiesto de Kubernetes que haga referencia a etiquetas de imagen de Docker. Los manifiestos de Kubernetes pueden ser archivos YAML de implementación de Kubernetes o gráficos de Helm. Para obtener información sobre cómo configurar el archivo `dependabot.yml` para `docker`, consulta \"`package-ecosystem`\" en [AUTOTITLE](/code-security/dependabot/working-with-dependabot/dependabot-options-reference#package-ecosystem-).\n\n Dependabot admite registros de Docker públicos y privados. Para ver una lista de los registros admitidos, consulte `docker-registry` en [AUTOTITLE](/code-security/dependabot/working-with-dependabot/configuring-access-to-private-registries-for-dependabot#docker-registry).\n\n Dependabot analiza las etiquetas de imagen de Docker para el control de versiones semánticos ([SemVer](https://semver.org/)). Si Dependabot detecta una etiqueta con una versión preliminar, solo sugerirá una actualización a la versión más reciente con una versión preliminar coincidente y no sugerirá una versión más reciente que use una etiqueta de versión preliminar diferente. Para obtener más información, consulte el archivo `dependabot-docker`[README.md](https://github.com/dependabot/dependabot-core/blob/main/docker/README.md) en el repositorio de `dependabot/dependabot-core`.\n```\n\n### Docker Compose\n\n```\n Dependabot admite Docker Compose de forma similar a Docker. Para obtener más información, consulta [Docker](#docker).\n```\n\n### GitHub Actions\n\n```\n Dependabot admite las actualizaciones de versión para GitHub Actions con las advertencias siguientes.\n```\n\n* Dependabot solo admite actualizaciones de GitHub Actions mediante la sintaxis del repositorio GitHub, como `actions/checkout@v6` o `actions/checkout@`. Dependabot omitirá las acciones o los flujos de trabajo reutilizables a los que se hace referencia localmente (por ejemplo, `./.github/actions/foo.yml`).\n* Dependabot actualiza la documentación de la versión de GitHub Actions cuando el comentario está en la misma línea, como `actions/checkout@ #` o `actions/checkout@ #`.\n* Si el commit que utilizas no está asociado a ninguna etiqueta, Dependabot actualizará GitHub Actions al commit más reciente (que puede diferir de la versión más reciente).\n* Actualmente no se admiten Docker Hub y direcciones URL del GitHub Packages de Container registry. Por ejemplo, no se admiten referencias a acciones de contenedor de Docker mediante la sintaxis `docker://`.\n* Dependabot admite repositorios públicos y privados para GitHub Actions. Para obtener las opciones de configuración del registro privado, consulta \"`git`\" en [Referencia de opciones de Dependabot](/es/code-security/dependabot/dependabot-version-updates/configuration-options-for-the-dependabot.yml-file#git).\n\nPara obtener más información sobre el uso Dependabot version updates con GitHub Actions, vea [Referencia de uso seguro](/es/actions/security-guides/using-githubs-security-features-to-secure-your-use-of-github-actions#keeping-the-actions-in-your-workflows-secure-and-up-to-date).\n\n### Gradle\n\n```\n Dependabot admite actualizaciones de los siguientes archivos sin necesidad de ejecutar Gradle:\n```\n\n* `build.gradle`, `build.gradle.kts` (para proyectos de Kotlin)\n* `gradle/libs.versions.toml` (para proyectos que usan un catálogo de versiones estándar de Gradle)\n* `gradle.lockfile` (para proyectos que usan el bloqueo de dependencias de Gradle)\n* Archivos incluidos a través de la `apply` declaración que tienen `dependencies` en el nombre de archivo. Ten en cuenta que `apply` no es compatible con `apply to`, con la recursión o con las sintaxis avanzadas (por ejemplo, el `apply` de Kotlin con `mapOf`, que son nombres de archivo que se definen por propiedad).\n\nPara actualizar el contenedor de Gradle, Dependabot ejecuta Gradle y actualiza:\n\n* `gradle/wrapper/gradle-wrapper.properties`\n* `gradlew`\n* `gradlew.bat`\n* `gradle/wrapper/gradle-wrapper.jar`\n\n ```\n Dependabot usa información del archivo de dependencias `pom.xml` para agregar vínculos a la información de lanzamiento en las solicitudes de incorporación de cambios para actualizaciones. Si se omite la información del archivo `pom.xml`, no se puede incluir en solicitudes de extracción Dependabot, consulte [AUTOTITLE](/code-security/dependabot/ecosystems-supported-by-dependabot/optimizing-java-packages-dependabot).\n ```\n\nPara Dependabot security updates, la compatibilidad con Gradle se limita a las cargas manuales de los datos del grafo de dependencia mediante el uso del API de envío de dependencias. Para obtener más información sobre API de envío de dependencias, consulta [Uso de la Dependency submission API](/es/code-security/supply-chain-security/understanding-your-software-supply-chain/using-the-dependency-submission-api).\n\n> \\[!NOTE]\n>\n> * Al cargar dependencias de Gradle en el gráfico de dependencias mediante API de envío de dependencias, todas las dependencias del proyecto se cargan, incluso las dependencias transitivas que no se mencionan explícitamente en ningún archivo de dependencia. Cuando se detecta una alerta en una dependencia transitiva, Dependabot no puede encontrar la dependencia vulnerable en el repositorio y, por tanto, no creará una actualización de seguridad para esa alerta.\n> *\n\n```\n Dependabot version updates sin embargo, creará pull requests cuando la dependencia primaria se declare explícitamente como una dependencia directa en el archivo de manifiesto del proyecto.\n```\n\n### Gráficos de Helm\n\n```\n Dependabot admite el uso de un nombre de usuario y una contraseña para los registros. Para más información, consulta [AUTOTITLE](/code-security/dependabot/working-with-dependabot/configuring-access-to-private-registries-for-dependabot#helm-registry).\n```\n\nEl `helm-registry` tipo solo admite la autenticación básica http y no admite registros compatibles con OCI. Si necesita acceder a un registro compatible con OCI para los diagramas de Helm, configure `docker-registry` en su lugar. Para más información, consulta [Configuración del acceso a registros privados para Dependabot](/es/code-security/dependabot/working-with-dependabot/configuring-access-to-private-registries-for-dependabot#docker-registry).\n\nAl configurar Dependabot para gráficos de Helm, también actualizará automáticamente las imágenes de Docker a las que se hace referencia dentro de esos gráficos, lo que garantiza que las versiones del gráfico y sus imágenes contenidas permanezcan actualizadas.\n\n### Maven\n\n```\n Dependabot no ejecuta Maven, pero admite actualizaciones de `pom.xml` archivos.\n\n Dependabot usa información del archivo de dependencias `pom.xml` para agregar vínculos a la información de lanzamiento en las solicitudes de incorporación de cambios para actualizaciones. Si se omite la información del archivo `pom.xml`, no se puede incluir en solicitudes de extracción Dependabot, consulte [AUTOTITLE](/code-security/dependabot/ecosystems-supported-by-dependabot/optimizing-java-packages-dependabot).\n```\n\n### Nix\n\n```\n Dependabot supervisa el `flake.lock` archivo y abre solicitudes de incorporación de cambios cuando las confirmaciones más recientes están disponibles en sentido ascendente para las entradas de flake. \n GitHubSe admiten todas las entradas de GitLab, SourceHut y Git sin formato. No se admite la actualización de referencias ancladas en `flake.nix` en sí mismo (por ejemplo, cambiar `github:cachix/devenv/v0.5` a una etiqueta más reciente).\n\n Dependabot actualmente no admite repositorios privados para el `nix` ecosistema.\n```\n\n### CLI de NuGet\n\n```\n Dependabot no ejecuta la CLI de NuGet, pero admite la mayoría de las características hasta la versión 6.8.0.\n```\n\n### pip y pip-compile\n\n```\n Dependabot admite actualizaciones en cualquier `.txt` archivo.\n```\n\nAdemás, Dependabot admite actualizaciones de `pyproject.toml` archivos si siguen el estándar PEP 621.\n\n### poetry\n\n```\n Dependabot admite Poesía v2.\n```\n\n### pre-commit\n\n```\n Dependabot puede actualizar revisiones de ganchos en archivos `.pre-commit-config.yaml`. Cuando un gancho ancla un SHA de confirmación específico, Dependabot resuelve la etiqueta coincidente más reciente y actualiza el valor de `rev` en consecuencia.\n```\n\nPuede usar un comentario `# frozen:` después del valor `rev` para anclar un hook a una versión específica o prefijo de versión.\nDependabot usa este comentario para determinar si se necesita una actualización y qué etiqueta resolver.\n\n| Escenario | Comportamiento |\n| ------------------------------------------------------------------------ | ---------------------------------------------------------------------------------------------------- |\n| `rev: # frozen: 7.3.0` y 7.3.0 es la versión más reciente | Sin actualización. La dependencia ya está actualizada. |\n| `rev: # frozen: 7.3.0` y la versión 8.0.0 ha sido publicada | Se ha actualizado el SHA de la etiqueta `8.0.0`. El comentario se actualiza a `# frozen: 8.0.0`. |\n| `rev: # frozen: v1` y `v1.43.5` es la versión `v1.x` más reciente | Se ha actualizado el SHA de la etiqueta `v1.43.5`. El comentario se actualiza a `# frozen: v1.43.5`. |\n| `rev: ` sin `# frozen:` comentario | Actualizado al HEAD SHA de la rama predeterminada. |\n\nAdemás de actualizar las revisiones de enlace, Dependabot puede actualizar `additional_dependencies` para enlaces que usan los siguientes lenguajes: Python, Node, Go, Rust, Ruby y Dart.\n\nEl soporte para registros privados utiliza registros git. Puede configurar el acceso para repositorios git privados especificando un registro de git en el archivo `dependabot.yml`. Para más información, consulta [Configuración del acceso a registros privados para Dependabot](/es/code-security/dependabot/working-with-dependabot/configuring-access-to-private-registries-for-dependabot#git).\n\n> \\[!NOTE]\n> No se admiten registros privados para `additional_dependencies`.\n\n### Cadena de herramientas de Rust\n\n```\n Dependabot admite actualizaciones automáticas para las versiones de toolchain de Rust definidas en los archivos `rust-toolchain.toml` y `rust-toolchain`.\n```\n\nLos patrones de actualización admitidos Dependabot pueden actualizar:\n\n* Cadenas de herramientas con control de versiones como `channel = \"1.xx.yy\"` y `channel = \"1.xx\"`.\n* Cadenas de herramientas con fecha como `channel = \"nightly-YYYY-MM-DD\"` y `channel = \"beta-YYYY-MM-DD\"`.\n\n### Swift\n\nLa compatibilidad con el registro privado se aplica solo a los registros de Git. No se admiten los registros de Swift. No se admiten manifiestos no declarativos. Para más información sobre los manifiestos no declarativos, consulta [Edición de manifiestos no declarativos](https://github.com/apple/swift-evolution/blob/7003da1439ad60896ec14657dfce829f04b0632c/proposals/0301-package-editing-commands.md#editing-non-declarative-manifests) en la documentación de Swift Evolution.\n\n### Terraform\n\nTerraform es compatible con:\n\n* Módulos hospedados en Terraform Registry o en un repositorio Git accesible públicamente.\n* Proveedores de Terraform.\n* Registro privado de Terraform. Puede configurar el acceso para repositorios git privados especificando un registro de git en el archivo `dependabot.yml`. Para obtener más información, consulte [`git`](/es/code-security/dependabot/working-with-dependabot/configuring-access-to-private-registries-for-dependabot#git).\n\n### vcpkg\n\nLa compatibilidad con vcpkg incluye la actualización del SHA de confirmación de `builtin-baseline` desde el repositorio de puertos vcpkg en el archivo de manifiesto de `vcpkg.json`. Para obtener más información, visite el repositorio [`microsoft/vcpkg`](https://github.com/microsoft/vcpkg) en GitHub.com y vea [ ¿Qué es el modo de manifiesto?](https://learn.microsoft.com/vcpkg/concepts/manifest-mode) en la documentación de Microsoft.\n\n### Yarn\n\nDependabot admite dependencias proporcionadas por el proveedor a partir de la versión 2.\n\n## Ecosistemas mantenidos por la comunidad y respaldados\n\n```\n Sus mantenedores comunitarios ascendentes mantienen los siguientes ecosistemas. GitHub integra Dependabot con estos ecosistemas sin mantenerlos directamente.\n \n \n```\n\n* [Julia](#julia) - Mantenida por la comunidad de Julia\n* [OpenTofu](#opentofu) : mantenido por la comunidad de OpenTofu\n* [Pub](#pub) - Mantenido por The Dart Community\n\n### Julia\n\n```\n Dependabot admite proyectos de Julia que incluyen archivos `Project.toml`/`Manifest.toml`. \n Dependabot usa el administrador de paquetes de Julia para resolver y actualizar las dependencias.\n```\n\n### OpenTofu\n\n```\n Dependabot admite la actualización de módulos y proveedores de OpenTofu en archivos de configuración `.tf` y `.tofu`, incluidos `terragrunt.hcl` archivos. Si el `.terraform.lock.hcl` archivo de bloqueo para las sumas de comprobación del proveedor está presente, Dependabot también lo actualizará.\n```\n\n### Pub\n\n```\n Dependabot no realizará una actualización para `pub` cuando se omita la versión a la que intenta actualizar, incluso si hay disponible una versión anterior.\n```\n\nSi usa repositorios de pub privados hospedados, puede usar Dependabot para mantener las dependencias de Dart actualizadas. Para obtener información sobre cómo permitir Dependabot el acceso a dependencias privadas GitHub , consulte [Permitir Dependabot el acceso a dependencias privadas](/es/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)."}