Cómo configurar un registro privado de Docker en Rocky Linux 8

Si trabaja para una organización y desea mantener sus imágenes de Docker internamente para una implementación rápida, entonces alojar un repositorio de Docker privado es perfecto. Tener un registro docker privado le permite ser dueño de su tubería de distribución de imágenes y tener un control más estricto sobre el almacenamiento y la distribución de imágenes. Puede integrar su registro con su sistema CI/CD mejorando su flujo de trabajo.

Este tutorial le enseñará cómo configurar y usar un registro Docker privado en un servidor basado en Rocky Linux 8 usando Amazon S3 como ubicación de almacenamiento.

Requisitos

• Dos servidores Linux con Rocky Linux 8. Un servidor actuará como host de registro, mientras que el otro se usará como cliente para enviar solicitudes y recibir imágenes del host.
• Un nombre de dominio registrado que apunta al servidor host. Usaremos registry.example.com para nuestro tutorial.
• Un usuario no root con privilegios sudo en ambas máquinas.

Paso 1:configurar el cortafuegos

El primer paso es configurar el cortafuegos. Rocky Linux usa Firewalld Firewall. Compruebe el estado del cortafuegos.

$ sudo firewall-cmd --state
running

El firewall funciona con diferentes zonas, y la zona pública es la predeterminada que usaremos. Enumere todos los servicios y puertos activos en el firewall.

$ sudo firewall-cmd --permanent --list-services

Debería mostrar el siguiente resultado.

cockpit dhcpv6-client ssh

Permitir puertos HTTP y HTTPS.

$ sudo firewall-cmd --permanent --add-service=http
$ sudo firewall-cmd --permanent --add-service=https

Vuelva a comprobar el estado del cortafuegos.

$ sudo firewall-cmd --permanent --list-services

Debería ver un resultado similar.

cockpit dhcpv6-client http https ssh

Vuelva a cargar el cortafuegos para habilitar los cambios.

$ sudo firewall-cmd --reload

Paso 2:instalar Docker y Docker Compose

Este paso es necesario tanto en el servidor como en las máquinas cliente.

Instale el repositorio oficial de Docker.

$ sudo dnf install yum-utils
$ sudo yum-config-manager \
    --add-repo \
    https://download.docker.com/linux/centos/docker-ce.repo

Instalar Docker.

$ sudo dnf install docker-ce docker-ce-cli containerd.io

Habilite y ejecute el demonio Docker.

$ sudo systemctl enable docker --now

Agregue el usuario de su sistema al grupo Docker para evitar el uso de sudo para ejecutar los comandos de Docker.

$ sudo usermod -aG docker $(whoami)

Vuelva a iniciar sesión en su servidor después de cerrar la sesión para habilitar el cambio.

Descargue e instale la última versión estable de Docker Compose.

$ sudo curl -L "https://github.com/docker/compose/releases/download/1.29.2/docker-compose-$(uname -s)-$(uname -m)" -o /usr/local/bin/docker-compose

Aplicar permisos ejecutables al archivo binario descargado.

$ sudo chmod +x /usr/local/bin/docker-compose

Instale el script Docker-compose Bash Completion.

$ sudo curl \
    -L https://raw.githubusercontent.com/docker/compose/1.29.2/contrib/completion/bash/docker-compose \
    -o /etc/bash_completion.d/docker-compose

Vuelva a cargar la configuración de su perfil para que la finalización de bash funcione.

$ source ~/.bashrc

Paso 3:configurar el registro de Docker

Crear directorios de usuarios

Cree un directorio para la configuración del registro.

$ mkdir ~/docker-registry

Cambie al docker-registry directorio.

$ cd ~/docker-registry

Cree un directorio para almacenar la contraseña de autenticación HTTP, los archivos de configuración de Nginx y los certificados SSL.

$ mkdir auth

Cree otro directorio para almacenar los registros de Nginx.

$ mkdir logs

Crear depósito de Amazon S3

Puede almacenar los datos de registro y las imágenes en su servidor o utilizar un servicio de alojamiento en la nube. Para nuestro tutorial, utilizaremos el servicio en la nube de Amazon S3.

