Otimizando a criação de pull requests para atualizações de versão do Dependabot

Saiba como simplificar e gerenciar com eficiência pull requests de Dependabot.

Quem pode usar esse recurso?

Users with write access

Neste artigo

Por padrão, Dependabot abre uma nova pull request para atualizar cada dependência. Quando você habilita atualizações de segurança, novas pull requests são abertas quando uma dependência vulnerável é encontrada. Quando você configura atualizações de versão para um ou mais ecossistemas, novas pull requests são abertas quando novas versões de dependências estão disponíveis, com a frequência definida no arquivo dependabot.yml.

Se o projeto tiver muitas dependências, você poderá descobrir que tem um número muito grande de pull requests de Dependabot para revisão e mesclagem, o que pode, rapidamente, se tornar difícil de gerenciar.

Há algumas opções de personalização que você pode implementar para otimizar pull requests de atualização de Dependabot para se alinharem com seus processos, como: * Controlar a frequência com que Dependabot verifica se há versões mais recentes de suas dependências com schedule. * Priorizar atualizações significativas com groups.

Controlar a frequência e os intervalos das atualizações de dependência

O Dependabot executa suas verificações de atualizações de versão em uma frequência definida por você no arquivo de configuração, em que o campo obrigatório, schedule.interval, precisa ser definido como daily, weekly, monthly, quarterly, semiannually, yearly ou cron (consulte cronjob).

Por padrão, Dependabot equilibra sua carga de trabalho atribuindo um tempo aleatório para verificar e gerar pull requests para atualizações de dependência.

No entanto, para reduzir a distração ou organizar melhor o tempo e os recursos para revisar e abordar atualizações de versão, você pode achar útil modificar a frequência e os intervalos. Por exemplo, você pode preferir que Dependabot seja executado semanalmente em vez de verificações diárias de atualizações e em um momento que garanta que as pull requests sejam geradas antes para a sessão de triagem da sua equipe.

Modificar a frequência e os intervalos para atualizações de dependência

Você pode usar o schedule com uma combinação de opções para modificar a frequência e os intervalos de quando o Dependabot verifica se há atualizações de versão.

O arquivo de exemplo dependabot.yml abaixo altera a configuração do NPM para especificar que o Dependabot deve verificar se há atualizações de versão para dependências do NPM todas as terças-feiras às 02:00 Horário Padrão Japonês (UTC +09:00).

YAML
# `dependabot.yml` file with
# customized schedule for version updates

version: 2
updates:
  # Keep npm dependencies up to date
  - package-ecosystem: "npm"
    directory: "/"
    # Check the npm registry every week on Tuesday at 02:00 Japan Standard Time (UTC +09:00)
    schedule:
      interval: "weekly"
      day: "tuesday"
      time: "02:00"
      timezone: "Asia/Tokyo"

Veja também agenda.

Configurar um período de resfriamento para atualizações de dependência

Você pode usar o cooldown com uma combinação de opções para controlar quando o Dependabot cria pull requests para atualizações de versão.

O arquivo de exemplo dependabot.yml a seguir mostra um período de resfriamento sendo aplicado às dependências requests, numpy e aqueles prefixados com pandas ou django, mas não à dependência chamada pandas (correspondência exata), que é excluída por meio da lista de exclusões.

YAML
version: 2
updates:
  - package-ecosystem: "pip"
    directory: "/"
    schedule:
      interval: "daily"
    cooldown:
      default-days: 5
      semver-major-days: 30
      semver-minor-days: 7
      semver-patch-days: 3
      include:
        - "requests"
        - "numpy"
        - "pandas*"
        - "django"
      exclude:
        - "pandas"
  • O número de dias de resfriamento deve estar entre 1 e 90.
  • O limite máximo de itens permitidos nas listasinclude e exclude, que podem ser usados com cooldown, é de 150 cada.

Observação

Para considerar todas as dependências para um período de resfriamento, você pode:

  • Omita a opção include que aplica o resfriamento a todas as dependências.
  • Use "*" na include para aplicar as configurações de resfriamento a tudo. Recomendamos o uso de exclude para excluir apenas****dependências específicas das configurações de resfriamento.

