CI/CD with GitHub Actions & DevOps Pipelines · Aula

Fluxos de trabalho e ações reutilizáveis

Crie e aproveite fluxos de trabalho reutilizáveis e ações personalizadas para modularizar seus processos e promover a consistência entre repositórios.

Fluxos de trabalho e ações reutilizáveis é uma aula grátis de CI/CD with GitHub Actions & DevOps Pipelines no CoddyKit. Esta é a aula 3 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.

Introdução à reutilização de fluxos de trabalho

No desenvolvimento moderno de software, eficiência e consistência são fundamentais. À medida que seus projetos crescem, suas necessidades de automação também aumentam.

Fluxos de trabalho reutilizáveis e ações personalizadas no GitHub Actions ajudam você a evitar repetições, tornando seus processos de CI/CD mais fáceis de manter e mais robustos.

Por que reutilizar fluxos de trabalho?

Imagine ter várias aplicações que precisam das mesmas etapas de compilação, teste ou implantação. Copiar e colar o código do fluxo de trabalho causa:

Duplicação: mais código para manter.
Inconsistência: é fácil não aplicar atualizações em todos os fluxos de trabalho.
Problemas de manutenção: as alterações exigem a atualização de muitos arquivos.

A reutilização resolve esses problemas!

Definindo um fluxo de trabalho reutilizável

Um fluxo de trabalho reutilizável é um fluxo completo que pode ser chamado por outros fluxos de trabalho. Ele fica armazenado no seu repositório e funciona como um modelo.

Para tornar um fluxo de trabalho reutilizável, você usa o evento workflow_call. Isso informa ao GitHub Actions que esse fluxo deve ser chamado, e não acionado por eventos comuns, como push ou pull_request.

Exemplo de fluxo de trabalho reutilizável

Este é um fluxo de trabalho reutilizável simples que simula uma compilação. Salve-o em .github/workflows/reusable-build.yml.

Ele define uma saída chamada build_id que os fluxos de trabalho chamadores podem usar.

name: Reusable Build Component

on:
  workflow_call:
    outputs:
      build_id:
        description: "The ID of the build operation"
        value: ${{ jobs.build.outputs.build_id }}

jobs:
  build:
    runs-on: ubuntu-latest
    outputs:
      build_id: ${{ steps.generate_id.outputs.id }}
    steps:
      - name: Checkout code
        uses: actions/checkout@v4
      - name: Generate build ID
        id: generate_id
        run: echo "id=$(date +%s)" >> "$GITHUB_OUTPUT"
      - name: Simulate build
        run: echo "Building project with ID ${{ steps.generate_id.outputs.id }}..."

Chamando um fluxo de trabalho reutilizável

Para usar um fluxo de trabalho reutilizável, outro fluxo de trabalho (o 'chamador') usa a palavra-chave uses, de forma semelhante ao uso de uma ação do GitHub.

Você especifica o caminho para o arquivo do fluxo de trabalho reutilizável dentro do seu repositório, ou até mesmo de outro repositório ou de uma versão específica.

Exemplo de fluxo de trabalho chamador

Este fluxo de trabalho, salvo como .github/workflows/main-app-ci.yml, chama nosso fluxo reusable-build.yml.

Observe como ele acessa a saída build_id do fluxo de trabalho chamado usando jobs.call-build.outputs.build_id.

name: Main App CI

on: [push]

jobs:
  call-build:
    uses: ./.github/workflows/reusable-build.yml
    outputs:
      build_id: ${{ jobs.call-build.outputs.build_id }}
  
  deploy:
    needs: call-build
    runs-on: ubuntu-latest
    steps:
      - name: Deploy app
        run: echo "Deploying app built with ID ${{ needs.call-build.outputs.build_id }}"

Passando entradas para fluxos de trabalho reutilizáveis

Os fluxos de trabalho reutilizáveis não são apenas modelos estáticos; eles podem aceitar entradas, o que os torna muito flexíveis.

