Configurar Registro Docker con Certificado SSL Autofirmado | Guía Paso a Paso

Introducción

Docker se ha convertido en una herramienta esencial para desarrolladores y equipos de DevOps, permitiendo el despliegue y la gestión sin problemas de aplicaciones en contenedores. Al trabajar con un registro privado de Docker, asegurar la comunicación entre los clientes de Docker y el servidor del registro es crucial para proteger las imágenes de sus contenedores.

En este laboratorio, aprenderá a configurar un registro local de Docker y a asegurarlo utilizando un certificado SSL autofirmado. Este enfoque es perfecto para entornos de desarrollo, pruebas y escenarios de aprendizaje donde necesita un registro seguro sin comprar un certificado de una autoridad de confianza.

Al final de este tutorial, tendrá un registro de Docker funcional que utiliza HTTPS para una comunicación segura, lo que le permitirá enviar y extraer imágenes de Docker de forma segura dentro de su entorno de desarrollo.

Configuración de un Registro Básico de Docker

Antes de asegurar nuestro registro de Docker con SSL, primero entendamos qué es un registro de Docker y configuremos un registro básico para trabajar.

¿Qué es un Registro de Docker?

Un registro de Docker es un sistema de almacenamiento y distribución para imágenes de contenedores Docker. Le permite:

Almacenar sus imágenes de Docker en una ubicación central
Compartir imágenes con su equipo u organización
Controlar el acceso a sus imágenes
Desplegar contenedores desde sus imágenes en diferentes entornos

Docker Hub es el registro público más conocido, pero para muchas organizaciones, tener un registro privado es esencial para la seguridad, el rendimiento y el control.

Configuración de un Registro Básico

Comencemos ejecutando un registro de Docker simple y no seguro:

Cree un directorio para almacenar los datos de nuestro registro:
```
mkdir -p ~/project/registry-data
```
Ejecute un registro básico de Docker utilizando la imagen oficial:
```
docker run -d -p 5000:5000 --restart=always --name registry -v ~/project/registry-data:/var/lib/registry registry:2
```
Este comando:
- Ejecuta el contenedor del registro en modo desasociado (-d)
- Mapea el puerto 5000 en su host al puerto 5000 en el contenedor
- Configura el contenedor para que se reinicie automáticamente si se detiene
- Nombra el contenedor "registry"
- Monta el directorio que creamos para almacenar los datos del registro

Verifique que el registro se esté ejecutando:

docker ps

Debería ver una salida similar 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

Pruebe el registro enviando una imagen de muestra:

Primero, extraiga una imagen pequeña:
```
docker pull hello-world
```
Etiquétela para su registro local:
```
docker tag hello-world localhost:5000/hello-world
```
Envíela a su registro:
```
docker push localhost:5000/hello-world
```
Debería ver una salida que muestra la imagen que se está enviando a su registro.
Detenga el contenedor del registro antes de asegurarlo en los siguientes pasos:
```
docker stop registry
docker rm registry
```

Este registro básico funciona, pero tiene una limitación significativa: utiliza HTTP, que no es seguro. Los clientes de Docker se niegan a enviar o extraer de registros inseguros de forma predeterminada. En los siguientes pasos, aseguraremos nuestro registro con SSL.

Generación de un Certificado SSL Autofirmado

Ahora que entendemos los conceptos básicos del Registro de Docker, asegurémoslo generando un certificado SSL autofirmado. Este certificado habilitará la comunicación HTTPS con nuestro registro.

¿Qué es un Certificado Autofirmado?

Un certificado autofirmado es un certificado SSL que no está firmado por una Autoridad de Certificación (CA) de confianza. Si bien no son adecuados para entornos de producción expuestos a Internet pública, los certificados autofirmados son perfectos para el desarrollo, las pruebas y las aplicaciones internas.

Generar el Certificado y la Clave

Usaremos OpenSSL, un conjunto de herramientas de criptografía ampliamente utilizado, para crear nuestro certificado:

Cree un directorio para almacenar nuestros certificados:

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

Genere una clave privada:
```
openssl genrsa -out registry.key 2048
```
Este comando genera una clave privada RSA de 2048 bits. No debería ver ninguna salida si tiene éxito.

Cree una solicitud de firma de certificado (CSR) utilizando la clave privada:

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

Se le pedirá que ingrese información que se incluirá en su 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

Nota: Para Common Name, ingrese localhost ya que nos conectaremos al registro en nuestra máquina local.

También se le pedirá:

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

Puede dejar estos en blanco presionando Enter.

Genere el certificado autofirmado utilizando el CSR:

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

Este comando crea un certificado autofirmado válido por 365 días.

Debería ver una salida similar 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 que los archivos de certificado y clave se hayan creado:

ls -l

Debería ver tres archivos:

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

Ahora tenemos los archivos necesarios para asegurar nuestro registro de Docker. En el siguiente paso, configuraremos nuestro registro para usar este certificado para la comunicación HTTPS.

Configuración del Registro de Docker con Certificado SSL

Ahora que tenemos nuestro certificado autofirmado, podemos configurar nuestro registro de Docker para usar SSL para una comunicación segura.

Configuración del Registro Seguro

