
Os pipelines de integração contínua (CI) do GitLab são uma maneira popular de automatizar compilações, testes e lançamentos sempre que você envia código para seu repositório. Os pipelines são executados simultaneamente e consistem em estágios sequenciais; cada estágio pode incluir vários trabalhos executados em paralelo durante o estágio. A simultaneidade máxima de trabalhos paralelos e pipelines de instância cruzada depende da configuração do servidor.
Os trabalhos são executados por instâncias do GitLab Runner. Os executores operam como processos isolados que recebem novos trabalhos de seu servidor GitLab de controle. Quando um trabalho é emitido, o executor cria um subprocesso que executa o script de CI. Existem várias variáveis que controlam quando um executor aceitará um trabalho e começará a executá-lo. Neste guia, veremos as maneiras de configurar trabalhos e pipelines paralelos.
Aumentando a contagem de corredores
Uma maneira de permitir que mais tarefas sejam executadas simultaneamente é simplesmente registrar mais executores. Cada instalação do GitLab Runner pode registrar várias instâncias de execução distintas. Eles operam independentemente uns dos outros e nem todos precisam se referir ao mesmo servidor coordenador.
Use o gitlab-runner register comando para adicionar um novo corredor:
sudo gitlab-runner register
Você será solicitado a fornecer as informações de registro do seu servidor GitLab. Você pode encontrar isso na página Configurações > CI/CD de um projeto ou grupo do GitLab, ou vá para Visão geral > Executores no Centro de administração para um executor em nível de instância. Os executores só executarão trabalhos originados no escopo no qual estão registrados.

