Configurar Registro Docker com Certificado SSL Autoassinado: Guia Passo a Passo

Introdução

O Docker tornou-se uma ferramenta essencial para desenvolvedores e equipes de DevOps, permitindo a implantação e o gerenciamento contínuos de aplicações em contêineres. Ao trabalhar com um registro Docker privado, a segurança da comunicação entre os clientes Docker e o servidor de registro é crucial para proteger as suas imagens de contêiner.

Neste laboratório, você aprenderá como configurar um registro Docker local e protegê-lo usando um certificado SSL autoassinado. Essa abordagem é perfeita para ambientes de desenvolvimento, testes e cenários de aprendizado onde você precisa de um registro seguro sem comprar um certificado de uma autoridade confiável.

Ao final deste tutorial, você terá um registro Docker funcional que usa HTTPS para comunicação segura, permitindo que você envie (push) e puxe (pull) imagens Docker com segurança dentro do seu ambiente de desenvolvimento.

Configurando um Registro Docker Básico

Antes de proteger nosso registro Docker com SSL, vamos primeiro entender o que é um registro Docker e configurar um registro básico para trabalhar.

O que é um Registro Docker?

Um registro Docker é um sistema de armazenamento e distribuição para imagens de contêiner Docker. Ele permite que você:

Armazene suas imagens Docker em um local central
Compartilhe imagens com sua equipe ou organização
Controle o acesso às suas imagens
Implante contêineres a partir de suas imagens em diferentes ambientes

O Docker Hub é o registro público mais conhecido, mas para muitas organizações, ter um registro privado é essencial para segurança, desempenho e controle.

Configurando um Registro Básico

Vamos começar executando um registro Docker simples e inseguro:

Crie um diretório para armazenar os dados do nosso registro:
```
mkdir -p ~/project/registry-data
```
Execute um registro Docker básico usando a imagem oficial:
```
docker run -d -p 5000:5000 --restart=always --name registry -v ~/project/registry-data:/var/lib/registry registry:2
```
Este comando:
- Executa o contêiner do registro em modo detached (-d)
- Mapeia a porta 5000 no seu host para a porta 5000 no contêiner
- Define o contêiner para reiniciar automaticamente se parar
- Nomeia o contêiner "registry"
- Monta o diretório que criamos para armazenar os dados do registro

Verifique se o registro está em execução:

docker ps

Você deve ver uma saída semelhante a:

CONTAINER ID   IMAGE        COMMAND                  CREATED         STATUS         PORTS                    NAMES
a7d8098de3a2   registry:2   "/entrypoint.sh /etc…"   5 seconds ago   Up 4 seconds   0.0.0.0:5000->5000/tcp   registry

Teste o registro enviando (push) uma imagem de exemplo:

Primeiro, puxe (pull) uma imagem pequena:
```
docker pull hello-world
```
Marque-a para o seu registro local:
```
docker tag hello-world localhost:5000/hello-world
```
Envie-a para o seu registro:
```
docker push localhost:5000/hello-world
```
Você deve ver a saída mostrando a imagem sendo enviada para o seu registro.
Pare o contêiner do registro antes de protegê-lo nos próximos passos:
```
docker stop registry
docker rm registry
```

Este registro básico funciona, mas tem uma limitação significativa: ele usa HTTP, que é inseguro. Os clientes Docker se recusam a enviar ou puxar (pull) de registros inseguros por padrão. Nos próximos passos, protegeremos nosso registro com SSL.

Gerando um Certificado SSL Autoassinado

Agora que entendemos os conceitos básicos do Registro Docker, vamos protegê-lo gerando um certificado SSL autoassinado. Este certificado permitirá a comunicação HTTPS com nosso registro.

O que é um Certificado Autoassinado?

Um certificado autoassinado é um certificado SSL que não é assinado por uma Autoridade de Certificação (CA) confiável. Embora não seja adequado para ambientes de produção expostos à internet pública, os certificados autoassinados são perfeitos para desenvolvimento, testes e aplicações internas.

Gerar o Certificado e a Chave

Usaremos o OpenSSL, um kit de ferramentas de criptografia amplamente utilizado, para criar nosso certificado:

Crie um diretório para armazenar nossos certificados:

mkdir -p ~/project/registry-certs
cd ~/project/registry-certs

Gere uma chave privada:
```
openssl genrsa -out registry.key 2048
```
Este comando gera uma chave privada RSA de 2048 bits. Você não deve ver nenhuma saída se for bem-sucedido.

