Publicamos atualizações frequentes em nossa documentação, e a tradução desta página ainda pode estar em andamento. Para obter as informações mais recentes, acesse a documentação em inglês. Se houver problemas com a tradução desta página, entre em contato conosco.

Persistir dados de fluxo de trabalho usando artefatos

Artefatos permitem que você compartilhe dados entre trabalhos em um fluxo e armazene dados quando o fluxo de trabalho estiver concluído.

GitHub Actions is available with GitHub Free, GitHub Pro, GitHub Team, and GitHub Enterprise Cloud. GitHub Actions is unavailable for per-repository plans, which are legacy billing plans. For more information, see "GitHub's products."

Neste artigo

Sobre artefatos de fluxos de trabalho

Artefatos permitem que você persista dados depois que um trabalho foi finalizado. Um artefato é um arquivo ou uma coleção de arquivos produzidos durante a execução de um fluxo de trabalho. You can use artifacts to pass data between jobs in a workflow or persist build and test output after a workflow run has ended. GitHub stores artifacts for 90 days for pushes and pull requests. O período de retenção da pull request é reiniciado sempre que alguém faz push de novos commits para a pull request em questão.

Storing artifacts uses storage space on GitHub. GitHub Actions usage is free for public repositories. For private repositories, each GitHub account receives a certain amount of free minutes and storage, depending on the product used with the account. For more information, see "Managing billing for GitHub Actions."

Você deve fazer upload de artefatos durante a execução de um fluxo de trabalho. O GitHub fornece duas ações que você pode usar para fazer upload e baixar artefatos de compilação. Arquivos carregados na execução de um fluxo de trabalho são arquivados com o formato .zip. Para obter mais informações, consulte ações/fazer upload de artefatos e ações/fazer download de artefatos.

Cada trabalho em um fluxo é executado em uma nova instância do ambiente virtual. Quando o trabalho é finalizado, o executor encerra e exclui a instância do ambiente virtual.

Para compartilhar dados entre trabalhos:

  • Você pode fazer upload dos dados antes do trabalho finalizar para salvar o arquivo dentro da execução do fluxo de trabalho. Ao fazer upload de um arquivo, você deve nomeá-lo.
  • Depois de fazer upload de um arquivo, você pode baixá-lo em outro trabalho dentro da mesma execução de fluxo. Quando você baixa um arquivo, você pode fazer referência ao arquivo pelo nome. Você somente pode baixar artefatos que foram carregados na mesma execução de fluxo de trabalho.

As etapas que fazem parte de um trabalho são executadas no mesmo ambiente virtual, mas em seus próprios processos individuais. Para transmitir dados entre etapas de um trabalho, você pode usar entradas e saídas. Para obter mais informações sobre entradas e saídas, consulte "Sintaxe de metadados para o GitHub Actions".

Estes são alguns dos artefatos de saída de compilação e de teste comuns que talvez você queira fazer upload:

  • Arquivos de log e descartes de memória;
  • Resultados de testes, falhas e capturas de tela;
  • Arquivos binários ou de acervo;
  • Resultados de teste de estresse e resultados de cobertura do código.

Transmitir dados entre trabalhos em um fluxo

É possível usar ações upload-archive e download-archive para compartilhar dados entre trabalhos em um fluxo. Este exemplo de fluxo de trabalho ilustra como transmitir dados entre trabalhos em um mesmo fluxo. Para obter mais informações, consulte ações/fazer upload de artefatos e ações/fazer download de artefatos.

Os trabalhos que são dependentes de artefatos de um trabalho anterior devem aguardar a finalização do trabalho dependente. Esse fluxo de trabalho usa a palavra-chave needs para garantir que job_1, job_2 e job_3 sejam executados sequencialmente. Por exemplo, job_2 requer job_1 usando a sintaxe needs: job_1.

O Job 1 (Trabalho 1) executa estas etapas:

  • Adiciona os valores 3 e 7 e coloca o valor em um arquivo de texto denominado math-homework.txt.
  • Usa a ação upload-artifact para fazer upload do arquivo math-homework.txt com o nome homework. A ação coloca o arquivo em um diretório denominado homework.

O Job 2 (Trabalho 2) usa o resultado do trabalho anterior:

  • Baixa o artefato homework carregado no trabalho anterior. Por padrão, a ação download-artifact baixa artefatos no diretório da área de trabalho no qual a etapa está sendo executada. É possível especificar um diretório diferente para baixar a ação usando o parâmetro de entrada path.
  • Lê o valor no arquivo homework/math-homework.txt, multiplica o valor por 9 e atualiza o arquivo com o novo valor.
  • Faz upload do arquivo math-homework.txt. Esse upload sobrescreve o upload anterior, pois ambos compartilham o mesmo nome.