O SemVer é compatível com a maioria dos gerenciadores de pacotes. As atualizações para novas versões para dependências no resfriamento são adiadas da seguinte maneira:

  • Atualizações principais: atrasadas por 30 dias (semver-major-days: 30).
  • Atualizações secundárias: atrasadas por 7 dias (semver-minor-days: 7).
  • Atualizações de patch: atrasadas por 3 dias (semver-patch-days: 3).

Consulte também cooldown.

Como priorizar atualizações significativas

Você pode usar groups para consolidar atualizações para várias dependências em apenas uma pull request. Isso ajuda você a concentrar seu tempo de revisão em atualizações de maior risco e minimizar o tempo gasto revisando atualizações de versão secundárias. Por exemplo, você pode combinar atualizações para atualizações secundárias ou de patch para dependências de desenvolvimento em apenas uma pull request e ter um grupo dedicado para atualizações de segurança ou de versão que afetam uma área chave da base de código.

Você precisa configurar grupos por ecossistema de pacote individual e, em seguida, pode criar vários grupos por ecossistema de pacotes usando uma combinação de critérios:

  • Tipo de atualização do Dependabot: applies-to
  • O tipo de dependência: dependency-type.
  • Nome da dependência: patterns e exclude-patterns
  • Níveis de controle de versão semântico: update-types

Para ver todos os valores com suporte para cada critério, consulte groups.

Os exemplos abaixo apresentam vários métodos diferentes para criar grupos de dependências usando os critérios.

Exemplo 1: três grupos de atualização de versão

Neste exemplo, o arquivo dependabot.yml:

  • Cria três grupos, chamados "production-dependencies", "development-dependencies" e "rubocop".
  • Usa patterns e dependency-type para incluir dependências no grupo.
  • Usa exclude-patterns para excluir uma dependência (ou várias dependências) do grupo.
version: 2
updates:
  # Keep bundler dependencies up to date
  - package-ecosystem: "bundler"
    directory: "/"
    schedule:
      interval: "weekly"
    groups:
      production-dependencies:
        dependency-type: "production"
      development-dependencies:
        dependency-type: "development"
        exclude-patterns:
          - "rubocop*"
      rubocop:
        patterns:
          - "rubocop*"

Como resultado:

  • As atualizações de versão são agrupadas por tipo de dependência.
  • As dependências de desenvolvimento correspondentes ao padrão rubocop* são excluídas do grupo development-dependencies.
  • Em vez disso, as dependências de desenvolvimento correspondentes a rubocop* serão incluídas no grupo rubocop. Devido à ordenação, as dependências de produção que correspondem a rubocop* serão incluídas no grupo production-dependencies.
  • Além disso, todos os grupos são padrão para aplicar somente a atualizações de versão, já que a chave applies-to está ausente.

Exemplo 2: atualizações agrupadas com dependências excluídas

Neste exemplo, o arquivo dependabot.yml:

  • Cria um grupo chamado "support-dependencies" como parte de uma configuração personalizada do empacotador.
  • Usa patterns, que correspondem ao nome de uma dependência (ou várias dependências) para incluir dependências no grupo.
  • Usa exclude-patterns, que correspondem ao nome de uma dependência (ou várias dependências) para excluir dependências do grupo.
  • Aplica o agrupamento apenas a atualizações de versão, já que applies-to: version-updates é usado.
version: 2
updates:
  # Keep bundler dependencies up to date
  - package-ecosystem: "bundler"
    directories:
      - "/frontend"
      - "/backend"
      - "/admin"

    schedule:
      interval: "weekly"
    # Create a group of dependencies to be updated together in one pull request
    groups:
      # Specify a name for the group, which will be used in pull request titles
      # and branch names
      support-dependencies:
        # Define patterns to include dependencies in the group (based on
        # dependency name)
        applies-to: version-updates # Applies the group rule to version updates
        patterns:
          - "rubocop" # A single dependency name
          - "rspec*"  # A wildcard string that matches multiple dependency names
          - "*"       # A wildcard that matches all dependencies in the package
                      # ecosystem. Note: using "*" may open a large pull request
        # Define patterns to exclude dependencies from the group (based on
        # dependency name)
        exclude-patterns:
          - "gc_ruboconfig"
          - "gocardless-*"

