Como hospedar um repositório de imagens Docker e criar imagens Docker com uma instância GitLab Self-Managed no Ubuntu 20.04

Tecnologia de conteinerização avançou significativamente no espaço tecnológico de desenvolvimento de software como o método mais aceito para empacotar e implantar aplicações em ambientes de nuvem. Isso se tornou necessário devido à necessidade de integração contínua (CI) e implantação contínua (CD), que são aspectos definidores do DevOps. Desenvolvedores e engenheiros de software utilizam contêineres para alcançar o aspecto de CI/CD da arquitetura de software. Um contêiner é essencialmente uma plataforma de computação portátil, totalmente empacotada e autossuficiente. Embora existam várias plataformas de contêineres na web, o Docker é a mais comum.

O Docker é uma plataforma de contêineres de código aberto que torna o desenvolvimento eficiente e previsível. O Docker oferece um repositório público de imagens Docker disponível em Docker Hub. Ele contém muitas imagens Docker de código aberto para as implementações mais comuns que você pode baixar e usar. Como é um repositório público, você também está livre para adicionar suas próprias imagens Docker para compartilhar com o público. Se, no entanto, você tiver código privado/proprietário, poderá ter que pagar por um repositório de imagens privado ou criar seu próprio serviço de repositório de imagens. É aqui que o GitLab entra em cena.

GitLab é um repositório Git baseado na web que é mais do que apenas uma ferramenta de controle de versão. Ele fornece ferramentas de DevOps para integração e implantação contínuas, rastreamento de problemas, registros de imagens Docker e muito mais. Ele oferece três opções: GitLab Community Edition (CE), GitLab Enterprise Edition (EE) e GitLab SaaS. O GitLab CE e o GitLab EE são soluções autogerenciadas que permitem que você mesmo baixe, instale e gerencie a instância do GitLab. O GitLab SaaS é hospedado pela GitLab Inc., e você não precisa se preocupar em instalar nada para usá-lo.

Em um tutorial anterior, mostramos como configurar uma instância do GitLab em um servidor CloudSigma e hospedar seu próprio repositório Git. Também mostramos como implementar pipelines de integração contínua com o GitLab runner para compilar e executar seus testes automaticamente sempre que houver um novo commit. Se você ainda não passou pelos tutoriais mencionados, faça-o, pois eles são a base para este tutorial.

Neste tutorial, demonstraremos como criar uma imagem Docker simples e hospedá-la em uma instância auto-hospedada do GitLab (seja usando a Community Edition ou a Enterprise Edition – o fluxo de etapas é o mesmo).

Pré-requisitos

Para acompanhar cada etapa deste tutorial, certifique-se de ter um GitLab CI runner e um servidor GitLab auto-hospedado conforme explicado abaixo.

1. Um servidor GitLab seguro

Usaremos isso para armazenar o código-fonte, executar tarefas de CI/CD e hospedar o registro de imagens Docker. Você deve ter um servidor com pelo menos 2 CPU cores e 4GB de RAM conforme recomendado pelo GitLab para instalar uma instância autogerenciada do GitLab. Você também precisará de um nome de domínio registrado para apontar para o servidor, pois o usaremos para obter um certificado SSL da Let’s Encrypt para proteger o servidor. Abaixo estão alguns links que você pode seguir para configurar uma instância auto-hospedada do GitLab.

• Registre um nome de domínio em qualquer registrador de sua escolha e aponte-o para a CloudSigma.
• Siga este tutorial para a configuração inicial do servidor Ubuntu, adicionar um usuário não-root, e ativar o firewall UFW do Ubuntu.
• Finalmente, siga este tutorial para instalar e configurar uma instância auto-hospedada do GitLab.

2. Um GitLab CI runner

Um GitLab CI runner é necessário para executar tarefas automatizadas em seus casos de teste. O tutorial sobre como configurar pipelines de Integração Contínua do GitLab no Ubuntu 20.04 oferece uma visão geral do servidor GitLab CI e mostra como acionar tarefas. Siga as etapas do tutorial para configurar o serviço GitLab CI runner, caso ainda não o tenha feito. O tutorial possui um aplicativo de demonstração em Node.js com casos de teste – nós o usaremos neste tutorial.

Agora, vamos começar!

Etapa 1: Configurando um GitLab CI Runner Privilegiado

No tutorial sobre como configurar um GitLab CI Runner, configuramos um GitLab runner usando o sudo gitlab-runner register comando que nos permitiu adicionar interativamente os parâmetros necessários. Embora isso tenha funcionado para o nosso caso de uso anterior, que era executar compilações e testes em contêineres Docker isolados, pode não lidar com a criação de imagens Docker. A criação de imagens Docker exige que o runner tenha acesso total ao serviço Docker. Você pode obter essa configuração usando o oficial docker-in-docker imagem para executar os jobs. Tal configuração envolve conceder ao runner um modo de execução privileged de execução.