O Job 3 (Trabalho 3) mostra o resultado carregado no trabalho anterior:

  • Baixa o artefato homework.
  • Imprime o resultado da operação matemática no log.

A operação matemática completa executada nesse fluxo de trabalho é (3 + 7) x 9 = 90.

name: Share data between jobs

on: [push]

jobs:
  job_1:
    name: Add 3 and 7
    runs-on: ubuntu-latest
    steps:
      - shell: bash
        run: |
          expr 3 + 7 > math-homework.txt
      - name: Upload math result for job 1
        uses: actions/upload-artifact@v1
        with:
          name: homework
          path: math-homework.txt

  job_2:
    name: Multiply by 9
    needs: job_1
    runs-on: windows-latest
    steps:
      - name: Download math result for job 1
        uses: actions/download-artifact@v1
        with:
          name: homework
      - shell: bash
        run: |
          value=`cat homework/math-homework.txt`
          expr $value \* 9 > homework/math-homework.txt
      - name: Upload math result for job 2
        uses: actions/upload-artifact@v1
        with:
          name: homework
          path: homework/math-homework.txt

  job_3:
    name: Display results
    needs: job_2
    runs-on: macOS-latest
    steps:
      - name: Download math result for job 2
        uses: actions/download-artifact@v1
        with:
          name: homework
      - name: Print the final result
        shell: bash
        run: |
          value=`cat homework/math-homework.txt`
          echo The result is $value

Fluxo de trabalho que transmite dados entre trabalhos para executar cálculos matemáticos

Compartilhar dados entre execuções de fluxo de trabalho

Após a finalização de um fluxo de trabalho, você pode baixar um arquivo dos artefatos carregados no GitHub localizando a execução do fluxo de trabalho na aba Actions (Ações). O GitHub não oferece atualmente uma API REST para recuperar artefatos carregados.

Caso precise acessar artefatos de uma execução de fluxo de trabalho anterior, você precisará armazenar os artefatos em algum lugar. Por exemplo, você poderia executar um script no fim de seu fluxo de trabalho para armazenar artefatos no Amazon S3 ou no Artifactory, e usar a API dos serviços de armazenamento para recuperar esses artefatos em um fluxo de trabalho futuro.

Fazer upload da compilação e testar artefatos

Você pode criar uma integração contínua (CI, continuous integration) para compilar e testar seu código em um ambiente virtual hospedado no GitHub. Para obter mais informações sobre o uso do GitHub Actions para executar CI, consulte Sobre integração contínua.

A saída da compilação e teste de seu código muitas vezes produz arquivos que podem ser usados para depurar falhas em testes e códigos de produção que você pode implantar. É possível configurar um fluxo de trabalho para compilar e testar o código com push no repositório e relatar um status de sucesso ou falha. Você pode fazer upload da saída de compilação e teste para usar em implantações, para depurar falhas e testes com falhas e visualizar a cobertura do conjunto de teste.

É possível usar a ação upload-archive para fazer upload de artefatos. Para obter mais informações, consulte a ação ações/fazer upload-artefatos action.

Exemplo

Por exemplo, seu repositório ou um aplicativo web pode ter arquivos SASS e Typescript que você deve compilar em CSS e JavaScript. Pressupondo que sua configuração de compilação envia os arquivos compilados para o diretório dist, você implementaria os arquivos no diretório dist no seu servidor de aplicativo web, se todos os testes foram concluídos com sucesso.

|-- hello-world (repository)
|   └── dist
|   └── tests
|   └── src
|       └── sass/app.scss
|       └── app.ts
|   └── output
|       └── test
|   

Esse exemplo mostra como criar um fluxo de trabalho para um projeto Node.js que builds (compila) o código no diretório src e executa os testes no diretório tests. Você pode partir do princípio que executar npm test produz um relatório de cobertura de código denominado code-coverage.html, armazenado no diretório output/test/.

O fluxo de trabalho faz upload dos artefatos de produção no diretório dist e no code-coverage.html como dois artefatos separados.

name: Node CI

on: [push]

jobs:
  build_and_test:
    runs-on: ubuntu-latest
    steps:
      - name: Checkout repository
        uses: actions/checkout@v1
      - name: npm install, build, and test
        run: |
          npm install
          npm run build --if-present
          npm test
      - name: Archive production artifacts
        uses: actions/upload-artifact@v1
        with:
          name: dist
          path: dist
      - name: Archive code coverage results
        uses: actions/upload-artifact@v1
        with:
          name: code-coverage-report
          path: output/test/code-coverage.html

Imagem de execução de fluxo de trabalho de artefato carregado em fluxo de trabalho

Leia mais

Pergunte a uma pessoa

Não consegue encontrar o que procura?

Entrar em contato