Como criar imagens do Docker em um canal Gitlab CI

Um caso de uso comum para pipelines de CI é criar as imagens do Docker que você usará para implantar seu aplicativo. O GitLab CI é uma ótima opção para isso, pois oferece suporte a um serviço de proxy de pull integrado, o que significa pipelines mais rápidos e um registro integrado para armazenar as imagens que você cria.

Neste guia, mostraremos como configurar compilações do Docker que usam os dois recursos acima. As etapas que você precisa seguir variam um pouco dependendo do tipo de GitLab Runner que você usará para seu pipeline. Abordaremos os artistas Shell e Docker abaixo.

índice

  1. Construindo com o shell runner
  2. Construindo com o Docker Executor
    1. Docker no Docker
    2. Suportes de acessórios de soquete
  3. Empurrando imagens para o registro do GitLab
  4. Usando o proxy de dependência do GitLab
  5. Resumo

Construindo com o shell runner

Se você estiver usando o executor de shell, certifique-se de ter o Docker instalado no computador que hospeda seu executor. O runner funciona executando comandos shell normais usando o arquivo docker binário no host do Runner.

Navegue até o repositório Git do projeto para o qual você deseja criar imagens. Crie um arquivo .gitlab-ci.yml na raiz do repositório. Esse arquivo define o pipeline do GitLab CI que será executado quando você enviar as alterações para seu projeto.

Adicione o seguinte conteúdo ao arquivo:

 estágios: - build docker_build : stage : build script : - docker build -t example.com/example-image:latest . - docker push example.com/example-image:latest

Essa configuração simplista é suficiente para demonstrar os conceitos básicos de construções de imagens baseadas em pipeline. O GitLab clona automaticamente seu repositório Git no ambiente de compilação que está executando o docker build usando seu projeto Dockerfile e disponibilizando o conteúdo do repositório como um contexto de compilação.

Após a conclusão da compilação, você pode docker push . Caso contrário, ele só estaria disponível para a instalação local do Docker que fez a compilação. Se você estiver usando um registro privado, execute o docker login antes de fornecer os detalhes de autenticação corretos:

 script: - docker login -u $DOCKER_REGISTRY_USER -p $DOCKER_REGISTRY_PASSWORD

Defina os valores das duas variáveis ​​de credencial acessando Configurações > CI/CD > Variáveis ​​na IU da web do GitLab. Clique no botão azul "Adicionar variável" para criar uma nova variável e atribuir um valor a ela. O GitLab disponibilizará essas variáveis ​​no ambiente shell usado para executar o trabalho.

Construindo com o Docker Executor

O Docker Executor do GitLab Runner é comumente usado para fornecer um ambiente completamente limpo para cada trabalho. O trabalho será executado em um contêiner isolado, portanto, o binário docker no host Runner ficará inacessível.

O Docker Executor oferece duas estratégias possíveis para criar a imagem: use o Docker-in-Docker ou conecte o soquete do Docker do host ao ambiente de compilação do Runner. Em seguida, ele usa a imagem de contêiner oficial do Docker como sua imagem de trabalho, disponibilizando o comando docker no script de CI.

Docker no Docker

O uso do Docker-in-Docker (DinD) para criar suas imagens oferece um ambiente completamente isolado para cada trabalho. O processo do Docker que compila será um filho do contêiner que o GitLab Runner cria no host para executar o processo de CI.

Você deve registrar seu executor do GitLab Runner Docker com o modo privilegiado habilitado para usar o DinD. Adicione o --docker-privileged ao registrar seu corretor:

 sudo gitlab-runner register -n --url https://example.com --registration-token $GITLAB_REGISTRATION_TOKEN --executor docker --description "Docker Runner" --docker-image "docker:20.10" --docker-volumes "/certs/client" --docker-privileged

Dentro do pipeline de CI, adicione o arquivo de imagem docker:dind como um serviço. Isso torna o Docker disponível como uma imagem separada vinculada à imagem do trabalho. Você poderá usar o comando docker para criar imagens usando a instância do Docker no contêiner docker:dind .

 services : - docker:dind docker_build : stage : build image : docker:latest script : - docker build -t example-image:latest .

