{"meta":{"title":"Ecossistemas e repositórios compatíveis com o Dependabot","intro":"O Dependabot é compatível com uma variedade de ecossistemas e repositórios","product":"Qualidade de segurança e código","breadcrumbs":[{"href":"/pt/code-security","title":"Qualidade de segurança e código"},{"href":"/pt/code-security/reference","title":"Referência"},{"href":"/pt/code-security/reference/supply-chain-security","title":"Segurança da cadeia de fornecedores"},{"href":"/pt/code-security/reference/supply-chain-security/supported-ecosystems-and-repositories","title":"Ecossistemas Dependabot"}],"documentType":"article"},"body":"# Ecossistemas e repositórios compatíveis com o Dependabot\n\nO Dependabot é compatível com uma variedade de ecossistemas e repositórios\n\nEste artigo fornece informações de referência sobre os ecossistemas de pacotes e os tipos de repositório que Dependabot suporta.\n\nDependabot é uma ferramenta GitHub que ajuda a manter suas dependências seguras e atualizadas. Ele detecta automaticamente dependências vulneráveis ou desatualizadas em seus repositórios e cria solicitações de pull para atualizá-las, facilitando a manutenção da segurança da cadeia de fornecimento de software. Para saber mais, confira [Guia de início rápido do Dependabot](/pt/code-security/tutorials/secure-your-dependencies/dependabot-quickstart-guide).\n\n## Ecossistemas com suporte mantidos por GitHub\n\n\n\nÉ possível configurar atualizações para repositórios que contenham um manifesto de dependência ou arquivo de bloqueio para um dos gerentes de pacotes suportados. Para alguns gerenciadores de pacotes, você também pode configurar o armazenamento para dependências. Para obter mais informações, confira [`vendor`](/pt/code-security/dependabot/working-with-dependabot/dependabot-options-reference#vendor--).\nO Dependabot dá suporte também a dependências em registros privados. Para saber mais, confira [Configurando o acesso a registros privados para Dependabot](/pt/code-security/dependabot/working-with-dependabot/configuring-access-to-private-registries-for-dependabot).\n\n> \\[!NOTE]\n>\n> * Ao executar atualizações de segurança ou versão, alguns ecossistemas devem ser capazes de resolver todas as dependências de sua fonte para verificar se as atualizações foram bem-sucedidas. Se o seu manifesto ou arquivos de bloqueio contiverem dependências privadas, Dependabot deverá ser capaz de acessar o local em que essas dependências estão hospedadas. Os proprietários da organização podem conceder a Dependabot acesso a repositórios privados que contêm dependências para um projeto dentro da mesma organização. Para saber mais, confira [Gerenciando as configurações de segurança e de análise da sua organização](/pt/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). Você pode configurar o acesso a registros privados no arquivo de configuração `dependabot.yml` de um repositório. Para saber mais, confira [Configurando o acesso a registros privados para Dependabot](/pt/code-security/dependabot/working-with-dependabot/configuring-access-to-private-registries-for-dependabot).\n> * Dependabot não é compatível com as dependências privadas de GitHub para todos os gerenciadores de pacote. Veja os detalhes na tabela abaixo.\n\nSe o seu repositório já usa uma integração para gerenciamento de dependências, você precisará desativar isso antes de habilitar o Dependabot. Para saber mais, confira [Sobre integrações de GitHub](/pt/get-started/exploring-integrations/about-integrations).\n\n\n\n| Gerenciador de Pacotes | Valor YAML | Versões com suporte | Atualizações de versão | Atualizações de segurança | Repositórios privados | Registros privados | Delegação |\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` | Não aplicável | | | | | |\n```\n\n\\| |\n\n```\n [Contêineres de desenvolvimento](#dev-containers) | `devcontainers` | Não aplicável | | | | | |\n\n [Docker](#docker) | `docker` | v1 | | | | | Não aplicável |\n```\n\n\\| |\n\n```\n [Docker Compose](#docker-compose) | `docker-compose` | v2, v3 | | | | | Não aplicável |\n```\n\n\\| |\n\\| |\nSDK do .NET | `dotnet-sdk` | >=.NET Core 3.1 | | | Não aplicável | Não aplicável | Não aplicável |\n\\| |\n\n```\n [Gráficos de Helm](#helm-charts) | `helm` | \n V3 | | | | | Não aplicável |\n```\n\nHex | `mix` | v1 | | | | | |\n\\| |\n\n```\n [Julia](#julia) | `julia` | >=v1.10 | | | | | |\n```\n\n\\| |\nelm-package | `elm` | v0.19 | | | | | |\nSubmódulo git | `gitsubmodule` | Não aplicável | | | | | Não aplicável |\n[GitHub Actions](#github-actions) | `github-actions` | Não aplicável | | | | | Não aplicável |\nMódulos Go | `gomod` | v1 | | | | | |\n\n```\n [Gradle](#gradle) | `gradle` | Não aplicável | | | | | |\n\n [Maven](#maven) | `maven` | Não aplicável | | | | | |\n```\n\n\\| |\n\n```\n [Nix](#nix) | `nix` | Não aplicável | | | | Não aplicável | Não aplicável |\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` | Não aplicável | | | | | Não aplicável |\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 [Poesia](#poetry) | `pip` | v2 | | | | | |\n```\n\n\\| |\n\n```\n [pre-commit](#pre-commit) | `pre-commit` | Não aplicável | | | | | |\n```\n\n\\| |\n\n```\n [pub](#pub) | `pub` | v2 | | | | | |\n```\n\n\\| |\n\n```\n [Cadeia de ferramentas do Rust](#rust-toolchain) | `rust-toolchain` | Não aplicável | | | | Não aplicável | Não aplicável |\n```\n\n\\| |\n\n```\n [Swift](#swift) | `swift` | V5 | | | | \n (somente Git) | |\n\n [Terraform](#terraform) | `terraform` | >= 0,13, <= 1,13.x | | | | | Não aplicável |\n```\n\n\\| |\nuv | `uv` | v0 | | | | | Não aplicável |\n\\| |\n\\| |\n\n```\n [vcpkg](#vcpkg) | `vcpkg` | Não aplicável | | | | | Não aplicável |\n```\n\n\\| |\n\n```\n [yarn](#yarn) | `npm` | v1, v2, v3, v4 | | | | | |\n```\n\n> \\[!TIP]\n> Para Gerenciadores de Pacotes como `pipenv` e `poetry`, você precisa usar o valor YAML `pip`. Por exemplo, se você usar `poetry` para gerenciar suas dependências de Python e quiser Dependabot para monitorar o arquivo de manifesto de dependências para suas novas versões, use `package-ecosystem: \"pip\"` no arquivo `dependabot.yml`.\n\nPara obter mais informações sobre o suporte ao ecossistema Dependabot security updates, consulte também [Ecossistemas de pacotes com suporte a gráficos de dependência](/pt/code-security/supply-chain-security/understanding-your-software-supply-chain/dependency-graph-supported-package-ecosystems).\n\n### Bun\n\n```\n Dependabot dá suporte ao arquivo atual baseado em `bun.lock` texto padrão, mas não ao arquivo binário herdado `bun.lockb` . Há suporte para o arquivo `bun.lock` versão 1.1.39 e superior. Para saber mais, confira [Lockfile](https://bun.sh/docs/install/lockfile) na documentação do Bun.\n```\n\n### Cargo\n\nO suporte para registro privado inclui registros de cargo, para que você possa usar Dependabot e manter suas dependências do Rust atualizadas. Para saber mais, confira [Diretrizes para a configuração de registros privados para o Dependabot](/pt/code-security/dependabot/working-with-dependabot/guidance-for-the-configuration-of-private-registries-for-dependabot#cargo).\n\n### Conda\n\n```\n Dependabot O suporte para Conda **não inclui registros privados, fornecedores ou atualizações de arquivos de bloqueio**.\n```\n\n### Contêineres de desenvolvimento\n\nVocê pode usar `devcontainers` como um `package-ecosystem` em seu arquivo `dependabot.yml` para atualizar Recursos em seus arquivos de configuração `devcontainer.json`. Para obter mais informações sobre esse suporte e para exemplos de arquivo de configuração, consulte [Disponibilidade Geral da Integração Dependabot](https://containers.dev/guide/dependabot) na documentação de contêineres de desenvolvimento.\n\nContêineres de desenvolvimento são usados em várias ferramentas e serviços, incluindo Codespaces. Para obter mais informações sobre recursos e os serviços com suporte, consulte [Recursos](https://containers.dev/implementors/features/) e [Ferramentas e serviços de suporte](https://containers.dev/supporting) na documentação de contêineres de desenvolvimento, respectivamente.\n\nEsse atualizador garante que os recursos sejam fixados à versão mais recente `major` no arquivo `devcontainer.json` associado. Se um contêiner de desenvolvimento tiver um arquivo de bloqueio, esse arquivo também será atualizado. Para obter mais informações sobre especificações de arquivo de bloqueio, consulte [Arquivos de bloqueio](https://github.com/devcontainers/spec/blob/main/docs/specs/devcontainer-lockfile.md) no repositório `devcontainers/spec`.\n\nOs recursos em qualquer local de contêiner de desenvolvimento válido serão atualizados em uma única solicitação de pull. Para obter mais informações sobre a especificação do contêiner de desenvolvimento, consulte [Especificação](https://containers.dev/implementors/spec/#devcontainerjson) na documentação de contêineres de desenvolvimento.\n\n### Docker\n\n```\n Dependabot pode adicionar metadados de imagens do Docker a solicitações de pull para atualizações de versão. Os metadados incluem notas de versão, logs de mudanças e histórico de commits. Os administradores de repositório podem usar os metadados para avaliar rapidamente o risco de estabilidade da atualização de dependência.\n\n Dependabot Para buscar metadados do Docker, os mantenedores de imagens do Docker devem adicionar o `org.opencontainers.image.source` rótulo ao Dockerfile e incluir a URL do repositório de origem. Além disso, os mantenedores precisam marcar o repositório com as mesmas tags que as imagens do Docker publicadas. Para ver um exemplo, consulte o repositório [`dependabot-fixtures/docker-with-source`](https://github.com/dependabot-fixtures/docker-with-source). Para obter mais informações sobre rótulos do Docker, confira [Rótulos de imagem de extensão](https://docs.docker.com/desktop/extensions-sdk/extensions/labels/) e [BUILDX_GIT_LABELS](https://docs.docker.com/build/building/env-vars/#buildx_git_labels) na documentação do Docker.\n\n Dependabot pode atualizar tags de imagem do Docker em manifestos do Kubernetes. Adicione uma entrada ao elemento Docker `package-ecosystem` do arquivo `dependabot.yml` para cada diretório que contém um manifesto do Kubernetes que faz referência a tags de imagem do Docker. Os manifestos do Kubernetes podem ser arquivos YAML de implantação do Kubernetes ou gráficos do Helm. Para obter informações sobre como configurar o arquivo `dependabot.yml` para `docker`, confira \"`package-ecosystem`\" em [AUTOTITLE](/code-security/dependabot/working-with-dependabot/dependabot-options-reference#package-ecosystem-).\n\n Dependabot dá suporte a registros do Docker públicos e privados. Para obter uma lista dos registros suportados, consulte \"`docker-registry`\" em [AUTOTITLE](/code-security/dependabot/working-with-dependabot/configuring-access-to-private-registries-for-dependabot#docker-registry).\n\n Dependabot analisa tags de imagem do Docker para Controle de Versão Semântico ([SemVer](https://semver.org/)). Se Dependabot detectar uma etiqueta com um pré-lançamento, ele sugerirá apenas uma atualização para a versão mais recente com um pré-lançamento correspondente e não sugerirá uma versão mais recente que use um rótulo de pré-lançamento diferente. Para obter mais informações, consulte o arquivo `dependabot-docker`[README.md](https://github.com/dependabot/dependabot-core/blob/main/docker/README.md) no repositório `dependabot/dependabot-core`.\n```\n\n### Docker Compose\n\n```\n Dependabot dá suporte ao Docker Compose de maneira semelhante ao Docker. Para saber mais, veja [Docker](#docker).\n```\n\n### GitHub Actions\n\n```\n Dependabot dá suporte a atualizações de versão para GitHub Actions com as seguintes limitações.\n```\n\n* Dependabot apenas suporta atualizações para GitHub Actions usando a sintaxe de repositório do GitHub, como `actions/checkout@v6` ou `actions/checkout@`. O Dependabot ignorará ações ou fluxos de trabalho reutilizáveis referenciados localmente (por exemplo, `./.github/actions/foo.yml`).\n* Dependabot atualiza a documentação de versão do GitHub Actions quando o comentário está na mesma linha, como `actions/checkout@ #` ou `actions/checkout@ #`.\n* Se a confirmação que você usa não estiver associado a nenhuma tag, Dependabot atualizará o GitHub Actions para a confirmação mais recente (que pode ser diferente do lançamento mais recente).\n* Não há suporte atualmente para URLs GitHub Packages do Docker Hub e do Container registry. Por exemplo, não há suporte para referências a ações de contêiner do Docker usando a sintaxe `docker://`.\n* Dependabot suporta repositórios públicos e privados para GitHub Actions. Para opções de configuração de registro privado, consulte `git` em [Referência de opções do Dependabot](/pt/code-security/dependabot/dependabot-version-updates/configuration-options-for-the-dependabot.yml-file#git).\n\nPara obter mais informações sobre como usar Dependabot version updates com GitHub Actions, consulte [Referência de uso seguro](/pt/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 dá suporte a atualizações para os seguintes arquivos sem a necessidade de executar o Gradle:\n```\n\n* `build.gradle`, `build.gradle.kts` (para projetos Kotlin)\n* `gradle/libs.versions.toml` (para projetos que utilizam um catálogo de versões Gradle padrão)\n* `gradle.lockfile` (para projetos que usam o bloqueio de dependência do Gradle)\n* Arquivos incluídos por meio da declaração `apply` que tenham `dependencies` no nome do arquivo. Observe que `apply` não dá suporte a `apply to`, recursão ou sintaxes avançadas (por exemplo, `apply` do Kotlin com `mapOf` e nomes de arquivo definidos por propriedade).\n\nPara atualizar o Wrapper do Gradle, Dependabot execute o Gradle e atualize:\n\n* `gradle/wrapper/gradle-wrapper.properties`\n* `gradlew`\n* `gradlew.bat`\n* `gradle/wrapper/gradle-wrapper.jar`\n\n ```\n Dependabot usa informações do `pom.xml` arquivo de dependências para adicionar links às informações de versão em solicitações de pull de atualização. Se as informações forem omitidas do `pom.xml` arquivo, elas não poderão ser incluídas em Dependabot solicitações de pull, consulte [AUTOTITLE](/code-security/dependabot/ecosystems-supported-by-dependabot/optimizing-java-packages-dependabot).\n ```\n\nPara Dependabot security updates, o suporte ao Gradle é limitado a uploads manuais dos dados do grafo de dependência usando o API de envio de dependência. Para obter mais informações sobre API de envio de dependência, confira [Usar a API de envio de dependências](/pt/code-security/supply-chain-security/understanding-your-software-supply-chain/using-the-dependency-submission-api).\n\n> \\[!NOTE]\n>\n> * Quando você carrega as dependências do Gradle no grafo de dependências usando o API de envio de dependência, todas as dependências do projeto são carregadas, inclusive as dependências transitivas que não são explicitamente mencionadas em arquivos de dependência. Quando um alerta é detectado em uma dependência transitiva, Dependabot não é capaz de encontrar a dependência vulnerável no repositório e, portanto, não criará uma atualização de segurança para esse alerta.\n> *\n\n```\n Dependabot version updates no entanto, criará solicitações de pull quando a dependência pai for declarada explicitamente como uma dependência direta no arquivo de manifesto do projeto.\n```\n\n### Gráficos Helm\n\n```\n Dependabot dá suporte ao uso de um nome de usuário e senha para registros. Para saber mais, confira [AUTOTITLE](/code-security/dependabot/working-with-dependabot/configuring-access-to-private-registries-for-dependabot#helm-registry).\n```\n\nO `helm-registry` tipo dá suporte apenas à Autenticação Básica HTTP e não dá suporte a registros compatíveis com OCI. Se você precisar acessar um registro compatível com OCI para gráficos do Helm, configure um `docker-registry` em vez disso. Para saber mais, confira [Configurando o acesso a registros privados para Dependabot](/pt/code-security/dependabot/working-with-dependabot/configuring-access-to-private-registries-for-dependabot#docker-registry).\n\nAo configurar Dependabot para gráficos do Helm, ele também atualizará automaticamente as imagens do Docker referenciadas nesses gráficos, garantindo que as versões do gráfico e suas imagens contidas permaneçam atualizadas.\n\n### Maven\n\n```\n Dependabot não executa o Maven, mas dá suporte a atualizações em `pom.xml` arquivos.\n\n Dependabot usa informações do `pom.xml` arquivo de dependências para adicionar links às informações de versão em solicitações de pull de atualização. Se as informações forem omitidas do `pom.xml` arquivo, elas não poderão ser incluídas em Dependabot solicitações de pull, consulte [AUTOTITLE](/code-security/dependabot/ecosystems-supported-by-dependabot/optimizing-java-packages-dependabot).\n```\n\n### Nix\n\n```\n Dependabot monitora seu `flake.lock` arquivo e abre solicitações de pull quando confirmações mais recentes estão disponíveis upstream para suas entradas de floco. \n GitHubHá suporte para entradas GitLab, SourceHut e Git simples. Não há suporte para atualizar refs fixados dentro de `flake.nix` (por exemplo, alterando `github:cachix/devenv/v0.5` para uma tag mais recente).\n\n Dependabot atualmente, não dá suporte a repositórios privados para o `nix` ecossistema.\n```\n\n### CLI do NuGet\n\n```\n Dependabot não executa a CLI do NuGet, mas dá suporte à maioria dos recursos até a versão 6.8.0.\n```\n\n### pip e pip-compile\n\n```\n Dependabot dá suporte a atualizações para qualquer `.txt` arquivo.\n```\n\nAlém disso, Dependabot dá suporte a atualizações nos `pyproject.toml` arquivos se eles seguirem o padrão PEP 621.\n\n### poetry\n\n```\n Dependabot dá suporte à Poesia v2.\n```\n\n### pre-commit\n\n```\n Dependabot pode atualizar revisões de hooks nos arquivos `.pre-commit-config.yaml`. Quando um gancho fixa um commit SHA específico, Dependabot resolve a tag correspondente mais recente e atualiza o valor `rev` adequadamente.\n```\n\nVocê pode usar um `# frozen:` comentário após o `rev` valor para fixar um gancho em uma versão específica ou prefixo de versão.\nDependabot usa este comentário para determinar se é necessária uma atualização e qual tag resolver.\n\n| Scenario | Comportamento |\n| ----------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------ |\n| `rev: # frozen: 7.3.0` e 7.3.0 é a versão mais recente | Nenhuma atualização. A dependência já está atual. |\n| `rev: # frozen: 7.3.0` e 8.0.0 foi lançado | Atualizado para o SHA da marcação `8.0.0`. O comentário é atualizado para `# frozen: 8.0.0`. |\n| `rev: # frozen: v1` e `v1.43.5` são a versão mais `v1.x` recente | Atualizado para o SHA da marcação `v1.43.5`. O comentário é atualizado para `# frozen: v1.43.5`. |\n| `rev: ` sem `# frozen:` comentários | Atualizado para o HEAD SHA do branch padrão. |\n\nAlém de atualizar revisões de gancho, Dependabot pode atualizar `additional_dependencies` para ganchos que utilizam as seguintes linguagens: Python, Node.js, Go, Rust, Ruby e Dart.\n\nO suporte ao Registro Privado usa registros git. Você pode configurar o acesso para repositórios git privados especificando um registro git em seu arquivo `dependabot.yml`. Para saber mais, confira [Configurando o acesso a registros privados para Dependabot](/pt/code-security/dependabot/working-with-dependabot/configuring-access-to-private-registries-for-dependabot#git).\n\n> \\[!NOTE]\n> Não há suporte para registros privados para `additional_dependencies`.\n\n### Cadeia de ferramentas do Rust\n\n```\n Dependabot dá suporte a atualizações automáticas para versões de ferramentas do Rust definidas em `rust-toolchain.toml` e `rust-toolchain` arquivos.\n```\n\nOs padrões Dependabot de atualização com suporte podem atualizar:\n\n* Cadeias de ferramentas com controle de versão, como `channel = \"1.xx.yy\"` e `channel = \"1.xx\"`.\n* Cadeias de ferramentas datadas, como `channel = \"nightly-YYYY-MM-DD\"` e `channel = \"beta-YYYY-MM-DD\"`.\n\n### Swift\n\nO suporte de registro particular se aplica somente a registros do Git. Não há suporte para registros do Swift. Não há suporte para manifestos não declarativos. Para obter mais informações sobre manifestos não declarativos, confira [Editando manifestos não declarativos](https://github.com/apple/swift-evolution/blob/7003da1439ad60896ec14657dfce829f04b0632c/proposals/0301-package-editing-commands.md#editing-non-declarative-manifests) na documentação do Swift Evolution.\n\n### Terraform\n\nO suporte Terraform inclui:\n\n* Módulos hospedados no registro Terraform ou em um repositório Git acessível publicamente.\n* Provedores Terraform.\n* Registro Privado Terraform. Você pode configurar o acesso para repositórios git privados especificando um registro git em seu arquivo `dependabot.yml`. Para obter mais informações, consulte [`git`](/pt/code-security/dependabot/working-with-dependabot/configuring-access-to-private-registries-for-dependabot#git).\n\n### vcpkg\n\nO suporte ao vcpkg inclui a atualização do SHA de commit `builtin-baseline` do repositório das portas do vcpkg no arquivo de manifesto `vcpkg.json`. Para obter mais informações, visite o [`microsoft/vcpkg` repositório](https://github.com/microsoft/vcpkg) em GitHub.com e consulte [O que é o modo de manifesto?](https://learn.microsoft.com/vcpkg/concepts/manifest-mode) na documentação da Microsoft.\n\n### yarn\n\nO Dependabot dá suporte a dependências de fornecedores da v2 em diante.\n\n## Ecossistemas com suporte da comunidade\n\n```\n Os ecossistemas a seguir são mantidos por seus mantenedores de comunidade de origem. GitHub integra Dependabot com esses ecossistemas, mas não os mantém diretamente.\n \n \n```\n\n* [Julia](#julia) - Mantida pela comunidade julia\n* [OpenTofu](#opentofu) – Mantido pela comunidade OpenTofu\n* [Pub](#pub) - Mantido pela Comunidade do Dardo\n\n### Julia\n\n```\n Dependabot dá suporte a projetos julia que incluem arquivos `Project.toml`/`Manifest.toml`. \n Dependabot usa o gerenciador de pacotes da Julia para resolver e atualizar dependências.\n```\n\n### OpenTofu\n\n```\n Dependabot dá suporte à atualização de módulos e provedores OpenTofu em arquivos de configuração `.tf` e `.tofu`, incluindo arquivos `terragrunt.hcl`. Se o `.terraform.lock.hcl` arquivo de bloqueio ('lockfile') para somas de verificação do provedor estiver presente, Dependabot também o atualizará.\n```\n\n### Pub\n\n```\n Dependabot não executará uma atualização para `pub` quando a versão para a qual ela tenta atualizar for ignorada, mesmo se uma versão anterior estiver disponível.\n```\n\nVocê pode usar Dependabot para manter as dependências do Dart atualizadas se você estiver usando repositórios de pub hospedados privadamente. Para obter informações sobre como permitir Dependabot o acesso a dependências privadas GitHub , consulte [Permitir Dependabot o acesso a dependências privadas](/pt/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)."}