Todo projeto de software enfrenta o desafio inevitável de gerenciar suas dependências. Com o tempo, essas dependências podem se tornar obsoletas, abrindo brechas de segurança. Outras vezes, tornam-se desnecessárias, inchando os tempos de construção do projeto. Para muitas equipes de desenvolvimento, resolver esses problemas significa executar scripts manuais, revisar arquivos de saída e torcer para que nada passe despercebido.
Recentemente, transformei esse processo manual, propenso a erros, em uma solução automatizada utilizando algumas ferramentas do GitHub: GitHub Copilot, GitHub Actions e Dependabot. Veja como você também pode simplificar a auditoria de dependências com GitHub Copilot.
Então, vamos nessa!
O Problema das Auditorias Manuais de Dependência
A maioria das equipes começa com uma abordagem simples para o gerenciamento de dependências, que geralmente inclui um script Bash executado periodicamente. Nosso script manual era assim:
#!/bin/bash
echo "Starting manual dependency audit..."
# List all dependencies
echo "Installed dependencies:"
npm list --depth=0 > deps.txt
cat deps.txt
# Check for outdated ones
echo -e "\nChecking outdated dependencies..."
npm outdated > outdated.txt
cat outdated.txt
# Guess at unused ones (very crude)
echo -e "\nLooking for potentially unused dependencies..."
for dep in $(npm list --depth=0 | grep '├──' | cut -d' ' -f2 | cut -d@ -f1); do
if ! find . -type f -name "*.js" -o -name "*.tsx" -o -name "*.ts" | xargs grep -l "$dep" > /dev/null 2>&1; then
echo "$dep might be unused"
fi
done
echo "Done! Check deps.txt and outdated.txt manually. Phew that was a lot of work!"
Essa abordagem tem várias limitações:
- É manual, então alguém tem que lembrar de executá-lo (e, sejamos honestos, eu frequentemente esqueço de fazer isso nos meus próprios projetos).
- A verificação de dependências não utilizadas é muito básica e, muitas vezes, imprecisa.
- Os resultados ficam espalhados por vários arquivos de saída.
- Não é integrado com fluxos de trabalho ou pipelines de CI/CD.
Tem que haver um jeito melhor do que esse, certo?
Simplificando a Auditoria de dependências com GitHub Copilot
Felizmente, existe uma solução melhor do que scripts Bash manuais se você estiver trabalhando no GitHub. Ela começa com a combinação da nossa ferramenta de IA para desenvolvedores, o GitHub Copilot, com nossa ferramenta de automação e CI/CD, o GitHub Actions, e o Dependabot, nossa ferramenta automatizada de dependência.
Aqui está um guia passo a passo para você usar:
Passo 1: Usando o GitHub Copilot para criar a Action
O Agent mode leva o GitHub Copilot de sugerir código a assumir tarefas, como transformar nosso script bash em um fluxo de trabalho do GitHub Actions.
Aqui está nosso prompt:
“Crie uma GitHub Action para auditoria de dependências com depcheck e publicação de issues. E um fluxo de trabalho Dependabot separado para gerenciar dependências desatualizadas.”
Lembra do nosso script bash original? Com apenas um prompt, compartilhei o contexto (package.json e nosso script manual) e pedi para ele criar uma action que usa a ferramenta de verificação de dependência depcheck para uma detecção mais precisa de dependências não utilizadas.
Passo 2: GitHub Copilot escreve a GitHub Action
Para implementar esta GitHub Action, o GitHub Copilot cria o novo arquivo de fluxo de trabalho em .github/workflows/dependency-audit.yml. Aqui está o arquivo de fluxo de trabalho que o Copilot ajudou a criar:
name: Dependency Audit
on:
schedule:
- cron: '0 0 * * 1' # Run weekly on Mondays
workflow_dispatch: # Allow manual triggering
jobs:
audit:
runs-on: ubuntu-latest
steps:
- uses: actions/checkout@v4
- name: Set up Node.js
uses: actions/setup-node@v4
with:
node-version: '18'
- name: Install dependencies
run: npm ci
- name: Install depcheck
run: npm install -g depcheck
- name: Run depcheck for unused dependencies
run: depcheck --json > unused-deps.json
- name: Run npm audit
run: npm audit --json > security-audit.json
- name: Generate report
run: |
echo "# Dependency Audit Report $(date)" > report.md
echo "## Unused Dependencies" >> report.md
cat unused-deps.json | jq -r '.dependencies[]' >> report.md
echo "## Security Issues" >> report.md
cat security-audit.json | jq '.metadata.vulnerabilities' >> report.md
- name: Create issue if problems found
uses: peter-evans/create-issue-from-file@v4
if: ${{ success() }}
with:
title: Weekly Dependency Audit
content-filepath: ./report.md
labels: maintenance, dependencies
Passo 3: Habilitando o Dependabot
Enquanto nossa action personalizada se concentra em encontrar dependências não utilizadas, podemos usar o Dependabot para criar automaticamente pull requests para pacotes desatualizados. O Dependabot pode ser configurado através de um arquivo YAML simples ou automaticamente, ativando-o nas configurações do seu repositório. Aqui está o arquivo YAML que o Copilot criou:
# .github/dependabot.yml
version: 2
updates:
- package-ecosystem: "npm"
directory: "/"
schedule:
interval: "weekly"
open-pull-requests-limit: 10
O Resultado: Uma Auditoria de Dependência Totalmente Automatizada
Com isso, nosso gerenciamento de dependência está agora totalmente automatizado. Vamos recapitular como funciona:
- Nossa action personalizada usa depcheck para identificar com precisão dependências não utilizadas.
- O Dependabot cria pull requests para pacotes desatualizados, completo com changelogs e avaliações de risco.
- Vulnerabilidades de segurança são detectadas e reportadas semanalmente.
- Tudo é documentado no GitHub Issues para visibilidade da equipe.
Essa abordagem não apenas economiza tempo, mas também reduz significativamente os riscos de segurança e problemas de desempenho que surgem de dependências mal gerenciadas.
Combinando as capacidades de IA do GitHub Copilot com o GitHub Actions e Dependabot, transformamos uma tarefa manual tediosa em uma solução automatizada e integrada que mantém nossa base de código enxuta e segura. E eu vou usar essa economia de tempo para fazer algo mais interessante, como desvendar o mistério das cabras estranhas na série de TV Severance. Ou quem sabe, talvez eu finalmente descubra o que significa refinamento de macrodata naquela série (alguém tem alguma ideia ainda? A segunda temporada está me matando).
Gerenciar as dependências de um projeto de software pode ser um grande desafio, especialmente quando feito manualmente. Processos manuais são propensos a erros e podem consumir um tempo valioso das equipes de desenvolvimento. A solução automatizada que apresentamos, utilizando GitHub Copilot, GitHub Actions e Dependabot, oferece uma alternativa eficiente e segura. A integração dessas ferramentas permite identificar dependências desatualizadas, detectar vulnerabilidades de segurança e manter a base de código organizada.
A automação não só simplifica o processo, mas também garante que as dependências sejam gerenciadas de forma consistente e precisa. Isso resulta em projetos mais seguros, com melhor desempenho e menos suscetíveis a problemas causados por dependências obsoletas ou desnecessárias. Além disso, a visibilidade proporcionada pelo GitHub Issues facilita a colaboração entre os membros da equipe, garantindo que todos estejam cientes do estado das dependências e das ações necessárias.
A capacidade de transformar tarefas manuais em processos automatizados é uma das grandes vantagens das ferramentas de IA e automação disponíveis atualmente. Ao adotar soluções como o GitHub Copilot, as equipes de desenvolvimento podem se concentrar em atividades mais estratégicas e criativas, como a resolução de problemas complexos e a inovação em seus produtos. Isso não só aumenta a produtividade, mas também melhora a qualidade do trabalho e a satisfação dos membros da equipe.
Para aqueles que ainda realizam auditorias de dependência manualmente, a transição para uma solução automatizada pode parecer desafiadora, mas os benefícios a longo prazo superam qualquer dificuldade inicial. A economia de tempo, a redução de riscos e a melhoria da qualidade do código são apenas algumas das vantagens que podem ser obtidas ao adotar uma abordagem mais moderna e eficiente para o gerenciamento de dependências. Com as ferramentas certas e um pouco de planejamento, é possível transformar um processo tedioso e propenso a erros em uma tarefa simples e automatizada.
Este conteúdo foi auxiliado por Inteligência Artificiado, mas escrito e revisado por um humano.
Via The GitHub Blog