Notícias
Novos modelos de linguagem da API Serverspace GPT
DF
fevereiro 27, 2023
Atualizado janeiro 31, 2025

Como configurar pipelines de integração contínua com o Concourse CI no Ubuntu 20/22

CentOS Debian Git Linux Node.js Ubuntu

Introdução

Configure a integração contínua e automatize os pipelines de teste com a sintaxe declarativa componível do Concourse CI. Em comparação com outros sistemas para configurar a integração contínua, a equipe do Concourse faz todos os esforços para simplificar o gerenciamento do pipeline de integração contínua.

As instruções anteriores analisaram o download e a configuração do Concourse em um servidor Ubuntu 22.04 e protegeram nossa interface da Web com SSL de uma CA Let's Encrypt.
Neste tutorial, veremos como usar o Concourse para executar testes automaticamente, e as alterações serão confirmadas em nosso repositório.

Considere a possibilidade de configurar um pipeline de integração contínua com o aplicativo "hello world", usando o código Hapi.js, criado na estrutura da Web do Node.js para garantir o processo de sincronização do código com a montagem e os testes. Vamos adicionar definições de CI ao próprio repositório do produto. Vamos usar o terminal e o utilitário "fly" para iniciar o pipeline no Concourse. Por fim, vamos adicionar as alterações ao nosso repositório para salvá-las e implementar os testes no fluxo de trabalho de CI.

Preparação para o trabalho

Antes de começar, você precisa executar um servidor baseado no Ubuntu/Debian/CentOS, a RAM deve ter pelo menos 1 GB.
Defina as permissões do usuário para executar com sudo.

Baixe e instale o utilitário Concourse do site oficial ou do GitHub e o servidor da Web Nginx instalado usando o gerenciador de pacotes. Você precisa configurar um certificado de segurança TLS/SSL, configurar um servidor proxy reverso para a interface da Web do Concourse.

Precisamos obter um nome de domínio que aponte para o nosso servidor Concourse.
Use as instruções a seguir para a configuração adequada:

Neste manual, todo o processo de trabalho é considerado em um computador funcional com o Ubuntu Linux pré-instalado. Por esse motivo, você deve se certificar de que instalou vários utilitários para editar arquivos de texto que sejam convenientes para você usar.
Você também precisará do utilitário Git em seu computador local e seguirá nossas instruções para a configuração adequada.

Quando tivermos certeza de que o servidor Concourse está em execução e que o computador local tem todas as ferramentas para trabalhar com arquivos de texto e o Git está instalado, vamos prosseguir para a tarefa principal de nossas instruções.

Usando o Fly na linha de comando

Você precisa ter certeza de que o Concourse Worker e o Fly estão instalados no servidor principal (para gerenciar o pipeline usando a linha de comando).

Para o trabalho diário com o Concourse CI, é mais conveniente instalar o fly em um computador de trabalho, que tem ferramentas diárias para trabalhar com o desenvolvimento de vários produtos.
Para obter a versão mais recente do fly, você precisa abrir a interface da Web do Concourse CI instalada no servidor:

https://server_url

Após a autorização no servidor, na parte inferior direita da tela, você pode fazer o download do fly selecionando seu sistema no local de trabalho:

Fly version and link to files
Tela 1 - Fly version and link to files

Clicamos no ícone do nosso sistema local e fazemos o download para um diretório conveniente para nós, que no nosso caso é Downloads.

Linux e MacOS

Se sua estação de trabalho principal tiver Linux ou um dispositivo com MacOS, siga estas etapas para instalar e executar o Fly:

chmod +x /root/fly

Em seguida, você precisa adicionar o utilitário fly ao ambiente "PATH" para executá-lo no terminal:

install /root/fly /usr/local/bin

Vamos executar o utilitário fly e obter informações sobre a versão:

fly –version

Obtemos um resultado que corresponde à versão da interface da Web:

7.9.0

Windows

Se o sistema primário for uma estação de trabalho Windows, você precisará executar o PowerShell e adicionar o diretório bin:

PS C:UsersServerspace> mkdir bin

Você precisa copiar o utilitário fly.exe baixado para o diretório bin:

PS C:UsersServerspace> mv .Downloadsfly.exe .bin

Vamos verificar a relevância do perfil executando o comando:

PS C:UsersServerspace> Test-Path $profile

Se o resultado for True, o perfil atual está disponível no sistema.
Se o resultado for False, você precisará criar um novo perfil:

PS C:UsersServerspace> New-Item -path $profile -type file -force

Como resultado, temos:

Directory: C:UsersServerspaceDocumentsWindowsPowerShell
Mode LastWriteTime Length Name
---- ------------- --------- ----
-a---- 31.01.2023 18:05 0 Microsoft.PowerShell_profile.ps1

Vamos abrir o arquivo de perfil do editor de texto Notepad criado:

PS C:UsersServerspace> notepad.exe $profile

Uma nova janela do editor de arquivos de texto será aberta e adicionada ao ambiente PATH, especificando o caminho para o arquivo:

$env:path += ";C:UsersServerspacebin"

Salve o arquivo e saia.
Vamos começar a ler o caminho de $profile:

PS C:UsersServerspace> . $profile

Em seguida, execute o comando para verificar a versão do arquivo fly baixado:

PS C:UsersServerspace> fly.exe –version

Como saída, obtemos:

7.9.0

Ao executar comandos do Windows, você precisa alterar cada comando fly (neste tutorial) para fly.exe.

Autorização usando a linha de comando

Depois de iniciar o fly com sucesso, você precisa fazer login no Concourse instalado. Cada servidor pode usar vários "alvos", com os quais você pode identificar o pipeline necessário no sistema e executar comandos nele.
Neste tutorial, vamos dar uma olhada no tutorial no nome de destino do sistema Concourse:

fly -t tutorial login -c https://concourse_server_url

É necessário preencher o login e a senha do arquivo de configuração /etc/concourse/web_environment do nosso servidor.

Como resultado, temos:

logging in to team 'main'
username: serverspace
password:

target saved

Se a autorização for bem-sucedida, um arquivo .flyrc aparecerá em seu diretório pessoal.
Vamos verificar a criação do "tutorial" no .flyrc:

fly -t tutorial sync

Como resultado, obtemos:

version 7.9.0 already matches; skipping

Forking e clonagem de um repositório

Depois de configurar o fly, você precisa configurar o repositório para usar os pipelines do Concourse.
Em um navegador da Web, abra o link para o repositório, que usaremos em nossas instruções.
No Concourse, você precisa adicionar um pipeline de integração contínua à filial principal do repositório.

hello_hapi repository
Tela 2- hello_hapi repository

No terminal, vá para o diretório do usuário. Vamos fazer uma cópia do repositório em nosso computador de trabalho. Para isso, usaremos os seguintes comandos do utilitário git clone e iremos para uma nova ramificação:

cd
git clone https://github.com/githubUser/hello_hapi
cd hello_hapi
git checkout -b pipeline

Após a execução dos comandos, obtemos a seguinte linha:

Switched to a new branch 'pipeline'

Mudamos para uma nova ramificação.

Configurar a integração contínua para um aplicativo

Vamos definir nossos arquivos que estão associados ao repositório do projeto. Assim, garantiremos a sincronização do trabalho de integração contínua com o código em teste.
O conjunto de testes está localizado no diretório de testes. Ele contém três testes. O script de teste reside em package.json, que armazena o elemento de teste no objeto scripts.
É necessário criar um diretório chamado ci e definir duas subpastas denominadas tasks e scripts, nas quais colocaremos os arquivos de integração contínua do produto.
Vamos executar o seguinte comando:

mkdir -p ci/{tasks,scripts}

Adicionando um pipeline

No diretório ci, criaremos um arquivo chamado pipeline.yml, no qual especificaremos nossas definições de configuração:

vim ci/pipeline.yml

Depois de criar o arquivo de configuração para o pipeline principal, precisamos adicionar nossa configuração a ele.

Definição do cache NPM

Vamos adicionar a seguinte configuração:

---
resource_types:
- name: npm-cache
type: docker-image
source:
repository: ymedlop/npm-cache-resource
tag: latest

Os processos que se desacoplam dos dados de integração contínua são processados pelo Concourse e extraem as informações de status da abstração e são convertidos em recursos.
Os recursos são dados de origem para o Concourse usar ao receber ou enviar informações.
A string resource_types definirá novos tipos de recursos que você pode implementar em seu pipeline.

Definição e armazenamento em cache de um repositório

Adicione o seguinte trecho de código ao pipeline.yml para definir o recurso real para o pipeline:

resources:
- name: hello_hapi
type: git
source: &repo-source
uri: https://github.com/githubUser/hello_hapi
branch: master
- name: dependency-cache
type: npm-cache
source:
<<: *repo-source
paths:
- package.json