El siguiente paso es configurar el archivo de configuración con algunas configuraciones importantes. Esta configuración también se puede definir en docker-compose.yml archivo, pero tener un archivo separado es mucho mejor.

Cree un depósito con la siguiente configuración.

• ACL debe estar deshabilitado.
• El acceso público al cubo debe estar deshabilitado.
• El control de versiones del depósito debe estar deshabilitado.
• Habilite el cifrado de depósito con claves administradas de Amazon S3. (SSE-S3)
• El bloqueo de objetos debe estar deshabilitado.

Cree un usuario de IAM con la siguiente política.

{
  "Version": "2012-10-17",
  "Statement": [
    {
      "Effect": "Allow",
      "Action": [
        "s3:ListBucket",
        "s3:GetBucketLocation",
        "s3:ListBucketMultipartUploads"
      ],
      "Resource": "arn:aws:s3:::S3_BUCKET_NAME"
    },
    {
      "Effect": "Allow",
      "Action": [
        "s3:PutObject",
        "s3:GetObject",
        "s3:DeleteObject",
        "s3:ListMultipartUploadParts",
        "s3:AbortMultipartUpload"
      ],
      "Resource": "arn:aws:s3:::S3_BUCKET_NAME/*"
    }
  ]
}

Reemplace el S3_BUCKET_NAME con el nombre de su depósito S3.

Anote la clave secreta, el valor secreto y la región del depósito de su depósito que se utilizará más adelante.

Crear archivo de composición de Docker

Crea el docker-compose.yml archivo y ábralo para editarlo.

$ nano docker-compose.yml

Pegue el siguiente código en él.

version: '3.3'
services:
  registry:
    image: registry:2 
    restart: always
    environment:
      - REGISTRY_STORAGE=s3
      - REGISTRY_STORAGE_S3_REGION=us-west-2
      - REGISTRY_STORAGE_S3_BUCKET=hf-docker-registry
      - REGISTRY_STORAGE_S3_ENCRYPT=true
      - REGISTRY_STORAGE_S3_CHUNKSIZE=5242880
      - REGISTRY_STORAGE_S3_SECURE=true
      - REGISTRY_STORAGE_S3_ACCESSKEY=AKIA3FIG4NVFCJ6STMUA
      - REGISTRY_STORAGE_S3_SECRETKEY=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
      - REGISTRY_STORAGE_S3_V4AUTH=true
      - REGISTRY_STORAGE_S3_ROOTDIRECTORY=/image-registry
      - REGISTRY_STORAGE_CACHE_BLOBDESCRIPTOR=inmemory
      - REGISTRY_HEALTH_STORAGEDRIVER_ENABLED=false
  nginx:  
    image: "nginx:alpine"
    ports:
      - 443:443
    links:
      - registry:registry
    volumes:
      - ./auth:/etc/nginx/conf.d
      - ./auth/nginx.conf:/etc/nginx/nginx.conf:ro
      - ./logs:/var/log/nginx
      - /etc/letsencrypt:/etc/letsencrypt

Guarde el archivo presionando Ctrl + X e ingresando Y cuando se le solicite.

Repasemos lo que hemos configurado en nuestro archivo de redacción.

1. El primer paso es tomar la imagen más reciente de la versión 2 del registro de Docker desde el concentrador. No usamos la última etiqueta porque puede causar problemas en el caso de una actualización de versión principal. Configurarlo en 2 le permite obtener todas las actualizaciones 2.x y evitar que se actualice automáticamente a la siguiente versión principal, lo que puede introducir cambios importantes.

2. El contenedor de registro está configurado para reiniciarse siempre en caso de falla o apagado inesperado.