Crie uma solicitação de assinatura de certificado (CSR) usando a chave privada:

openssl req -new -key registry.key -out registry.csr

Você será solicitado a inserir informações que serão incluídas em seu certificado:

Country Name (2 letter code) [AU]:US
State or Province Name (full name) [Some-State]:California
Locality Name (eg, city) []:San Francisco
Organization Name (eg, company) [Internet Widgits Pty Ltd]:Example Company
Organizational Unit Name (eg, section) []:IT
Common Name (e.g. server FQDN or YOUR name) []:localhost
Email Address []:admin@example.com

Observação: Para Common Name, insira localhost pois estaremos nos conectando ao registro em nossa máquina local.

Você também será questionado sobre:

Please enter the following 'extra' attributes
to be sent with your certificate request
A challenge password []:
An optional company name []:

Você pode deixá-los em branco pressionando Enter.

Gere o certificado autoassinado usando o CSR:

openssl x509 -req -days 365 -in registry.csr -signkey registry.key -out registry.crt

Este comando cria um certificado autoassinado válido por 365 dias.

Você deve ver uma saída semelhante a:

Signature ok
subject=C = US, ST = California, L = San Francisco, O = Example Company, OU = IT, CN = localhost, emailAddress = admin@example.com
Getting Private key

Verifique se os arquivos de certificado e chave foram criados:

ls -l

Você deve ver três arquivos:

total 12
-rw-r--r-- 1 labex labex 1220 [date] registry.crt
-rw-r--r-- 1 labex labex 1054 [date] registry.csr
-rw-r--r-- 1 labex labex 1679 [date] registry.key

Agora temos os arquivos necessários para proteger nosso registro Docker. No próximo passo, configuraremos nosso registro para usar este certificado para comunicação HTTPS.

Configurando o Registro Docker com Certificado SSL

Agora que temos nosso certificado autoassinado, podemos configurar nosso registro Docker para usar SSL para comunicação segura.

Configurando o Registro Seguro

Primeiro, vamos criar um arquivo de configuração simples para nosso registro. Este arquivo especificará as configurações HTTPS:
```
mkdir -p ~/project/registry-config
cd ~/project/registry-config
nano config.yml
```
Adicione a seguinte configuração ao arquivo:
```
version: 0.1
storage:
  filesystem:
    rootdirectory: /var/lib/registry
http:
  addr: 0.0.0.0:5000
  tls:
    certificate: /certs/registry.crt
    key: /certs/registry.key
```
Esta configuração diz ao registro para:
- Usar o sistema de arquivos para armazenamento
- Ouvir em todas as interfaces na porta 5000
- Usar TLS (HTTPS) com nosso certificado e chave
Salve e saia pressionando Ctrl+X, depois Y e, em seguida, Enter.

Agora vamos executar nosso registro com o certificado SSL:

docker run -d -p 5000:5000 --restart=always --name registry \
  -v ~/project/registry-data:/var/lib/registry \
  -v ~/project/registry-certs:/certs \
  -v ~/project/registry-config/config.yml:/etc/docker/registry/config.yml \
  registry:2

Este comando:

Monta nosso diretório de certificado e chave
Monta nosso arquivo de configuração
Usa o mesmo diretório de dados que criamos anteriormente

Verifique se o registro está em execução:
```
docker ps
```
Você deve ver a saída mostrando que o contêiner do registro está em execução.

Configurando o Cliente Docker para Confiar no Certificado

Por padrão, os clientes Docker não confiam em certificados autoassinados. Precisamos dizer ao Docker para confiar em nosso certificado:

Crie um diretório para o Docker armazenar certificados confiáveis:
```
sudo mkdir -p /etc/docker/certs.d/localhost:5000
```

Copie nosso certificado para este diretório:

sudo cp ~/project/registry-certs/registry.crt /etc/docker/certs.d/localhost:5000/ca.crt

Reinicie o serviço Docker para aplicar as alterações:
```
sudo systemctl restart docker
```
Isso pode levar alguns segundos para ser concluído.
Como reiniciar o Docker irá parar nosso contêiner de registro, vamos iniciá-lo novamente:
```
docker start registry
```
Verifique se o registro está em execução novamente:
```
docker ps
```

Agora, nosso registro Docker está configurado para usar HTTPS com nosso certificado autoassinado, e nosso cliente Docker está configurado para confiar neste certificado ao se conectar a localhost:5000.