O primeiro dos recursos define nossa ramificação do repositório. Source define a ligação YAML para o nome da fonte do repositório.
O primeiro recurso mostra a ramificação do nosso repositório do GitHub.
O segundo recurso define uma "cache-dependency" que usará o tipo de recurso "npm-cache" e determinará a execução do download das dependências necessárias do projeto.
A cadeia de caracteres "source" é seguida por <<: *repo-source é usada para redirecionar e expandir itens. No final, escrevemos "paths", que se refere ao pacote package.json baixado anteriormente.

Teste de dependência

Vamos definir os processos reais de integração contínua usando os trabalhos do Concourse. No final da configuração pipeline.yml, adicione o seguinte trecho de código sem excluir as linhas de código anteriores:

jobs:
- name: install_dependencies
plan:
- get: hello_hapi
trigger: true
- get: dependency-cache
- name: run_tests
plan:
- get: hello_hapi
trigger: true
passed: [install_dependencies]
- get: dependency-cache
passed: [install_dependencies]
- task: run_the_test_suite
file: hello_hapi/ci/tasks/run_tests.yml

O código implementará dois trabalhos. Cada tarefa contém um nome e um plano. O plano armazena elementos como "receiving" e "setting". A primeira das instruções get recupera dados do repositório e define o parâmetro trigger como true.
O segundo Get (dependency-cache) inclui um recurso específico para fazer download e armazenar em cache as dependências necessárias do Node.js no projeto.
O operador Get precisa avaliar os requisitos do package.json e, com base nisso, o operador carrega os dados.
Há também uma instrução "passed" no código, que atribui à instrução get os elementos que passaram pelas etapas anteriores com um resultado bem-sucedido, a fim de unir os processos em pipeline.
No final de todas as instruções, é formada uma linha com um link para "run_tests.yml", para extração e execução de testes. A próxima etapa é criar esse arquivo.

Criação de tarefas de teste

O processo de extração de tarefas o ajudará a manter a definição do pipeline concisa e fácil de ler.
Você precisa criar um novo arquivo de configuração no diretório ci/tasks chamado run_tests.yml:

vim ci/tasks/run_tests.yml

Para transferir as tarefas de teste, é necessário preencher a linha com a plataforma de acordo com o nosso sistema no qual o processo de trabalho do desenvolvedor é realizado; também indicamos a imagem que qualquer entrada ou saída pode definir para uso na tarefa. No final, especifique o caminho para o arquivo executável.
Adicione o seguinte trecho de código para configurar uma tarefa para teste:

---
platform: linux

image_resource:
type: docker-image
source:
repository: node
tag: latest

inputs:
- name: hello_hapi
- name: dependency-cache

run:
path: hello_hapi/ci/scripts/run_tests.sh

O arquivo run_tests.yml contém as tarefas que serão executadas no Linux. O Concourse satisfaz as linhas de código acima sem nenhuma configuração adicional.
Você deve especificar uma imagem para usar o "worker" ao executar as tarefas. No entanto, poderemos criar tipos de imagem personalizados e usá-los. A mais comumente usada é a mais famosa imagem do Docker.

Como nosso repositório consiste em um aplicativo Node.js, selecionaremos a imagem "node" ao executar nossos testes porque ela tem todas as ferramentas necessárias.

Para o Concourse, você pode definir entrada e saída para tarefas a fim de especificar os recursos que podem ser usados para acessar os artefatos que elas criarão.

Os recursos devem corresponder às entradas recuperadas anteriormente no nível do "trabalho". Isso torna todos esses recursos disponíveis para o ambiente da tarefa como um diretório de nível superior que pode ser manipulado durante a execução da tarefa.

Neste manual, consideramos um aplicativo que está localizado no diretório hello_hapi baixado anteriormente. As dependências do Node.js são armazenadas no diretório dependency-cache.

A etapa de execução de um script com um script às vezes requer a movimentação de arquivos ou diretórios para o local esperado especificado no script e a colocação de artefatos em locais de saída no final das tarefas.

O script contém o comando a ser executado. Cada tarefa armazena um comando com um argumento, portanto, vamos criar um script bash para executar os comandos. Mas, geralmente, o caminho para o arquivo com o script de comando é indicado na tarefa. No nosso caso, especificamos o caminho para o script no diretório hello_hapi, que está localizado em hello_hapi/ci/scripts/run_tests.sh.

Na próxima etapa, considere a criação de um arquivo de script.
Você precisa salvar e sair.

Criando um arquivo de script

Agora precisamos criar um arquivo de script que execute nossos testes. Você precisará fazer alterações usando um editor de texto.

touch ci/scripts/run_tests.sh
vim ci/scripts/run_tests.sh