3. Hemos establecido varias variables de entorno para el almacenamiento de Amazon S3. Repasémoslos rápidamente.

   • REGISTRO_ALMACENAMIENTO establece el tipo de almacenamiento. Hemos seleccionado s3 ya que estamos usando Amazon S3.
   • REGISTRO_ALMACENAMIENTO_S3_REGIÓN establece la región de su depósito S3.
   • REGISTRO_ALMACENAMIENTO_S3_CUBO establece el nombre de su depósito S3.
   • REGISTRY_STORAGE_S3_ENCRYPT - Establézcalo en verdadero si ha habilitado el cifrado de depósito.
   • REGISTRY_STORAGE_S3_CHUNKSIZE establece el tamaño de los fragmentos de carga. Debe tener más de 5 MB (5 * 1024 * 1024).
   • REGISTRO_STORAGE_S3_SECURE - Establézcalo en verdadero si va a utilizar HTTPS.
   • REGISTRY_STORAGE_S3_ACCESSKEY y REGISTRY_STORAGE_S3_SECRETKEY - Credenciales de usuario que obtuvo después de crear su usuario de IAM.
   • REGISTRO_ALMACENAMIENTO_S3_V4AUTH - configúrelo en verdadero si usa v4 de autenticación de AWS. Si recibe errores relacionados con el inicio de sesión de S3, configúrelo como falso.
   • REGISTRY_STORAGE_S3_ROOTDIRECTORY - establece el directorio raíz en su depósito bajo el cual se almacenarán sus datos de registro.
   • REGISTRO_STORAGE_CACHE_BLOBDESCRIPTOR - establece la ubicación de la caché. En nuestro caso, lo estamos almacenando en la memoria. También puede configurarlo para usar Redis.
   • REGISTRO_HEALTH_STORAGEDRIVER_ENABLED - Establézcalo en falso para deshabilitar el servicio de verificación del estado del almacenamiento del Registro. Hay un error con el Registro que puede causar problemas si no lo configura en falso.

4. El registro de Docker se comunica a través del puerto 5000, que es lo que hemos expuesto en nuestro servidor al docker.

5. ./auth:/etc/nginx/conf.d el mapeo garantiza que todas las configuraciones de Nginx estén disponibles en el contenedor.

6. ./auth/nginx.conf:/etc/nginx/nginx.conf:ro asigna el archivo de configuración de Nginx del sistema a uno en el contenedor en modo de solo lectura.

7. ./logs:/var/log/nginx permite el acceso a los registros de Nginx en el sistema mediante la asignación al directorio de registros de Nginx en el contenedor.

8. La configuración del registro de Docker se almacena en /etc/docker/registry/config.yml archivo en el contenedor, y lo hemos asignado a config.yml archivo en el directorio actual, que crearemos en el siguiente paso.

Configurar autenticación

Para configurar la autenticación HTTP, debe instalar httpd-tools paquete.

$ sudo dnf install httpd-tools

Cree el archivo de contraseña en ~/docker-registry/auth directorio.

$ htpasswd -Bc ~/docker-registry/auth/nginx.htpasswd user1
New password:
Re-type new password:
Adding password for user user1

El -c indica al comando que cree un nuevo archivo y -B flag es usar el algoritmo bcrypt compatible con Docker. Reemplazar user1 con un nombre de usuario de su elección.

Si desea agregar más usuarios, ejecute el comando nuevamente, pero sin -c bandera.

$ htpasswd -B ~/docker-registry/auth/registry.password user2

Ahora, el archivo se asignará al contenedor de registro para la autenticación.

Paso 4:instalar SSL

Para instalar un certificado SSL usando Let's Encrypt, necesitamos descargar la herramienta Certbot, que está disponible en el repositorio de Epel.

Instale el repositorio EPEL y Certbot.

$ sudo dnf install epel-release 
$ sudo dnf install certbot

Genere un certificado SSL.

$ sudo certbot certonly --standalone --agree-tos --no-eff-email --staple-ocsp --preferred-challenges http -m [email protected] -d registry.example.com

El comando anterior descargará un certificado en /etc/letsencrypt/live/registry.example.com directorio en su servidor.

Generar un grupo Diffie-Hellman certificado.

$ sudo openssl dhparam -out /etc/ssl/certs/dhparam.pem 4096

Pruebe la renovación del certificado.

$ sudo certbot renew --dry-run

Si el simulacro tiene éxito, significa que sus certificados se renovarán automáticamente.

Copiar el archivo Dhparam al contenedor

Copie el grupo Diffie-Hellman certificado para ~/docker-registry/auth directorio, que se asignará al contenedor.

$ sudo cp /etc/ssl/certs/dhparam.pem ~/docker-registry/auth

Paso 5:configurar Nginx