Embora a concessão do privileged modo de execução seja necessária para criar imagens Docker, ela traz problemas de segurança. Isso ocorre porque envolve abrir mão dos méritos de segurança dos contêineres. Você pode pensar que os outros runners do Docker são seguros, mas eles apresentam os mesmos problemas explicados na documentação oficial do Docker.

Criaremos outro runner com o modo de execução privilegiado. Este será um runner específico do projeto devido às implicações de segurança mencionadas acima. Ele aceitará jobs do projeto Node Pipeline que criamos no tutorial sobre como configurar pipelines de CI contínuas com o GitLab.

A primeira coisa que você deve fazer é verificar se os Shared Runners estão desativados no projeto. Na página do projeto Node Pipeline do projeto, clique em Settings no menu inferior esquerdo e selecione CI/CD no submenu:

Encontre o botão Expand na seção Runners e clique nele para revelar detalhes sobre os runners disponíveis:

Clique no interruptor para Disable Shared Runners para este projeto. Se você adicionou um runner específico do projeto na seção anterior, também o desative. Estaremos adicionando um runner privileged específico do projeto para executar jobs para este projeto. Isso garante que não terminemos com erros de compilação caso o GitLab atribua jobs aleatoriamente a runners que não foram registrados com um modo de execução privilegiado. Na captura de tela acima, na aba Specific runners, você deverá ver o registration token do seu projeto. Anote-o, pois você o usará abaixo.

Note: Um runner específico do projeto também pode ser atribuído a outros projetos a partir da seção Admin panel > Runners. Ao selecionar um runner na lista de runners, você acessa a página de configuração do runner. Role para baixo para visualizar a seção Restrict projects for this runner:

É hora de abrir o seu terminal. Se você não seguiu as etapas do tutorial sobre como configurar pipelines de integração contínua do GitLab no Ubuntu 20.04, faça uma pausa neste tutorial e siga as etapas para ter um servidor com o serviço de runner do GitLab CI. Caso contrário, acesse via SSH o GitLab CI runner server com seu sudo user para as próximas etapas.

Para configurar o runner específico do projeto privilegiado, insira o seguinte comando no seu terminal, substituindo o nome do seu domínio e o token de registro copiados acima:

Esta saída mostra um registro bem-sucedido:

Para verificar se a sua instância do GitLab detectou o runner, volte ao navegador e atualize a página Settings > CI/CD. Expanda a seção Runners e você deverá ver o seu runner em Specific Runners:

Opcionalmente, se você for para o Admin Panel (clicando no botão Menu na barra superior e selecionando Admin), depois selecione Runners nas opções do menu:

Você deve chegar a esta página mostrando todos os runners disponíveis conectados à sua GitLab instance, tanto runners compartilhados quanto específicos do projeto:

Até este ponto, você configurou com sucesso um runner que pode criar imagens Docker.

Step 2: Configuring GitLab’s Docker Registry

Alguns fluxos de trabalho cruciais exigem independência de serviços externos. É aí que entra o GitLab auto-gerenciado Docker Registry entra em cena. Ele não é apenas seguro, mas garante que você tenha a flexibilidade de adaptar seus jobs e pipelines de acordo com suas necessidades. Para configurar o Docker Registry, você modificará o arquivo de configuração do GitLab. Primeiro, acesse a instância do GitLab via SSH e abra o arquivo com o seguinte comando:

Role para baixo até ver as Container Registry Settings:

Descomente a linha com o registry_external_url e defina-o como o nome de domínio da sua instância do GitLab, especificando a porta 8888 no final:

Em seguida, precisamos especificar onde o registry encontrará os certificados do Let’s Encrypt adicionando as seguintes linhas. Lembre-se de editar com o nome de domínio real da sua instância do GitLab:

Quando terminar, salve e feche o arquivo. Insira o seguinte comando no seu terminal para reconfigurar o GitLab:

Em seguida, aguarde alguns segundos para que o comando termine de ser executado. Você deverá ver a seguinte saída se for bem-sucedido:

Em seguida, precisamos garantir que o firewall (ufw) permita o tráfego para a porta do registry que atribuímos usando o comando:

Depois, você precisa testar se o Docker Registry está funcionando fazendo login nele a partir de outra máquina que tenha o Docker instalado usando o comando docker login. Se você não tiver configurado o Docker em seu ambiente local, poderá acessar o servidor do runner do GitLab CI via SSH, pois ele já possui o Docker instalado. Em seguida, execute o seguinte comando, especificando, obviamente, o nome de domínio da sua instância do GitLab:

A sua saída mostrará a mensagem Login Succeeded assim:

Isso significa que o registry foi configurado com sucesso e está funcionando. Quando você cria imagens, elas serão armazenadas localmente no sistema de arquivos do servidor do GitLab. Isso é adequado para um registry privado de uma empresa. No entanto, se você planeja deixar seu registry aberto ao público, poderá precisar de mais espaço de armazenamento. Felizmente, o GitLab oferece opções para conectar a buckets de armazenamento. Você pode ler mais na documentação oficial do documentação do GitLab container registry para ver como você pode configurar um bucket de armazenamento para sua instância do GitLab.

