O que é integração contínua (CI)?

A integração contínua é a próxima etapa lógica após ter um sistema de controle de versão como Git e um sistema de controle de versão remoto como GitLab ou GitHub para esforços colaborativos. O problema que os grandes projetos enfrentam é este - conforme chegam novas solicitações de pull, elas precisam ser testadas e, em seguida, integradas ao branch master e esse esforço pode facilmente levar de algumas horas a algumas semanas, dependendo do tamanho do projeto, a localização dos membros da equipe, etc.

Como qualquer problema desse tipo, a etapa lógica é automatizar todo o rigmarole de teste. Fazemos isso configurando um gatilho de forma que, sempre que commits mais novos são mesclados em um branch, um agente (GitLab Runner, por exemplo) constrói automaticamente o ambiente e o código, executa todos os testes de unidade e testes de integração contra ele. Se houver algum erro encontrado, ele dá um aviso e um relatório de falha, caso contrário você receberá um sinal verde dizendo que tudo funciona.

Claro, levado ao extremo lógico, você também pode automatizar a implantação, configurar testes A / B automatizados e remover totalmente a intervenção humana do processo. Isso é denominado como entrega contínua e / ou implantação contínua, dependendo do nível de automação. Mas vamos nos concentrar apenas na integração contínua neste tutorial.

Pré-requisitos

Vamos nos concentrar na configuração de um fluxo de CI simples no tutorial usando uma instância GitLab sobre HTTPS, que abordamos em uma postagem anterior.

Além disso, também assumimos que você configurou uma conta de usuário nesta instância do GitLab e um repositório (clonado em sua máquina local) gerenciado com seu nome de usuário. É esse repositório que usaremos para demonstrar o fluxo de trabalho de CI. No tutorial, seu nome será meu projeto.

Para listar tudo:

1. Instância GitLab
2. Repositório em branco, chamado my-project
3. Clone local deste repositório
4. Sua instância Git local configurada para enviar alterações para controlo remoto.

Criação de um aplicativo simples

Neste repositório, vamos criar um nó simples.js app. Este aplicativo é um Express simples.servidor js que deve ser implantado em um contêiner Docker. O servidor fornece uma carga útil HTTP dizendo “Hello World” no seu navegador.

Na raiz do seu repositório local, crie um arquivo aplicativo.js e adicione as seguintes linhas:

'use estrito';
const express = require ('express');
// Constants
const PORT = 8080;
const HOST = '0.0.0.0 ';
// Aplicativo
const app = express ();
aplicativo.get ('/', (req, res) =>
res.send ('Olá, mundo \ n');
);
aplicativo.ouvir (PORTO, HOST);
console.log ('Executando em http: // $ HOST: $ PORT');

Em seguida, crie outro arquivo pacote.json e adicione o seguinte a ele:

"nome": "docker_web_app",
"versão 1.0.0 ",
"descrição": "Nó.js no Docker ",
"autor": "John Doe",
"main": "servidor.js ",
"scripts":
"start": "servidor de nó.js "
,
"dependências":
"expresso": "^ 4.16.1 "

Por último, crie um Dockerfile e adicione o seguinte conteúdo a ele:

Nó DE: 8
# Criar diretório de aplicativos
WORKDIR / usr / src / app
# Instalar dependências de aplicativos
# Um curinga é usado para garantir que ambos os pacotes.json AND package-lock.json são copiados
COPIAR pacote *.json ./
EXECUTAR npm install
# Se você estiver construindo seu código para produção
# RUN npm install --only = production
# Fonte do aplicativo do pacote
CÓPIA DE…
EXPOSE 8080
CMD ["nó", "aplicativo"]

O processo de construção para este aplicativo envolveria a criação de um contêiner de nó e a instalação das dependências (como Express.módulo js). Este processo deve acontecer sem erros. Para simplificar, não vamos discutir nenhum teste neste tutorial.

GitLab Runner Pipeline

Agora adicionaríamos outro arquivo ao nosso repositório que seria chamado .gitlab-ci.yml . Este arquivo conteria as instruções para construir nosso projeto. Agora, toda vez que enviamos um commit para a nossa instância do GitLab, o GitLab invoca um Runner para construir e testar o projeto.

Atribuímos este pipeline de vários empregos que podem ser executados independentemente uns dos outros, tornando o processo de construção mais flexível. Para o repo acima, este é um válido .gitlab-ci.yml crie este arquivo na raiz do seu repositório:

imagem: nó: mais recente
estágios:
- construir
cache:
caminhos:
- node_modules /
install_dependencies:
estágio: construir
roteiro:
- npm install

Temos apenas uma etapa construir e tem apenas npm install como um script. Este é um comando que você teria que executar manualmente toda vez que uma mudança ocorrer em seu projeto. O executor GitLab faria isso por você. O runner pode ser instalado em um cluster Kubernetes, um VPS na nuvem ou em sua estação de trabalho local e, se estiver ativo, estará aguardando instruções do servidor GitLab para executar uma compilação.