Testando o Registro Docker Seguro

Agora que temos nosso registro Docker em execução com SSL, vamos testá-lo enviando (push) e puxando (pull) imagens. Isso confirmará que tudo está funcionando corretamente.

Testando com uma Imagem de Exemplo

Primeiro, vamos puxar uma imagem de exemplo para usar no teste:
```
docker pull alpine:latest
```
Você deve ver a saída mostrando o Docker baixando a imagem do Alpine Linux.
Marque a imagem para nosso registro seguro:
```
docker tag alpine:latest localhost:5000/alpine:latest
```
Este comando cria uma nova tag que aponta para nosso registro local.

Envie a imagem para nosso registro seguro:

docker push localhost:5000/alpine:latest

Você deve ver a saída mostrando as camadas da imagem sendo enviadas para seu registro:

The push refers to repository [localhost:5000/alpine]
213ec9aee27d: Pushed
latest: digest: sha256:69e70a79f2d41ab5d637de98c1e0b055206ba40a8145e7bddb55ccc04e13cf8f size: 528

Remova a imagem local para garantir que estamos puxando do registro:
```
docker rmi localhost:5000/alpine:latest
docker rmi alpine:latest
```

Puxe a imagem do nosso registro seguro:

docker pull localhost:5000/alpine:latest

Você deve ver a saída mostrando o Docker baixando a imagem do seu registro:

latest: Pulling from alpine
213ec9aee27d: Pull complete
Digest: sha256:69e70a79f2d41ab5d637de98c1e0b055206ba40a8145e7bddb55ccc04e13cf8f
Status: Downloaded newer image for localhost:5000/alpine:latest
localhost:5000/alpine:latest

Verificando o Conteúdo do Registro

Vamos examinar o conteúdo do nosso registro usando a API do Docker Registry:

Liste todos os repositórios no registro:

curl -X GET https://localhost:5000/v2/_catalog --cacert ~/project/registry-certs/registry.crt

Você deve ver uma saída como:

{ "repositories": ["alpine", "hello-world"] }

Isso mostra todas as imagens que enviamos para nosso registro.

Liste todas as tags para o repositório alpine:

curl -X GET https://localhost:5000/v2/alpine/tags/list --cacert ~/project/registry-certs/registry.crt

Você deve ver uma saída como:

{ "name": "alpine", "tags": ["latest"] }

Entendendo o que Realizamos

Vamos revisar o que fizemos:

Configurar um registro Docker com HTTPS usando um certificado SSL autoassinado
Configurar nosso cliente Docker para confiar neste certificado
Enviar (push) e puxar (pull) imagens com sucesso de e para nosso registro seguro

Esta configuração fornece:

Comunicação criptografada: Todos os dados transferidos entre o cliente Docker e o registro são criptografados.
Fundamento de autenticação: SSL é o primeiro passo para implementar a autenticação.
Compatibilidade do cliente Docker: Os clientes Docker exigem HTTPS por padrão para registros que não sejam localhost.

Agora você pode usar este registro seguro para suas necessidades de desenvolvimento e teste. Para ambientes de produção, você normalmente usaria um certificado de uma autoridade de certificação confiável em vez de um certificado autoassinado.

Resumo

Parabéns! Você configurou com sucesso um registro Docker seguro usando um certificado SSL autoassinado. Aqui está o que você realizou:

Configurar um registro Docker básico e entender seu propósito e funcionalidade
Gerar um certificado SSL autoassinado para proteger seu registro
Configurar o registro Docker para usar HTTPS com seu certificado
Configurar seu cliente Docker para confiar no certificado autoassinado
Testar com sucesso o registro seguro enviando (push) e puxando (pull) imagens

Essas habilidades permitem que você crie registros privados seguros para seus ambientes de desenvolvimento e teste. Registros privados dão a você controle sobre onde suas imagens Docker são armazenadas e quem pode acessá-las, enquanto a criptografia SSL garante que seus dados permaneçam seguros durante a transmissão.

Para ambientes de produção, você normalmente usaria certificados de uma autoridade de certificação confiável, mas o processo de configuração seria semelhante ao que você aprendeu neste laboratório.

Agora você pode implementar com confiança registros Docker seguros em seus próprios projetos e fluxos de trabalho de desenvolvimento, aprimorando a segurança de suas aplicações em contêineres.

Como configurar um registro Docker para usar um certificado SSL autoassinado