Como resultado:

  • A maioria das dependências do empacotador são consolidadas no grupo support-dependencies devido ao padrão curinga ("*"), além de
  • As dependências que correspondem gc_ruboconfig e gocardless-* são excluídas do grupo e os dados Dependabot continuam a gerar pull requests únicas para essas dependências. Isso poderá ser útil se as atualizações dessas dependências precisarem ser revisadas com mais detalhamento.
  • Para support-dependencies, Dependabot só gerará pull requests para atualizações de versão.

Exemplo 3: pull requests individuais para atualizações principais e agrupadas para atualizações secundárias/de patch

Neste exemplo, o arquivo dependabot.yml:

  • Cria um grupo chamado "angular".
  • Usa patterns, que correspondem com o nome de uma dependência para incluir dependências no grupo.
  • Usa update-type apenas para incluir atualizações de minor ou patch no grupo.
  • Aplica o agrupamento apenas a atualizações de versão, já que applies-to: version-updates é usado.
version: 2
updates:
  - package-ecosystem: "npm"
    directory: "/"
    schedule:
      interval: "weekly"
    groups:
      # Specify a name for the group, which will be used in pull request titles
      # and branch names
      angular:
        applies-to: version-updates
        patterns:
          - "@angular*"
        update-types:
          - "minor"
          - "patch"

Como resultado:

  • Dependabot criará uma pull request agrupada para todas as dependências angulares que têm uma atualização secundária ou de patch.
  • Todas as atualizações principais continuarão a ser geradas como pull requests individuais.

Exemplo 4: pull requests agrupadas para atualizações secundárias/de patch e nenhuma pull request para atualizações principais

Neste exemplo, o arquivo dependabot.yml:

  • Cria dois grupos chamados "angular" e "minor-and-patch".
  • Usa applies-to para que o primeiro grupo se aplique somente a atualizações de versão e o segundo se aplique somente a atualizações de segurança.
  • Usa update-type apenas para incluir atualizações minor ou patch a ambos os grupos.
  • Usa uma condição ignore para excluir atualizações nas versões major de pacotes @angular*.
version: 2
updates:
  # Keep npm dependencies up to date
  - package-ecosystem: "npm"
    directory: "/"
    schedule:
      interval: "weekly"
    groups:
      angular:
        applies-to: version-updates
        patterns:
          - "@angular*"
        update-types:
          - "minor"
          - "patch"
      minor-and-patch:
        applies-to: security-updates
        patterns:
          - "@angular*"
        update-types:
          - "patch"
          - "minor"
    ignore:
      - dependency-name: "@angular*"
        update-types: ["version-update:semver-major"]

Como resultado:

  • As atualizações de versão secundária e de patch para dependências do Angular são agrupadas em apenas uma pull request.
  • Atualizações de segurança secundárias e de patch para dependências do Angular também são agrupadas em apenas uma pull request.
  • Dependabot não abrirá automaticamente pull requests para atualizações principais do Angular.

Agrupando atualizações em diretórios em um monorepo

Se você gerenciar um monorepo com vários diretórios que compartilham dependências comuns, poderá reduzir o número de solicitações de pull para atualizações de versão agrupando atualizações por nome de dependência em todos os diretórios.

Quando você configura o Dependabot para monitorar vários diretórios e habilitar o agrupamento por nome de dependência, Dependabot fará o seguinte:

  • Criar uma única solicitação de pull para cada atualização de dependência que afeta vários diretórios
  • Atualizar a mesma dependência para a mesma versão em todos os diretórios em uma operação
  • Reduza o número de solicitações de pull que você precisa revisar
  • Minimizar os custos de CI/CD executando testes uma vez em vez de por diretório

Para obter mais informações, consulte group-by.

Este exemplo de configuração agrupa atualizações por nome de dependência nos diretórios /frontend, /admin-panel e /mobile-app. Se lodash precisar ser atualizado nos três diretórios, Dependabot criará uma única solicitação pull chamada "Bump lodash no grupo monorepo-dependencies" que atualiza lodash em todos os três locais.

version: 2
updates:
  - package-ecosystem: "npm"
    directories:
      - "/frontend"
      - "/admin-panel"
      - "/mobile-app"
    schedule:
      interval: "weekly"
    groups:
      monorepo-dependencies:
        group-by: dependency-name