Ajuste de desempenho dos processos
Identifique gargalos e aplique técnicas avançadas para otimizar a velocidade de execução e o consumo de recursos dos fluxos de trabalho do GitHub Actions.
Ajuste de desempenho dos processos é uma aula grátis de CI/CD with GitHub Actions & DevOps Pipelines no CoddyKit. Esta é a aula 2 de 4. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de CI/CD with GitHub Actions & DevOps Pipelines, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de CI/CD with GitHub Actions & DevOps Pipelines inclui 4 aulas no total.
Aumente a velocidade da sua pipeline
Boas-vindas ao ajuste de desempenho de pipelines! No desenvolvimento moderno, pipelines de CI/CD rápidas são essenciais para obter feedback rapidamente e usar os recursos com eficiência.
Pipelines lentas desperdiçam tempo e dinheiro. Nesta lição, você aprenderá técnicas avançadas para identificar gargalos e acelerar significativamente seus fluxos de trabalho do GitHub Actions.
Encontrando gargalos no fluxo de trabalho
Antes de otimizar, você precisa saber *o que* otimizar. O GitHub Actions oferece excelentes ferramentas para localizar etapas ou tarefas lentas.
- Interface do GitHub: visualize os registros das execuções do fluxo de trabalho. A visualização da linha do tempo mostra claramente quanto tempo cada tarefa e etapa levou.
- Resumos das tarefas: procure etapas com durações excepcionalmente longas.
- Registros das ações: registros detalhados podem revelar comandos ou processos específicos que estão consumindo mais tempo.
Concentre-se nas etapas que consistentemente levam mais tempo.
Executando tarefas independentes em paralelo
Se partes do seu fluxo de trabalho não dependerem umas das outras, execute-as ao mesmo tempo! Esta é uma maneira simples, mas poderosa, de reduzir o tempo total de execução.
Defina várias tarefas de nível superior no seu fluxo de trabalho. O GitHub Actions as executará em paralelo por padrão, desde que você não especifique dependências needs entre elas.
name: Parallel Jobs Example
on: [push]
jobs:
build-frontend:
runs-on: ubuntu-latest
steps:
- uses: actions/checkout@v4
- name: Build Frontend
run: echo "Building frontend..."
build-backend:
runs-on: ubuntu-latest
steps:
- uses: actions/checkout@v4
- name: Build Backend
run: echo "Building backend..."
Otimizando a ação de checkout
A ação actions/checkout busca o código do seu repositório. Em repositórios grandes ou com um histórico extenso, isso pode ser lento. Otimize-a:
- Clone superficial: use
fetch-depth: 1para buscar apenas o commit mais recente, economizando bastante tempo na maioria das tarefas de CI/CD. - Checkout esparso: se você precisar apenas de um subconjunto de arquivos, considere usar o checkout esparso (embora a configuração geralmente seja mais complexa).
Evite fetch-depth: 0, a menos que seja absolutamente necessário, pois ele baixa todo o histórico.
name: Optimized Checkout
on: [push]
jobs:
build:
runs-on: ubuntu-latest
steps:
- uses: actions/checkout@v4
with:
fetch-depth: 1 # Only fetch the latest commit
- name: Run Build
run: echo "Code checked out and building..."
Reduzindo o tamanho dos artefatos da compilação
Se o seu fluxo de trabalho envia ou baixa artefatos (como binários compilados ou relatórios de testes), o tamanho deles afeta diretamente o desempenho.
Para acelerar as coisas:
- Inclua apenas os arquivos necessários: não envie diretórios temporários de compilação nem registros de que você não precisa.
- Comprima os artefatos: se possível, comprima artefatos grandes antes de enviá-los. A ação
actions/upload-artifactlida automaticamente com a compressão, mas garanta que seus arquivos de origem sejam mínimos.
Filtragem por caminho para obter eficiência
Nem toda alteração de código precisa acionar todas as tarefas. Use a filtragem por caminho para executar tarefas somente quando arquivos relevantes forem modificados.
Isso é especialmente útil em repositórios maiores, nos quais uma alteração na documentação não deveria acionar uma compilação completa do back-end.
Especifique paths ou paths-ignore no gatilho on do seu fluxo de trabalho.
name: Path Filter Example
on:
push:
paths:
- 'frontend/**'
- 'shared/**'
jobs:
build-frontend:
runs-on: ubuntu-latest
steps:
- uses: actions/checkout@v4
- name: Build Frontend
run: echo "Frontend files changed, building..."
Executores mais rápidos e alocação de recursos
As máquinas virtuais (executores) que executam seus fluxos de trabalho têm diferentes tamanhos e tipos. Para tarefas que exigem muito da CPU, um executor mais potente pode reduzir drasticamente o tempo de execução.
- Executores maiores hospedados pelo GitHub: o GitHub oferece executores maiores (por exemplo,
ubuntu-latest-xlarge) para cargas de trabalho mais exigentes. - Executores auto-hospedados: se você tiver necessidades de hardware muito específicas ou quiser minimizar a latência da rede até recursos internos, os executores auto-hospedados poderão ser otimizados para atender exatamente aos seus requisitos.
Estratégias avançadas de armazenamento em cache
Armazenar dependências em cache (como pacotes do npm ou artefatos do Maven) é essencial. Vá além do armazenamento em cache básico com estas dicas:
- Chaves de cache granulares: use chaves de cache mais específicas para evitar perdas de cache desnecessárias. Por exemplo, inclua um hash de um arquivo de bloqueio específico e do OS.
- Vários caches: não coloque tudo em um único cache grande. Caches separados para diferentes tipos de dependência (por exemplo, node_modules e pacotes do pip) podem melhorar as taxas de acerto.
- Chaves de restauração: use
restore-keyspara tentar várias chaves de cache caso a principal não seja encontrada, aumentando a chance de um acerto parcial.
name: Advanced Caching
on: [push]
jobs:
build:
runs-on: ubuntu-latest
steps:
- uses: actions/checkout@v4
- name: Cache Node Modules
uses: actions/cache@v4
with:
path: ~/.npm
key: ${{ runner.os }}-node-${{ hashFiles('**/package-lock.json') }}
restore-keys: | # Try less specific keys if primary misses
${{ runner.os }}-node-
- name: Install Dependencies
run: npm ci
Otimize este fluxo de trabalho
Considere um fluxo de trabalho que compila código de front-end e back-end. Atualmente, ele é executado sequencialmente, e o checkout busca todo o histórico. Quais duas alterações melhorariam significativamente o desempenho?
name: Inefficient Workflow
on: [push]
jobs:
build-all:
runs-on: ubuntu-latest
steps:
- uses: actions/checkout@v4
- name: Install Frontend Deps
run: npm install
- name: Build Frontend
run: npm run build
- name: Install Backend Deps
run: pip install -r requirements.txt
- name: Build Backend
run: python setup.py build
Recapitulação: ajustando para obter velocidade
Você aprendeu técnicas poderosas para otimizar seus fluxos de trabalho do GitHub Actions!
- Identifique gargalos: use a interface e os registros do GitHub.
- Execute tarefas em paralelo: execute tarefas independentes simultaneamente.
- Otimize o checkout: use clones superficiais.
- Reduza os artefatos: mantenha pequenos os tamanhos de envio e download.
- Filtragem por caminho: execute tarefas somente quando arquivos relevantes forem alterados.
- Executores mais rápidos: escolha recursos de executor adequados.
- Armazenamento em cache avançado: use chaves granulares e vários caches.
Ao aplicar essas estratégias, você poderá tornar suas pipelines mais rápidas e eficientes, além de economizar tempo e recursos valiosos.
Perguntas Frequentes
A aula “Ajuste de desempenho dos processos” é grátis?
Sim — o texto completo de “Ajuste de desempenho dos processos” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de CI/CD with GitHub Actions & DevOps Pipelines, atualize para CoddyKit PRO. O curso de CI/CD with GitHub Actions & DevOps Pipelines inclui 4 aulas no total.
O que vou aprender em “Ajuste de desempenho dos processos”?
Identifique gargalos e aplique técnicas avançadas para otimizar a velocidade de execução e o consumo de recursos dos fluxos de trabalho do GitHub Actions. Você pratica CI/CD with GitHub Actions & DevOps Pipelines com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.
Preciso ter experiência prévia para começar CI/CD with GitHub Actions & DevOps Pipelines?
Nenhuma experiência prévia é necessária. CI/CD with GitHub Actions & DevOps Pipelines no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 2 de 4.
Quanto tempo leva a aula “Ajuste de desempenho dos processos”?
A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.
Posso escrever e executar código nesta aula de CI/CD with GitHub Actions & DevOps Pipelines?
Sim. Cada aula de CI/CD with GitHub Actions & DevOps Pipelines inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.
Todas as aulas deste curso
- Métricas DORA e saúde de CI/CD
- Ajuste de desempenho dos processos
- Tendências futuras na automação de DevOps
- Otimizando custos de CI/CD e eficiência dos executores