Esse script conterá dados para o ambiente de teste e moverá os elementos para o diretório desejado. Em seguida, os testes dos repositórios especificados serão executados e o npm test será executado.
Use o código a seguir para executar os testes:

#!/usr/bin/env bash

set -e -u -x

mv dependency-cache/node_modules hello_hapi
cd hello_hapi && npm test

Saia e salve usando :wq!
Em primeiro lugar, o caminho para o interpretador de comandos é indicado para a execução de comandos desse arquivo. Vamos definir os parâmetros padrão para interromper o script quando forem encontrados erros e em variáveis. Assim, o script é executado de forma segura e temos uma boa visibilidade da depuração.

Mv (mover) move as dependências do cache de node_modules para o diretório inicial de hello_hapi.
Em seguida, vá para o diretório inicial do projeto e execute o npm test.
Depois de escrever o código em um arquivo, você deve salvar e sair.
Você precisa atribuir permissões para executar run_tests.sh no diretório ci/scripts:

chmod +x ci/scripts/run_tests.sh

Após a atribuição de direitos, nosso pipeline está pronto para ser executado.

Executando um pipeline no Concourse

Antes de fazer o merge do branch do pipeline no branch principal e exportá-lo para o GitHub, precisamos fazer o upload do pipeline para o Concourse. Ele também processa nosso repositório para detectar alterações e executa uma rotina de integração contínua quando detectado.
Você deve iniciar manualmente o pipeline usando os comandos do utilitário fly baixado anteriormente.
Especificamos o destino por meio do parâmetro -t, adicionamos um pipeline e, após o parâmetro -p, inserimos o nome e usamos -c para apontar para o arquivo do qual os dados do pipeline serão recuperados:

fly -t tutorial set-pipeline -p hello_hapi -c ci/pipeline.yml

Concordamos com o lançamento:

Iniciando o transportador
Tela 3 - Iniciando o transportador

Depois de adicionar um pipeline com sucesso, ele é pausado. A retomada do trabalho ocorre por meio da interface da Web ou da execução do comando:

fly -t tutorial unpause-pipeline -p hello_hapi
Hello_hapi pipeline
Tela 4 - Hello_hapi pipeline

Também na interface da Web, você pode usar o botão para iniciar o pipeline.

Botão para iniciar o transportador
Tela 5 - Botão para iniciar o transportador

Comprometendo alterações no Git

Depois de iniciar o processo de integração contínua, precisamos adicionar alterações ao nosso repositório Git.
Adicionando o diretório ci ao git:

git add ci

Você precisa verificar o status dos arquivos adicionados:

git status
Checking the status
Tela 6 - Verificação do status

Vamos confirmar as alterações e usar o comando:

git commit -m 'First commit for our project'

Precisamos mesclar nossas ramificações mudando para a ramificação principal.

git checkout master

git merge pipeline

Precisamos confirmar as alterações que fizemos em nosso repositório:

git push origin master

É importante observar que, depois de salvar todas as alterações, você precisa executar o teste em um minuto.

Visão de execução do teste

Ao retornar à interface da Web, você precisa iniciar um novo teste clicando no botão +:

Starting a new test
Tela 7 - Iniciando um novo teste

Os dois primeiros testes estão marcados em amarelo porque não interagiram com o repositório Git. Depois de adicionar novos testes, você pode clicar na tarefa (tarefas) e ver os resultados do teste.

Successful test launch
Tela 8 - Lançamento de teste bem-sucedido

Se você clicar na inscrição hello_hapi, poderá retornar ao estado inicial do pipeline e ver o resultado da execução do pipeline:

Conveyor status
Tela 9 - Status do transportador

Os quadrados amarelos ao redor de uma tarefa significam que uma nova tarefa está sendo iniciada:

Starting a new task
Tela 10 - Iniciando uma nova tarefa

Conclusões

Neste guia, abordamos:

  • configuração do utilitário fly;
  • clonagem de um repositório do Git;
  • criação de um script para o transportador;
  • criação de um script para testes;
  • iniciar o transportador;
  • fazendo alterações em nosso repositório;
  • execução de testes.
Avaliação:
5 fora de 5
Аverage rating : 5
Avaliado por: 1
CEP 01311-930 São Paulo Avenida Paulista, nº 1765, 7º andar, Cj. 72, CV 10172, Bela Vista
+ 55 11 5118-1047
ITGLOBAL.COM BR LTDA
Usamos cookies para melhorar sua experiência no Serverspace. Ao continuar a navegar em nosso site, você concorda com o Uso de Cookies e com a Política de Privacidade.