El siguiente paso consiste en configurar el servidor Nginx como un proxy front-end para el servidor de registro de Docker. El registro de Docker viene con un servidor incorporado que opera en el puerto 5000. Lo pondremos detrás de Nginx.

Cree y abra el archivo ~/docker-registry/auth/nginx.conf para editar.

$ sudo nano ~/docker-registry/auth/nginx.conf

Pegue el siguiente código en él.

events {
    worker_connections  1024;
}

http {

  upstream docker-registry {
    server registry:5000;
  }

  ## Set a variable to help us decide if we need to add the
  ## 'Docker-Distribution-Api-Version' header.
  ## The registry always sets this header.
  ## In the case of nginx performing auth, the header is unset
  ## since nginx is auth-ing before proxying.
  map $upstream_http_docker_distribution_api_version $docker_distribution_api_version {
    '' 'registry/2.0';
  }

  server {
    listen 443 ssl http2;
    server_name registry.example.com;

    # SSL
    ssl_certificate /etc/letsencrypt/live/registry.example.com/fullchain.pem;
    ssl_certificate_key /etc/letsencrypt/live/registry.example.com/privkey.pem;
    ssl_trusted_certificate /etc/letsencrypt/live/registry.example.com/chain.pem;

    access_log  /var/log/nginx/registry.access.log;
    error_log   /var/log/nginx/registry.error.log;

    # Recommendations from https://raymii.org/s/tutorials/Strong_SSL_Security_On_nginx.html
    ssl_protocols TLSv1.2 TLSv1.3;
    ssl_ciphers ECDHE-ECDSA-AES128-GCM-SHA256:ECDHE-RSA-AES128-GCM-SHA256:ECDHE-ECDSA-AES256-GCM-SHA384:ECDHE-RSA-AES256-GCM-SHA384:ECDHE-ECDSA-CHACHA20-POLY1305:ECDHE-RSA-CHACHA20-POLY1305:DHE-RSA-AES128-GCM-SHA256:DHE-RSA-AES256-GCM-SHA384;
    ssl_prefer_server_ciphers on;
    ssl_ecdh_curve X25519:prime256v1:secp384r1:secp521r1;
    ssl_session_cache shared:SSL:10m;
    ssl_dhparam /etc/nginx.d/conf.d/dhparam.pem;
    resolver 8.8.8.8;

    # disable any limits to avoid HTTP 413 for large image uploads
    client_max_body_size 0;

    # required to avoid HTTP 411: see Issue #1486 (https://github.com/moby/moby/issues/1486)
    chunked_transfer_encoding on;

    location /v2/ {
      # Do not allow connections from docker 1.5 and earlier
      # docker pre-1.6.0 did not properly set the user agent on ping, catch "Go *" user agents
      if ($http_user_agent ~ "^(docker\/1\.(3|4|5(?!\.[0-9]-dev))|Go ).*$" ) {
        return 404;
      }

      # To add basic authentication to v2 use auth_basic setting.
      auth_basic "Registry realm";
      auth_basic_user_file /etc/nginx/conf.d/nginx.htpasswd;

      ## If $docker_distribution_api_version is empty, the header is not added.
      ## See the map directive above where this variable is defined.
      add_header 'Docker-Distribution-Api-Version' $docker_distribution_api_version always;

      proxy_pass                          http://docker-registry;
      proxy_set_header  Host              $http_host;   # required for docker client's sake
      proxy_set_header  X-Real-IP         $remote_addr; # pass on real client's IP
      proxy_set_header  X-Forwarded-For   $proxy_add_x_forwarded_for;
      proxy_set_header  X-Forwarded-Proto $scheme;
      proxy_read_timeout                  900;
    }
  }
}

Guarde el archivo presionando Ctrl + X e ingresando Y cuando se le solicite una vez terminado.

Configure SELinux para permitir conexiones de red para el registro privado de Docker.

$ sudo setsebool -P httpd_can_network_connect on

Paso 6:iniciar el registro de Docker

Cambie al directorio del Registro de Docker.

$ cd ~/docker-registry

Inicie el contenedor docker.

$ docker-compose up -d

Consulta el estado de los contenedores.

