0Pricing
DevOps Bootcamp · Aula

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 DevOps Bootcamp 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 DevOps Bootcamp, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de DevOps Bootcamp 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: 1 para 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-artifact lida 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-keys para 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 DevOps Bootcamp, atualize para CoddyKit PRO. O curso de DevOps Bootcamp 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 DevOps Bootcamp 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 DevOps Bootcamp?

Nenhuma experiência prévia é necessária. DevOps Bootcamp 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 DevOps Bootcamp?

Sim. Cada aula de DevOps Bootcamp 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

  1. Métricas DORA e saúde de CI/CD
  2. Ajuste de desempenho dos processos
  3. Tendências futuras na automação de DevOps
  4. Otimizando custos de CI/CD e eficiência dos executores
← Voltar para DevOps Bootcamp