Primero, creemos un archivo de configuración simple para nuestro registro. Este archivo especificará la configuración HTTPS:
```
mkdir -p ~/project/registry-config
cd ~/project/registry-config
nano config.yml
```
Agregue la siguiente configuración al archivo:
```
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 configuración le dice al registro que:
- Use el sistema de archivos para el almacenamiento
- Escuche en todas las interfaces en el puerto 5000
- Use TLS (HTTPS) con nuestro certificado y clave
Guarde y salga presionando Ctrl+X, luego Y y luego Enter.

Ahora ejecutemos nuestro registro con el 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 nuestro directorio de certificado y clave
Monta nuestro archivo de configuración
Usa el mismo directorio de datos que creamos anteriormente

Verifique que el registro se esté ejecutando:
```
docker ps
```
Debería ver una salida que muestra que el contenedor del registro se está ejecutando.

Configuración del Cliente Docker para Confiar en el Certificado

De forma predeterminada, los clientes de Docker no confían en los certificados autofirmados. Necesitamos decirle a Docker que confíe en nuestro certificado:

Cree un directorio para que Docker almacene los certificados de confianza:
```
sudo mkdir -p /etc/docker/certs.d/localhost:5000
```

Copie nuestro certificado a este directorio:

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

Reinicie el servicio Docker para aplicar los cambios:
```
sudo systemctl restart docker
```
Esto puede tardar unos segundos en completarse.
Dado que reiniciar Docker detendrá nuestro contenedor de registro, volvámoslo a iniciar:
```
docker start registry
```
Verifique que el registro se esté ejecutando nuevamente:
```
docker ps
```

Ahora nuestro registro de Docker está configurado para usar HTTPS con nuestro certificado autofirmado, y nuestro cliente de Docker está configurado para confiar en este certificado al conectarse a localhost:5000.

Prueba del Registro Seguro de Docker

Ahora que tenemos nuestro registro de Docker funcionando con SSL, probémoslo enviando y extrayendo imágenes. Esto confirmará que todo funciona correctamente.

Prueba con una Imagen de Ejemplo

Primero, extraigamos una imagen de ejemplo para usarla en las pruebas:
```
docker pull alpine:latest
```
Debería ver una salida que muestra a Docker descargando la imagen de Alpine Linux.
Etiquete la imagen para nuestro registro seguro:
```
docker tag alpine:latest localhost:5000/alpine:latest
```
Este comando crea una nueva etiqueta que apunta a nuestro registro local.

Envíe la imagen a nuestro registro seguro:

docker push localhost:5000/alpine:latest

Debería ver una salida que muestra las capas de la imagen que se envían a su registro:

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

Elimine la imagen local para asegurarse de que estamos extrayendo del registro:
```
docker rmi localhost:5000/alpine:latest
docker rmi alpine:latest
```

Extraiga la imagen de nuestro registro seguro:

docker pull localhost:5000/alpine:latest

Debería ver una salida que muestra a Docker descargando la imagen de su registro:

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

Verificación del Contenido del Registro

Examinemos el contenido de nuestro registro utilizando la API del Registro de Docker:

Enumere todos los repositorios en el registro:
```
curl -X GET https://localhost:5000/v2/_catalog --cacert ~/project/registry-certs/registry.crt
```
Debería ver una salida como:
```
{ "repositories": ["alpine", "hello-world"] }
```
Esto muestra todas las imágenes que hemos enviado a nuestro registro.

Enumere todas las etiquetas para el repositorio alpine:

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

Debería ver una salida como:

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

Comprender lo que Hemos Logrado

Revisemos lo que hemos hecho:

Configurar un registro de Docker con HTTPS utilizando un certificado SSL autofirmado
Configurar nuestro cliente de Docker para que confíe en este certificado
Enviar y extraer imágenes con éxito desde y hacia nuestro registro seguro

Esta configuración proporciona:

Comunicación cifrada: Todos los datos transferidos entre el cliente de Docker y el registro están cifrados.
Fundamento de autenticación: SSL es el primer paso para implementar la autenticación.
Compatibilidad con el cliente de Docker: Los clientes de Docker requieren HTTPS de forma predeterminada para los registros que no son localhost.

Ahora puede usar este registro seguro para sus necesidades de desarrollo y prueba. Para entornos de producción, normalmente usaría un certificado de una autoridad de certificación de confianza en lugar de un certificado autofirmado.

Resumen

¡Felicidades! Ha configurado con éxito un registro seguro de Docker utilizando un certificado SSL autofirmado. Esto es lo que ha logrado:

Configurar un registro básico de Docker y comprender su propósito y funcionalidad
Generar un certificado SSL autofirmado para asegurar su registro
Configurar el registro de Docker para usar HTTPS con su certificado
Configurar su cliente de Docker para que confíe en el certificado autofirmado
Probar con éxito el registro seguro enviando y extrayendo imágenes

Estas habilidades le permiten crear registros privados seguros para sus entornos de desarrollo y prueba. Los registros privados le dan control sobre dónde se almacenan sus imágenes de Docker y quién puede acceder a ellas, mientras que el cifrado SSL garantiza que sus datos permanezcan seguros durante la transmisión.

Para entornos de producción, normalmente usaría certificados de una autoridad de certificación de confianza, pero el proceso de configuración sería similar a lo que ha aprendido en este laboratorio.

Ahora puede implementar con confianza registros seguros de Docker en sus propios proyectos y flujos de trabajo de desarrollo, mejorando la seguridad de sus aplicaciones en contenedores.

¿Cómo configurar un registro de Docker para usar un certificado SSL autofirmado?