Cada corredor registrado recebe sua própria seção em seu /etc/gitlab-runner/config.toml Arquivo:
# Runner 1 [[runners]] executor = "shell" ... # Runner 2 [[runners]] executor = "shell" ... # Runner 3 [[runners]] executor = "shell" ...
Se todos os três executores estiverem registrados no mesmo servidor, você verá até três trabalhos sendo executados em paralelo.
Aumentando o limite de simultaneidade
Você pode definir a simultaneidade permitida de um registro de corredor específico usando o limit campo dentro de seu bloco de configuração:
# Runner 1 [[runners]] executor = "shell" limit = 4
Essa alteração permite que o primeiro executor execute até quatro tarefas simultâneas em subprocessos. Registrando outro corredor com limit = 2 aumentaria o nível de simultaneidade para um total de seis jobs, supondo que ambos os executores referenciassem o mesmo servidor GitLab de controle.
Lidando com "Solicitar Simultaneidade"
O número de trabalhos ativos em execução não é a única variável que afeta a simultaneidade. O GitLab Runner gerencia o número de solicitações de trabalho ele pode aceitar através do separado request_concurrency variável.
Esse valor controla o número de solicitações enfileiradas que o executor receberá do GitLab. Quando o servidor precisa agendar um novo trabalho de CI, os executores precisam indicar se têm capacidade suficiente para recebê-lo. O runner não aceitará o trabalho se já tiver mais solicitações enfileiradas do que request_concurrency permitem.
Considere este exemplo:
# Runner 1 [[runners]] executor = "shell" limit = 2 request_concurrency = 4
Este executor aceitará até quatro solicitações de trabalho simultâneas e executará até duas simultaneamente. Trabalhos adicionais não serão realizados até que os dois iniciais sejam concluídos.
O nível de simultaneidade global
O GitLab Runner também mantém um fator de simultaneidade global que coloca um limite geral no limit valores expostos por cadastros individuais. Você pode controlar este valor com o concurrency configuração no topo do seu config.toml:
concurrency = 4 # Runner 1 [[runners]] executor = "shell" limit = 4 # Runner 2 [[runners]] executor = "shell" limit = 2
Aqui, a configuração dos dois corredores sugere uma simultaneidade total de seis trabalhos. No entanto, a presença do mundo concurrency configuração significa que não mais do que quatro trabalhos serão executados simultaneamente. Esse valor limita o número total de subprocessos que podem ser criados por toda a instalação do GitLab Runner.
Aplicando alterações
Depois de fazer as alterações necessárias, você pode salvar seu config.toml e volte a executar seus pipelines. As modificações no arquivo são detectadas automaticamente pelo GitLab Runner e devem ser aplicadas quase imediatamente.
Você pode tentar reiniciar o processo do GitLab Runner se o novo nível de simultaneidade não parecer ter sido aplicado:
sudo gitlab-runner restart
Isso para e inicia o serviço GitLab Runner, recarregando o arquivo de configuração.
Organizando seus pipelines para trabalhos paralelos
Se seus trabalhos em um único pipeline não estiverem sendo paralelizados, vale a pena verificar os conceitos básicos de seu .gitlab-ci.yml configuração. É só empregos que são executados simultaneamente por padrão, não os estágios do pipeline:
stages: test: build: deploy: test: stage: test # ... build_ios: stage: build # ... build_android: stage: build # ... deploy_ios: stage: deploy # ... deploy_android: stage: deploy # ...
Esse pipeline define três estágios que são mostrados horizontalmente na IU do GitLab. Cada estágio deve ser concluído antes que o próximo possa começar. O build e deploy estágios têm dois trabalhos cada. Esses trabalhos são executados em paralelo se seus executores tiverem capacidade suficiente para permanecer dentro dos limites de simultaneidade configurados.
É possível quebrar a regra “stages execute sequencialmente” usando o needs palavra-chave para construir um gráfico acíclico dirigido:
stages: test: build: deploy: test: stage: test # ... build_ios: stage: build # ... build_android: stage: build # ... deploy_ios: stage: deploy needs: ["test", "build_ios"] # ... deploy_android: stage: deploy needs: ["test", "build_android"] # ...
Aqui, a implantação do iOS pode prosseguir assim que o build_ios trabalho terminou, mesmo que o restante do build etapa não foi concluída. Usando needs torna seus pipelines mais flexíveis, adicionando novas oportunidades de paralelização. No entanto, também traz complexidade que pode ser mais difícil de manter ao longo do tempo à medida que você adiciona mais trabalhos ao seu pipeline.
E quanto ao cache?
O uso de simultaneidade significa que seus trabalhos podem ser selecionados por diferentes executores em cada passagem por um pipeline específico. Os executores mantêm suas próprias instâncias de cache, portanto, não é garantido que um trabalho atinja um cache, mesmo que uma execução anterior por meio do pipeline tenha preenchido um. O cache pode residir em um executor diferente daquele que executa o segundo trabalho.
Você pode resolver isso configurando um provedor de cache compartilhado usando um sistema de armazenamento de objetos compatível com S3. Isso fará com que os caches sejam carregados para esse provedor após a conclusão do trabalho, armazenando o conteúdo independentemente de qualquer executor específico. Outras instâncias de execução poderão recuperar o cache do servidor de armazenamento de objetos, mesmo que não o tenham criado.
O cache compartilhado pode melhorar o desempenho aumentando a probabilidade de um acerto no cache, reduzindo o trabalho que seus trabalhos precisam concluir. Seus pipelines não devem exigir resolução de cache bem-sucedida, no entanto: os caches são usados com base no melhor esforço, portanto, os scripts de CI devem ser resilientes a falhas.
Resumo
O GitLab Runner oferece três controles principais para gerenciar a simultaneidade: o limit e request_concurrency campos em corredores individuais, e o concurrency valor total da instalação. Uma instalação específica do Runner não executará mais de <concurrency> empregos simultaneamente, ainda que a soma de seus registros limit valores sugere que poderia demorar mais.
Adicionar mais corredores é outra maneira de impactar a simultaneidade geral. Em geral, é melhor aumentar a simultaneidade em um executor existente se você simplesmente deseja executar mais tarefas com a mesma configuração. Adicione um novo corredor e defina seu limit valor quando você precisa executar trabalhos com um novo executor ou configurações que diferem de sua frota existente.
Fonte Adicione ao Google Notícias



