Construir Pipelines Jenkins - Parte 1. Configuração do Docker Swarm

Introdução

É difícil sobrestimar a importância da integração contínua e da entrega contínua nas práticas modernas de desenvolvimento. No entanto, a implementação correta destas práticas pode não ser assim tão fácil para muitas equipas de desenvolvimento de software. Uma das formas possíveis de o conseguir é usar soluções de código aberto como o Jenkins Pipelines, que é gratuito e extensível, embora ainda exija algum tempo e conhecimento.

Problemáticas na configuração de CI/CD

Há apenas alguns anos, configurar CI/CD para o projeto não era mais do que instalar e configurar um servidor de build autónomo como o TeamCity ou o Jenkins normal. No final, a configuração final incluía a construção de artefactos, a execução de testes unitários, a execução de testes de integração, testes e2e, deployment para múltiplos ambientes e até lançamentos em produção. O caso típico era ter diferentes agentes de build ou conjuntos de agentes por stack tecnológico, que eram partilhados entre departamentos. Uma configuração destas ainda é bastante comum hoje em dia.

Muitas equipas ainda usam agentes de build para construir o projeto, tendo todo o software necessário instalado neles. Um dos principais problemas aqui é que o ambiente de build é partilhado entre diferentes builds e, por isso, pode causar resultados imprevisíveis. Considere o caso em que testes de integração ou de sistema que usam a mesma base de dados estão a correr em simultâneo no mesmo agente. Nessa situação, é necessário um esforço adicional para que sejam executados com sucesso. Uma opção é criar uma instância de base de dados com um nome único em cada execução para a isolar; outra é limpar os dados dos testes após a execução. Mas todas estas formas não resolvem o problema completamente e, além disso, aumentam a complexidade geral da infraestrutura do projeto.

Para resolver todos estes problemas, muitas organizações usam o Docker para unificar os seus ambientes de build e de teste entre máquinas e para disponibilizar um mecanismo eficiente de deployment de aplicações. A partir das versões 2.5 e superiores do Jenkins Pipelines, este tem suporte integrado para interagir com o Docker, o que se adequa perfeitamente a este propósito.

Na Parte 1 deste artigo, vamos lançar alguma luz sobre a configuração do Docker Swarm – uma funcionalidade de clustering do Docker – e do Portainer – a UI de gestão para este.

Configuração do Docker Swarm

Pré-requisitos

Pode escolher o ambiente que preferir para executar o Docker Swarm. A única coisa que deve evitar é usar a configuração Docker in Docker (DID). Embora possa parecer uma solução conveniente em termos de deployment e configuração, podem acontecer muitos problemas ao executar a configuração DID, como conflitos, corrupção de dados, etc.

Vamos optar pelo que consideramos serem os melhores pré-requisitos:

• Centos OS numa máquina física
• Docker CE instalado (pode consultar o manual Get Docker CE for CentOS)
• Nome de domínio definido (vamos usar my.company.com neste tutorial)

Geração de Certificados

Primeiro de tudo, queremos que o nosso ambiente Docker Swarm seja seguro. Por isso, o primeiro passo a dar será a geração de certificados. Os certificados protegem as ligações SSL ao Docker Swarm Server, de modo a que o cliente tenha de fornecer certificados de cliente válidos, que o servidor depois validará aplicando os certificados do servidor.

Pode consultar a documentação original do Docker para gerar certificados – Create a CA, server and client keys with OpenSSL – ou seguir os passos abaixo:

Certificados do Servidor

1. Crie o diretório /etc/docker/certificates/server:

mkdir -p /etc/docker/certificates/server

2. Navegue até ao diretório criado:

cd /etc/docker/certificates/server

3. Gere as chaves privada e pública da CA:

openssl genrsa -aes256 -out ca-key.pem 4096

openssl req -new -x509 -days 1000 -key ca-key.pem -sha256 -out ca.pem

4. Crie uma chave de servidor e um certificate signing request (CSR):

openssl genrsa -out server-key.pem 4096

openssl req -subj "/CN=my.company.com" -sha256 -new -key server-key.pem -out server.csr

5. Assine a chave pública com a CA:

echo subjectAltName = DNS:my.company.com,IP:127.0.0.1 >> extfile.cnf

echo extendedKeyUsage = serverAuth >> extfile.cnf

6. Gere a chave:

openssl x509 -req -days 1000 -sha256 -in server.csr -CA ca.pem -CAkey ca-key.pem -CAcreateserial -out server-cert.pem -extfile extfile.cnf

Nota: my.company.com deve ser substituído pelo seu nome de domínio válido.

Certificados do Cliente

1. Crie o diretório /etc/docker/certificates/client:

mkdir -p /etc/docker/certificates/client

2. Navegue até ao diretório criado:

cd /etc/docker/certificates/client

3. Crie uma chave de cliente e um certificate signing request:

openssl genrsa -out key.pem 4096

openssl req -subj '/CN=client' -new -key key.pem -out client.csr

4. Crie um ficheiro de configuração de extensões:

echo extendedKeyUsage = clientAuth >> extfile.cnf

5. Assine a chave privada:

openssl x509 -req -days 1000 -sha256 -in client.csr -CA ../server/ca.pem -CAkey ../server/ca-key.pem -CAcreateserial -out cert.pem -extfile extfile.cnf

Uma vez gerados os certificados, pode remover os certificate signing requests:

rm -f /etc/docker/certificates/client/client.csr /etc/docker/certificates/server/server.csr

Para trabalhar com a Docker REST API no browser, o cert.pem do cliente tem de ser exportado para o formato PFX e depois adicionado aos Trusted Root Certification Authorities:

openssl pkcs12 -export -in cert.pem -inkey key.pem -out cert.pfx

Configuração do Serviço Docker

Para configurar o serviço Docker, execute os seguintes passos:

1. Crie o ficheiro de configuração do daemon Docker em /etc/docker/daemon.json com o seguinte conteúdo:

{
  "debug": false,
  "tls": true,
  "tlsverify": true,
  "tlscacert": "/etc/docker/certificates/server/ca.pem",
  "tlscert": "/etc/docker/certificates/server/server-cert.pem",
  "tlskey": "/etc/docker/certificates/server/server-key.pem",
  "hosts": ["tcp://0.0.0.0:2376", "unix:///var/run/docker.sock"]
}

2. Ative o daemon docker no arranque:

systemctl enable docker

3. Inicie o daemon docker:

systemctl start docker

Ativação do Docker Swarm Mode

A capacidade de escalabilidade fácil é o ponto mais crítico a considerar ao trabalhar com sistemas virtuais ou contentorizados. O Docker Swarm Mode possibilita estabelecer e gerir um cluster de nós Docker como um único sistema virtual. Para o ativar, devemos executar o seguinte comando uma vez:

docker swarm init

Integração do Portainer

Uma vez com o Docker Server em execução, seria ótimo ter algum tipo de UI para gestão. O Portainer é atualmente a melhor opção. É uma UI de gestão leve de código aberto que lhe permite gerir facilmente hosts Docker ou clusters Swarm.

O mais digno de nota aqui é que o Portainer não exige qualquer configuração especial e pode ser iniciado como um contentor dentro do cluster Docker existente. Para manter os dados do Portainer, é melhor criar alguma pasta no Docker Server:

mkdir -p /opt/portainer/data

Depois, basta instalar o Portainer como um serviço Docker, para que arranque automaticamente com o Docker Server:

docker service create --name portainer --publish
mode=host,target=9000,published=80 --constraint 'node.role == manager' --
mount type=bind,src=/var/run/docker.sock,dst=/var/run/docker.sock --mount
type=bind,src=/opt/portainer/data,dst=/data portainer/portainer -H
unix:///var/run/docker.sock

Por fim, se não gostar de guardar registos de histórico e de os mostrar na interface do Portainer, pode simplesmente limitar o histórico de tarefas para preservar o número especificado de registos:

docker swarm update --task-history-limit 1

Integração do Portainer

Parabéns, o nosso cluster Docker Swarm está preparado, pelo que estamos prontos para configurar o Jenkins e alguns Jenkins Pipelines. Partilhe este artigo nas redes sociais se lhe foi útil e não hesite em colocar as suas dúvidas sobre o tema.