Você define as entradas esperadas na seção on: workflow_call: inputs: do fluxo de trabalho reutilizável, especificando o tipo, se são obrigatórias e uma descrição. O fluxo de trabalho chamador passa essas entradas usando a palavra-chave with:.

Fluxo de trabalho reutilizável com entradas

Aqui está uma versão atualizada de reusable-build.yml que aceita uma entrada target_env. Isso permite personalizar a mesma lógica de compilação para diferentes ambientes.

name: Reusable Build Component with Input

on:
  workflow_call:
    inputs:
      target_env:
        required: true
        type: string
        description: "The target environment for the build"
    outputs:
      build_id:
        description: "The ID of the build operation"
        value: ${{ jobs.build.outputs.build_id }}

jobs:
  build:
    runs-on: ubuntu-latest
    outputs:
      build_id: ${{ steps.generate_id.outputs.id }}
    steps:
      - name: Checkout code
        uses: actions/checkout@v4
      - name: Generate build ID
        id: generate_id
        run: echo "id=$(date +%s)" >> "$GITHUB_OUTPUT"
      - name: Simulate build for ${{ inputs.target_env }}
        run: echo "Building project for ${{ inputs.target_env }} with ID ${{ steps.generate_id.outputs.id }}..."

Exemplo de chamada com entradas

Agora, nosso fluxo de trabalho principal de CI pode chamar o componente de compilação reutilizável duas vezes: uma para 'homologação' e outra para 'produção', passando valores diferentes para target_env.

name: Main App CI with Input

on: [push]

jobs:
  call-build-staging:
    uses: ./.github/workflows/reusable-build-with-input.yml
    with:
      target_env: 'staging'
    outputs:
      build_id: ${{ jobs.call-build-staging.outputs.build_id }}
  
  call-build-prod:
    uses: ./.github/workflows/reusable-build-with-input.yml
    with:
      target_env: 'production'
    outputs:
      build_id: ${{ jobs.call-build-prod.outputs.build_id }}

Fluxos de trabalho reutilizáveis vs. ações personalizadas

Embora ambos promovam a reutilização, eles têm finalidades diferentes:

Fluxos de trabalho reutilizáveis: Orquestram uma série de tarefas. Eles definem uma estrutura completa de fluxo de trabalho (por exemplo, compilação, teste e implantação).
Ações personalizadas: Executam uma tarefa específica e única dentro de uma tarefa (por exemplo, configurar o Node.js ou publicar um pacote). Elas são os blocos de construção *dentro* das etapas de uma tarefa.

Pense nos fluxos de trabalho como receitas e nas ações como ingredientes ou etapas individuais.

Verificação rápida

Quais das opções a seguir são benefícios importantes do uso de fluxos de trabalho reutilizáveis nas Ações do GitHub?

Recapitulação: fluxos de trabalho e ações reutilizáveis

Exploramos como os fluxos de trabalho reutilizáveis ajudam a modularizar suas esteiras de CI/CD.

Eles são definidos usando workflow_call.
Eles podem aceitar inputs e fornecer outputs.
Os fluxos de trabalho chamadores usam a palavra-chave uses.
Eles são diferentes das ações personalizadas, que são blocos de construção de tarefa única dentro das tarefas.

Adotar a reutilização resulta em uma automação mais eficiente, consistente e fácil de manter em todos os seus projetos.

Perguntas Frequentes

A aula “Fluxos de trabalho e ações reutilizáveis” é grátis?

Sim — o texto completo de “Fluxos de trabalho e ações reutilizáveis” é 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 “Fluxos de trabalho e ações reutilizáveis”?

Crie e aproveite fluxos de trabalho reutilizáveis e ações personalizadas para modularizar seus processos e promover a consistência entre repositórios. 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 3 de 4.

Quanto tempo leva a aula “Fluxos de trabalho e ações reutilizáveis”?

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

Compilações em matriz para vários ambientes
Armazenamento em cache de dependências para ganhar velocidade
Fluxos de trabalho e ações reutilizáveis
Execução condicional e dependências de tarefas

← Voltar para CI/CD with GitHub Actions & DevOps Pipelines