O que acontece depois que o GitLab faz o download do código?

Depois de o GitLab descarregar o código do repositório no diretório de trabalho, começa a execução do pipeline CI/CD definido no arquivo .gitlab-ci.yml.

1. Análise de .gitlab-ci.yml: GitLab Runner (ou o próprio GitLab, se estiver usando CI integrado) lê a configuração de .gitlab-ci.yml. Este arquivo descreve as etapas (stages) e tarefas (jobs) do pipeline.
2. Inicialização do Runner: Um GitLab Runner disponível é atribuído para executar o pipeline. O Runner obtém informações sobre o repositório, o commit, o branch e a configuração de .gitlab-ci.yml.
3. Criação do ambiente de execução: O Runner prepara um ambiente para executar as tarefas. Isto pode ser:
   • Máquina virtual
   • Contêiner (Docker, Kubernetes)
   • Servidor dedicado
   • Shell
4. Execução das etapas (stages): O pipeline é executado sequencialmente por etapas, definidas em .gitlab-ci.yml. As tarefas numa mesma etapa podem ser executadas em paralelo.
5. Execução das tarefas (jobs): Dentro de cada etapa, as tarefas configuradas são executadas. A tarefa inclui:
   • Definição da imagem ou executor (executor), se não estiver definido ao nível do pipeline ou secção variables.
   • Clonagem do repositório (já feito pelo GitLab, mas o Runner pode executar git fetch ou git checkout para o estado necessário).
   • Restauração do cache (se configurado) para acelerar a compilação (por exemplo, carregamento de dependências).
   • Execução de scripts (script): É o conteúdo principal da tarefa, onde são executados comandos de compilação, teste, análise ou implantação.
   • Carregamento de artefactos (se configurado): Os resultados da tarefa (por exemplo, binários compilados, relatórios) são guardados para uso ou download posterior.
   • Salvaguarda do cache (se configurado) para acelerar execuções futuras.
6. Relatório de estado: O Runner envia o estado de cada tarefa (sucesso, erro, cancelamento) de volta ao GitLab. O utilizador vê o progresso e os resultados na página do pipeline.
7. Passar para a próxima etapa: Se todas as tarefas na etapa atual terminarem com sucesso (ou se allow_failure estiver configurado), começa a próxima etapa. Se uma tarefa terminar com erro e allow_failure não estiver definido, todo o pipeline é interrompido.
8. Finalização do pipeline: Após executar todas as etapas (ou em caso de erro), o pipeline termina. Os resultados e artefactos estão disponíveis através da interface web do GitLab.

Exemplo de estrutura de /.gitlab-ci.yml`:

// Definimos as etapas de execução do pipeline
stages:
  - build
  - test
  - deploy

// Tarefa de build na etapa build
build_job:
  stage: build
  image: docker:latest // Usamos uma imagem Docker
  script:
    - echo "A construir a aplicação..."
    - docker build -t myapp:$CI_COMMIT_SHORT_SHA . // Construímos a imagem Docker
  artifacts:
    paths:
      - myapp.tar // Guardamos o artefacto de build

// Tarefa de teste na etapa test
test_job:
  stage: test
  image: python:3.9 // Usamos uma imagem Python
  script:
    - echo "A executar testes..."
    - pip install -r requirements.txt
    - pytest // Executamos os testes
  needs: ["build_job"] // Depende do sucesso do build_job

// Tarefa de deploy na etapa deploy
deploy_job:
  stage: deploy
  image: ubuntu:latest // Usamos uma imagem Ubuntu
  script:
    - echo "A fazer deploy da aplicação..."
    - echo "Script de deploy aqui..." // Script de deploy
  only: // Executar apenas em commits na branch master ou tags
    - master
    - tags
  needs: ["test_job"] // Depende do sucesso do test_job

Assim, o download do código é apenas o primeiro passo, seguido de um processo complexo de build, teste e deploy automatizado, baseado na configuração .gitlab-ci.yml.