$ docker ps
CONTAINER ID   IMAGE          COMMAND                  CREATED         STATUS         PORTS                                           NAMES
88d6addc1687   nginx:alpine   "/docker-entrypoint.…"   5 minutes ago   Up 5 minutes   80/tcp, 0.0.0.0:443->443/tcp, :::443->443/tcp   docker-registry_nginx_1
2b112edc1c72   registry:2     "/entrypoint.sh /etc…"   5 minutes ago   Up 5 minutes   5000/tcp                                        docker-registry_registry_1

Inicie sesión en el registro de Docker.

$ docker login -u=testuser -p=testpassword https://registry.example.com

También puede abrir la URL https://registry.example.com/v2/ en su navegador, y le pedirá un nombre de usuario y una contraseña. Deberías ver una página vacía con {} en él.

Puede verificar la URL en la terminal usando curl .

$ curl -u testuser -X GET https://registry.nspeaks.xyz/v2/
Enter host password for user 'testuser':
{}

Descargue la última imagen acoplable de Ubuntu.

$ docker pull ubuntu:latest

Etiquete esta imagen para el registro privado.

$ docker tag ubuntu:latest registry.example.com/ubuntu2004

Empuje la imagen al registro.

$ docker push registry.example.com/ubuntu2004

Pruebe si el impulso ha sido exitoso.

$ curl -u testuser -X GET https://registry.nspeaks.xyz/v2/_catalog
Enter host password for user 'testuser':
{"repositories":["ubuntu2004"]}

Ingrese su contraseña de autenticación de Nginx cuando se le solicite y verá la lista de repositorios disponibles a través del registro.

Consulte la lista de imágenes de Docker actualmente disponibles para su uso.

$ docker images
REPOSITORY                            TAG       IMAGE ID       CREATED       SIZE
registry                              2         d3241e050fc9   5 days ago    24.2MB
nginx                                 alpine    53722defe627   5 days ago    23.4MB
httpd                                 2         118b6abfbf55   5 days ago    144MB
ubuntu                                latest    ff0fea8310f3   2 weeks ago   72.8MB
registry.nspeaks.xyz/ubuntu2004       latest    ff0fea8310f3   2 weeks ago   72.8MB

Paso 7:acceda y use el registro de Docker desde la máquina cliente

Inicie sesión en su cliente-servidor. En el paso 1, instalamos Docker en la máquina cliente.

Inicie sesión en el registro privado de Docker desde la máquina cliente.

$ docker login -u=testuser -p=testpassword https://registry.example.com

Extraiga la imagen de Ubuntu del registro.

$ docker pull registry.example.com/ubuntu2004

Enumere todas las imágenes en su máquina cliente.

$ docker images
REPOSITORY                        TAG        IMAGE ID       CREATED         SIZE
registry.nspeaks.xyz/ubuntu2004   latest     ff0fea8310f3   2 weeks ago     72.8MB

Cree e inicie un contenedor utilizando la imagen descargada.

$ docker run -it registry.example.com/ubuntu2004 /bin/bash

Iniciará sesión en el Shell dentro del contenedor de Ubuntu.

[email protected]:

Ejecute el siguiente comando para comprobar la versión de Linux.

[email protected]$ cat /etc/os-release
NAME="Ubuntu"
VERSION="20.04.4 LTS (Focal Fossa)"
ID=ubuntu
ID_LIKE=debian
PRETTY_NAME="Ubuntu 20.04.4 LTS"
VERSION_ID="20.04"
HOME_URL="https://www.ubuntu.com/"
SUPPORT_URL="https://help.ubuntu.com/"
BUG_REPORT_URL="https://bugs.launchpad.net/ubuntu/"
PRIVACY_POLICY_URL="https://www.ubuntu.com/legal/terms-and-policies/privacy-policy"
VERSION_CODENAME=focal
UBUNTU_CODENAME=focal

Ahora, puede comenzar a usar su registro de Docker desde sus máquinas cliente.

Conclusión

Esto concluye nuestro tutorial sobre la configuración de un registro Docker privado en un servidor basado en Rocky Linux 8 que utiliza Amazon S3 como almacenamiento. Si tiene alguna pregunta, publíquela en los comentarios a continuación.