Como posso passar artefatos para outro estágio?

107

Gostaria de usar o GitLab CI com o arquivo .gitlab-ci.yml para executar diferentes estágios com scripts separados. O primeiro estágio produz uma ferramenta que deve ser usada posteriormente para a realização de testes. Eu declarei a ferramenta gerada como um artefato.

Agora, como posso executar essa ferramenta em um trabalho de estágio posterior? Qual é o caminho correto e quais arquivos haverá ao redor dele?

Por exemplo, o primeiro estágio cria artefatos / bin / TestTool / TestTool.exe e esse diretório contém outros arquivos necessários (DLLs e outros). Meu arquivo .gitlab-ci.yml se parece com este:

releasebuild:
  script:
    - chcp 65001
    - build.cmd
  stage: build
  artifacts:
    paths:
      - artifacts/bin/TestTool/

systemtests:
  script:
    - chcp 65001
    - WHAT TO WRITE HERE?
  stage: test

A construção e os testes são executados no Windows, se for relevante.

ygoe
fonte

Respostas:

102

Use dependencies. Com este estágio de teste de configuração, você fará o download dos arquivos não rastreados que foram criados durante o estágio de compilação:

build:
  stage: build
  artifacts:
    untracked: true
  script:
    - ./Build.ps1

test:
  stage: test
  dependencies: 
    - build
  script:
    - ./Test.ps1
user1495793
fonte
9
Finalmente comecei a trabalhar! O ponto principal aqui é que as dependências devem ser usadas junto com os artefatos. Apenas os artefatos incluídos estariam disponíveis para consumo no estágio subsequente. Desnecessário dizer, seja conservador no que está sendo carregado. Eu diria que use expire_in. Caso contrário, podemos acabar perdendo muito espaço de armazenamento. Esses artefatos são carregados para o gitlab no trabalho / estágio / etapa de construção e baixados no teste.
Ravikanth
18
Você realmente precisa usar dependências? Estados da documentação do Gitlab Note that artifacts from all previous stages are passed by default.. A questão é quando você precisa usar dependências.
2
A documentação esclarece isso muito bem: docs.gitlab.com/ee/ci/yaml/#dependencies
chetbox
3
@Josef artefatos de todos os estágios anteriores são passados ​​por padrão (não dos trabalhos anteriores)
Vivek
1
@Josef quando você não precisa de todos os artefatos de todos os estágios anteriores para o trabalho atual. Digamos que você tenha 10 GB de binários gerados pelo estágio de compilação, mas seu estágio final apenas envia alguns e-mails sobre compilação bem-sucedida - você não precisa baixar todos os 10 GB para este trabalho
Ezh
50

Como os artefatos de todos os estágios anteriores são passados ​​por padrão, só precisamos definir os estágios na ordem correta. Experimente o exemplo abaixo, que pode ajudar a entender.

image: ubuntu:18.04

stages:
  - build_stage
  - test_stage
  - deploy_stage

build:
  stage: build_stage
  script:
    - echo "building..." >> ./build_result.txt
  artifacts:
    paths:
    - build_result.txt
    expire_in: 1 week

unit_test:
  stage: test_stage
  script:
    - ls
    - cat build_result.txt
    - cp build_result.txt unittest_result.txt
    - echo "unit testing..." >> ./unittest_result.txt
  artifacts:
    paths:
    - unittest_result.txt
    expire_in: 1 week

integration_test:
  stage: test_stage
  script:
    - ls
    - cat build_result.txt
    - cp build_result.txt integration_test_result.txt
    - echo "integration testing..." >> ./integration_test_result.txt
  artifacts:
    paths:
    - integration_test_result.txt
    expire_in: 1 week

deploy:
  stage: deploy_stage
  script:
    - ls
    - cat build_result.txt
    - cat unittest_result.txt
    - cat integration_test_result.txt

insira a descrição da imagem aqui

E no caso de passar artefatos entre tarefas em diferentes estágios, podemos usar dependências junto com artefatos para passar os artefatos, conforme descrito no documento .

E mais um exemplo mais simples:

image: ubuntu:18.04

build:
  stage: build
  script:
    - echo "building..." >> ./result.txt
  artifacts:
    paths:
    - result.txt
    expire_in: 1 week

unit_test:
  stage: test
  script:
    - ls
    - cat result.txt
    - echo "unit testing..." >> ./result.txt
  artifacts:
    paths:
    - result.txt
    expire_in: 1 week

deploy:
  stage: deploy
  script:
    - ls
    - cat result.txt
Chuan
fonte
Explicação muito clara, obrigado. Se um estágio nomear um artefato com o mesmo nome de um artefato de um estágio anterior, o artefato original será sobrescrito?
Michael Osofsky
1
@MichaelOsofsky Você pode nomear o artefato com o mesmo nome; o artefato original não será sobrescrito pelo artefato do próximo estágio com o mesmo nome. O próximo estágio apenas baixa o artefato do estágio anterior, é uma cópia dele. Eu os nomeio de forma diferente no exemplo, principalmente devido ao teste de unidade e a integração será executada em paralelo. Se removermos o trabalho de teste de integração .eg, todos os trabalhos serão executados em sequência, então podemos usar o mesmo nome para todos os artefatos sem qualquer confusão. Para sua informação, atualizo a resposta com mais um exemplo.
Chuan
Em seu exemplo, vejo que você está anexando a result.txt. Se você substituir result.txt no job unit_test, presumo que a implantação do job nunca teria acesso ao conteúdo de result.txt da construção do job. Só estou pedindo para garantir que nunca causarei esse tipo de bug em meus scripts.
Michael Osofsky
1
De acordo com o log, o estágio de implantação fará o download do result.txt dos estágios de construção e teste, mas o último substituirá o anterior.
Chuan
1
Aliás, o artefato original não é tocado e está sempre disponível para download em CI / CD -> Pipelines, clique no botão suspenso de Artefatos à direita, você encontrará todos os artefatos de todos os estágios.
Chuan