Iríamos instalar e configurar um Runner localmente para automatizá-lo.

Obtendo o Runner Token

Abra seu repositório no GitLab e visite as configurações de CD / CI. Isso é Configurações → CD / CI dentro do seu repositório de teste.

Deixe a configuração Auto DevOps como padrão e clique em EXPANDIR para expandir as configurações gerais do pipeline e será mostrado um Runner Token. Copie seu valor e, claro, mantenha-o privado se você valoriza seu projeto.

Usando este token, seu executável GitLab Runner local será capaz de se registrar com segurança em sua instância GitLab.

Instalando o GitLab Runner

GitLab-Runner é um programa pequeno e leve escrito em Go que executa IC relacionado empregos em sua máquina local e envia os resultados ao GitLab para que ele considere as mudanças. É um único binário executável que pode ser instalado em qualquer sistema operacional principal. Siga as instruções aqui, para o seu sistema operacional específico. Essas instalações variam muito, então listar todas é inviável.

Alternativamente, você pode usar o Runner como um serviço Docker, mas vamos nos limitar à instalação tradicional, pois os comandos são mais simples de ler e entender para o leitor. Depois de instalá-lo em sua estação de trabalho local, você precisa executar o comando:

registro de $ gitlab-runner

Isso fará várias perguntas, começando com seu coordenador GitLab-CI, que seria sua instância GitLab:

registro de $ gitlab-runner
Digite o URL do coordenador gitlab-ci (e.g. https: // gitlab.com /):
https: // gitlab.exemplo.com

Em seguida, ele solicitaria seu Runner Token, que obtivemos na seção anterior:

Insira o token gitlab-ci para este executor:

Your_Secret_Token

Então, para alguma descrição de identificação e você pode simplesmente pular a adição de qualquer tag clicando em :

Insira a descrição gitlab-ci para este executor:

[Hostname]: Demo para configurar CI usando Runner

Insira as tags gitlab-ci para este executor (separadas por vírgula):

Registrando corredor… bem-sucedido

Mais importante, ele irá pedir a você um executor (mais sobre isso em um momento), vamos escolher o Docker por causa do nosso exemplo.

Insira o executor: docker-ssh + machine, kubernetes, paralels, shell, ssh, virtualbox, docker + machine, docker, docker-ssh:

docker

A imagem docker Base na qual a construção ocorreria, então, precisa ser especificada, nosso aplicativo de amostra usa o nó, portanto, especificaremos uma imagem do nó:

Insira a imagem padrão do Docker (e.g. rubi: 2.1):

nó: mais recente

Corredor registrado com sucesso. Sinta-se à vontade para iniciá-lo, mas se já estiver em execução, a configuração deve ser recarregada automaticamente!

Agora, algo que precisa de uma pequena explicação aqui é o que exatamente são executores? A forma como o trabalho de CI flui é que a construção de módulos, seus testes, etc, são todos conhecidos como empregos e os executores executam esses trabalhos. Se você escolher o VirtualBox como um executor, o executor GitLab se integrará ao VirtualBox instalado localmente e executará os trabalhos de CI em uma VM. Se você selecionar kubernetes, isso acontecerá no cluster do Kubernetes, na nuvem. Se você selecionar ssh, pode delegar as tarefas de CI a um servidor remoto.

Nosso projeto de amostra é baseado no Docker, então faz sentido usar o Docker como nosso executor. Você precisa ter Docker instalado localmente por esta.

Ter várias opções para executores torna o Runner mais flexível. Você pode querer construir localmente porque os arquivos do projeto são muito grandes ou você pode querer executar em um servidor remoto com 20 núcleos e meio terabyte de RAM porque o processo de construção é computacionalmente intensivo, especificar uma opção de executor oferece essa flexibilidade.

Por último, em seu shell, você deseja iniciar o serviço Runner:

$ gitlab-runner start

Vendo .gitlab-ci.yml em ação

Agora, fizemos todas essas mudanças em nosso repositório local, criamos todos os aplicativos.js, pacote.json, Dockerfile e .gitlab-ci.arquivos yml. Presumivelmente, você confirmou as alterações em seu repositório local executando:

$ git stage file_name
$ git commit -m “Mensagem de confirmação”

Vamos enviar as alterações para nosso GitLab remoto.

$ git push -u origin

Você pode então abrir seu projeto no GitLab, vá para meu-projeto → Pipeline e você verá uma tag dizendo "aprovado" ao lado do commit que você fez. Os commits subsequentes também terão tags.

Então, esse é o básico de CI usando GitLab e Runner. Espero que você tenha gostado do post e aprendido algo novo com ele.