Passo 3: Modificar o arquivo gitlab-ci.yml e criar uma imagem Docker

Para prosseguir com esta etapa, você deve ter o projeto Node Pipeline na sua instância do GitLab. Aqui está a visualização do projeto no GitLab:

Nós falamos sobre o gitlab-ci.yml como o arquivo que o runner do GitLab CI lê quando é acionado para saber como construir sua aplicação e realizar testes automatizados. Precisamos modificar este arquivo para adicionar instruções para a construção de imagens Docker. Você pode optar por editar este arquivo diretamente na interface do GitLab. Você também pode cloná-lo em sua máquina local e editá-lo com seu editor favorito, depois fazer um commit e git push de volta para o GitLab. Para fins de brevidade, usaremos a instância do GitLab.

Clique no arquivo para abri-lo e, em seguida, clique no botão Editar:

Isso abre o arquivo pronto para edição. Exclua tudo do arquivo e adicione o seguinte código:

Enquanto adiciona o trecho de código acima, lembre-se de atualizar a parte destacada com seus detalhes reais. Quando terminar, salve as alterações pressionando o botão Commit changes. Se você estiver trabalhando fora do GitLab, faça o commit e o push de suas alterações.

Vamos entender o que o código que adicionamos ao arquivo .gitlab-ci.yml está fazendo. A primeira linha diz ao GitLab para usar a imagem Docker-in-Docker e a anexa ao serviço docker-in-docker (docker:dind). Em seguida, definimos os estágios para build, test, e release. O estágio de build constrói a imagem usando as instruções no Dockerfile e depois a envia para o Docker Registry que configuramos em uma etapa anterior.

Quando o estágio de build for bem-sucedido, o estágio de test baixa a imagem, executa-a como um contêiner e executa o comando npm test para realizar testes automatizados dentro dele. Se o estágio de test for bem-sucedido, o estágio de release assume o controle. No estágio de release, a imagem é baixada e marcada como node_pipeline:latest. Em seguida, ela é enviada de volta para o registry.

Esta é apenas uma configuração básica para um projeto de demonstração. Para seus projetos do mundo real, você poderia ter outros estágios, por exemplo staging, production, etc. Quando você salva o arquivo após a edição, um pipeline é acionado. Ele então começa a executar os jobs. Volte para a página Node Pipeline. Você deverá ver que o job está em execução no momento:

Clique no ícone indicador CI para visualizar os vários estágios do job:

Como você pode ver na captura de tela acima, todos os estágios foram bem-sucedidos, conforme os ícones de marca de seleção verdes. Você pode clicar em cada estágio para visualizar a saída do job:

No menu lateral esquerdo, clique em Packages & Registries e selecione Container Registry:

Isso abre uma página que lista as imagens Docker disponíveis para o projeto selecionado. A imagem que construímos e lançamos deve aparecer na lista com a tag atribuída:

Clique para revelar as várias tags da imagem:

Se você tiver o Docker instalado em seu ambiente local, poderá baixar a imagem e testar se ela funciona como esperado. Clique no ícone Copiar ao lado do nome da tag da imagem. Isso copiará para a sua área de transferência o nome completo da imagem que você pode usar com o comando docker pull:

Os comandos acima baixarão a imagem e a executarão dentro de um contêiner:

O aplicativo agora está sendo servido na porta 8090. Se você abrir seu navegador e navegar até your-IP-address:8090 você deverá ver a página exibida:

Se você conseguir ver essa página em seu navegador, então você construiu com sucesso uma imagem Docker e a compartilhou em um Docker Registry. No futuro, se você fizer qualquer alteração na master branch, as etapas definidas no .gitlab-ci.yml arquivo serão executadas e, se forem bem-sucedidas, uma nova imagem Docker com a tag latest será reconstruída e enviada para o registro.

Conclusão

Neste projeto, você aprendeu como adicionar um privilegiado runner do GitLab à sua instância autogerenciada do GitLab para que você possa construir imagens Docker. Você também configurou um registro privado de imagens Docker para hospedar suas imagens. Usando o Node pipeline projeto, você pôde testar cada componente da configuração e garantir que eles se conectassem e se comunicassem como esperado. Assim que sua imagem ficou disponível no registro, você pôde fazer o pull dela e confirmar que ela foi executada dentro de um contêiner.

Este é um tutorial introdutório, que fornece as bases para você começar. Siga a documentação oficial do GitLab para saber mais sobre o GitLab. Este link pode fornecer informações sobre o GitLab Container Registry.

Para mais recursos sobre a utilização do Docker, você pode querer conferir mais tutoriais em nosso blog:

• Compartilhando dados entre contêineres Docker
• Configurando um Docker Registry privado no Ubuntu 18.04
• Como compartilhar dados entre um contêiner Docker e um host
• Limpando recursos do Docker – Imagens, contêineres e volumes

Boa computação!