O uso do DinD oferece compilações completamente isoladas que não podem afetar umas às outras ou ao seu host. A principal desvantagem é o comportamento de cache mais complicado: cada trabalho recebe um novo ambiente onde as camadas criadas anteriormente não estarão acessíveis. Você pode corrigir isso parcialmente tentando extrair a versão anterior da sua imagem antes de compilá-la e, em seguida, usando o --cache-from build para disponibilizar as camadas de imagem extraídas como uma fonte de cache:

 docker_build : stage : build image : docker: último script : - docker pull $CI_REGISTRY_IMAGE:latest || true - docker build --cache-from $CI_REGISTRY_IMAGE:latest -t $CI_REGISTRY_IMAGE:latest .

Suportes de acessórios de soquete

A montagem do soquete do Docker do host no ambiente de trabalho é uma opção alternativa ao usar o executor do Docker. Isso oferece um armazenamento em cache contínuo e elimina a necessidade de adicionar o serviço docker:dind à sua configuração de CI.

Para configurá-lo, registre seu Runner com um sinalizador docker-volumes que vincula o soquete Docker do host a /var/run/docker.sock dentro dos contêineres de trabalho:

 sudo gitlab-runner register -n --url https://example.com --registration-token $GITLAB_REGISTRATION_TOKEN --executor docker --description "Docker Runner" --docker-image "docker:20.10" --docker-volumes /var/run/docker.sock:/var/run/docker.sock

Agora os trabalhos feitos com o docker a imagem poderão usar o binário do docker como de costume. As operações serão realmente realizadas no computador host, tornando-se irmãos do contêiner de trabalho em vez de filhos.

Na verdade, isso é semelhante ao uso do shell runner com a instalação do Docker do host. As imagens residirão no host, tornando-as fáceis de usar sem interrupções normais de cache da camada de docker build .

Embora essa abordagem possa levar a um desempenho mais alto, menos configuração e nenhuma das limitações do DinD, ela tem seus próprios problemas exclusivos. As mais importantes são as implicações de segurança: os trabalhos podem executar comandos arbitrários do Docker em seu host Runner, executando assim um projeto malicioso em sua instância do GitLab. docker run -it malicious-image:latest ou docker rm -f $(docker ps -a) com consequências devastadoras.

O GitLab também avisa que a associação de soquete pode causar problemas quando os trabalhos são executados simultaneamente. Isso ocorre ao confiar na criação de containers com nomes específicos. Se duas instâncias de um trabalho forem executadas em paralelo, a segunda falhará porque o nome do contêiner já existe no host.

Você deve considerar o uso do DinD se espera que algum desses problemas seja problemático. Embora o DinD não seja mais recomendado, pode fazer mais sentido para instâncias públicas do GitLab executando trabalhos de CI simultâneos.

Empurrando imagens para o registro do GitLab

Os projetos do GitLab têm a opção de um registro integrado que você pode usar para arquivar suas imagens. Você pode visualizar o conteúdo do registro acessando Pacotes e Registros > Container Registry na barra lateral do seu projeto. Se você não vir este link, habilite o log acessando Configurações > Geral > Visibilidade, Projeto, Funções e Permissões e ativando a opção "Registro de contêiner".

O GitLab define automaticamente variáveis ​​de ambiente em seus trabalhos de CI que permitem que você faça referência ao registro de contêiner do seu projeto. Corrija a seção de script para acessar o registro e enviar sua imagem:

 script: - docker login -u gitlab-ci-token -p $CI_JOB_TOKEN $CI_REGISTRY - docker build -t $CI_REGISTRY_IMAGE:latest . - docker push $CI_REGISTRY_IMAGE:latest

O GitLab gera um conjunto seguro de credenciais para cada um de seus trabalhos de CI. A variável de ambiente $CI_JOB_TOKEN conterá um token de acesso que o trabalho pode usar para se conectar ao registro como o gitlab-ci-token . A URL do servidor de registro está disponível como $CI_REGISTRY .

A última variável, $CI_REGISTRY_IMAGE , fornece o caminho completo para o registro de contêiner do projeto. Esta é uma base adequada para seus rótulos de imagem. Você pode estender essa variável para criar sub-repositórios, como $CI_REGISTRY_IMAGE/production/api:latest .

Outros clientes Docker podem extrair imagens do registro autenticando com um token de acesso. Você pode gerá-los na tela Configurações > Tokens de acesso do seu projeto. Adicione o escopo read_registry e use as credenciais mostradas para o docker login no registro do seu projeto.

Usando o proxy de dependência do GitLab

O proxy de dependência do GitLab fornece uma camada de cache para as imagens upstream que ele extrai do Docker Hub. Ele ajuda você a ficar dentro dos limites de velocidade do Docker Hub, puxando o conteúdo da imagem apenas quando ela foi editada. Isso também melhorará o desempenho de suas compilações.

O proxy de dependência é ativado no nível do grupo GitLab acessando Configurações > Pacotes e logs > Proxy de dependência. Uma vez ativado, prefixe as referências de imagem no arquivo .gitlab-ci.yml com $CI_DEPENDENCY_PROXY_GROUP_IMAGE_PREFIX para puxá-las pelo proxy:

 docker_build : stage : build image : $CI_DEPENDENCY_PROXY_GROUP_IMAGE_PREFIX/docker:latest services : - name : $CI_DEPENDENCY_PROXY_GROUP_IMAGE_PREFIX/docker:dind alias : docker

Isso é tudo! O GitLab Runner acessa automaticamente o registro do proxy de dependência, portanto, você não precisa fornecer credenciais manualmente.

O GitLab agora armazena suas imagens em cache, oferecendo melhor desempenho e resistência a interrupções de rede. Observe que a definição de services também teve que ser alterada: as variáveis ​​de ambiente não funcionam com o módulo embutido usado acima, portanto, o name completo da imagem deve ser especificado e, em seguida, um comando de alias para referência na seção de script .

Embora já tenhamos configurado o proxy para as imagens usadas diretamente por nossas etapas de trabalho, é necessário mais trabalho para adicionar suporte à imagem base no Dockerfile a ser compilado. Uma declaração regular como esta não passará pelo proxy:

 DO Ubuntu: mais recente

Para adicionar esta última parte, use os argumentos de compilação do Docker para que a URL do proxy de dependência esteja disponível ao navegar no Dockerfile:

 ARG GITLAB_DEPENDENCY_PROXY FROM ${GITLAB_DEPENDENCY_PROXY}/ubuntu:latest

Em seguida, edite seu docker build para definir o valor da variável:

 script : > - docker build --build-arg GITLAB_DEPENDENCY_PROXY=${CI_DEPENDENCY_PROXY_GROUP_IMAGE_PREFIX} -t example-image:latest .

Agora sua imagem base também será puxada pelo proxy de dependência.

Resumo

As compilações de imagem do Docker são facilmente integradas aos pipelines de CI do GitLab. Após a configuração inicial do Runner, os comandos docker build E docker push em seu script de trabalho são tudo o que você precisa para criar uma imagem com o Dockerfile em seu repositório. O registro de contêiner integrado do GitLab oferece espaço de armazenamento privado para as imagens do seu projeto.

Além das compilações básicas, vale a pena integrar o proxy de dependência do GitLab para acelerar o desempenho e evitar atingir os limites de velocidade do Docker Hub. Você também deve verificar a segurança de sua instalação avaliando se o método selecionado permite que projetos não confiáveis ​​executem comandos em seu host Runner. Embora tenha seus problemas, o Docker-in-Docker é a abordagem mais segura quando a instância do GitLab é acessível publicamente ou para uma grande base de usuários.

  • Como hackear o jogo oculto do Google Chrome Dinosaur
  • Baixe seu Humble Game Bundle para Mac e Linux antes que eles desapareçam para sempre

descubra mais conteúdo

O que é um amplificador integrado?

Google Pixel Watch também tem detecção de queda, mas não até o próximo ano

As melhores xícaras de café aquecidas de 2022

Como automatizar seu iPhone com base na hora, atividade ou localização

"Isso deve ter sido antes do meu tempo"

Por que a NASA enviou Snoopy para a Lua? – Revisão Geek

Ir arriba