Cómo configurar el registro privado de Docker en Ubuntu 20.04

Para un desarrollo de CI/CD sin problemas con la plataforma docker, considere usar un servidor de registro docker autohospedado. El registro de Docker es el repositorio donde puede almacenar sus imágenes de Docker y extraerlas para ejecutar aplicaciones en el servidor. Para una entrega más rápida y una infraestructura segura, se recomienda configurar su propio registro privado de docker para almacenar sus imágenes de docker y distribuirlas entre organizaciones. En este artículo, vamos a aprender cómo configurar el registro privado de docker en Ubuntu 20.04

requisitos previos

  • Cuenta de usuario con privilegios sudo
  • Un servidor para el registro de Docker
  • Nginx en el servidor de registro de Docker
  • Un servidor cliente
  • Docker y Docker-Compose en ambos servidores.

Registro Docker Privado

Docker Registry es una aplicación del lado del servidor que le permite almacenar sus imágenes acoplables localmente en una ubicación centralizada. Al configurar su propio servidor de registro de Docker, puede extraer y enviar imágenes de Docker sin tener que conectarse al concentrador de Docker, ahorrando ancho de banda y evitando amenazas de seguridad.

Leer también : Cómo instalar y usar Docker en Ubuntu 20.04/20.10

Antes de que empieces

Antes de comenzar, me aseguro de haber instalado Docker y Docker-Compose tanto en el servidor del cliente como en el servidor de registro local. Para verificar que ha instalado el software requerido, puede ejecutar los siguientes comandos para verificar la versión del software.

$ docker version

docker-versión-salida-linux

$ docker-compose version

docker-compose-versión-salida-linux

Además, debe asegurarse de que el servicio Docker se haya iniciado y esté configurado para habilitarse en el momento del arranque:

$ sudo systemctl start docker
$ sudo systemctl enable docker

Instalar y configurar el registro privado de Docker

Para configurar el registro privado de Docker, siga los pasos:

Crear directorios de registro

Configure su servidor que va a alojar un registro privado. Cree un nuevo directorio que almacenará todos los archivos de configuración necesarios.

Use el siguiente comando para crear un nuevo directorio de proyecto ‘mi registro’ y dos subdirectorios ‘nginx’ y ‘auth’. Puede tener su propia suposición para el nombre del proyecto.

$ mkdir -p my-registry/{nginx, auth}

Ahora navegue al directorio del proyecto y cree nuevos directorios dentro de nginx como:

$ cd my-registry/
$ mkdir -p nginx/{conf.d/, ssl}

Crear secuencias de comandos y servicios de Docker-Compose

Debe crear un nuevo script docker-compose.yml que defina la versión de docker-compose y los servicios necesarios para configurar un registro privado.

Cree un nuevo archivo «docker-compose.yml» dentro del directorio «my-registry» con el editor vi.

$ vi docker-compose.yml

Defina su servicio en el archivo docker-compose como:

services:
#Registry
  registry:
    image: registry:2
    restart: always
    ports:
    - "5000:5000"
    environment:
      REGISTRY_AUTH: htpasswd
      REGISTRY_AUTH_HTPASSWD_REALM: Registry-Realm
      REGISTRY_AUTH_HTPASSWD_PATH: /auth/registry.passwd
      REGISTRY_STORAGE_FILESYSTEM_ROOTDIRECTORY: /data
    volumes:
      - myregistrydata:/data
      - ./auth:/auth
    networks:
      - mynet

#Nginx Service
  nginx:
    image: nginx:alpine
    container_name: nginx
    restart: unless-stopped
    tty: true
    ports:
      - "80:80"
      - "443:443"
    volumes:
      - ./nginx/conf.d/:/etc/nginx/conf.d/
      - ./nginx/ssl/:/etc/nginx/ssl/
    networks:
      - mynet

#Docker Networks
networks:
  mynet:
    driver: bridge

#Volumes
volumes:
  myregistrydata:
    driver: local

Guarde y cierre el archivo

Configurar el reenvío de puertos nginx

Necesitamos crear una configuración de host virtual nginx para el servicio web nginx. Vaya al directorio nginx/conf.d/ creado en el paso anterior.

$ cd nginx/conf.d/

Ahora cree un archivo de host virtual nginx con su editor de texto. En este ejemplo, lo nombraré myregistry.conf. Puedes tener tu propia suposición.

$ vi myregistry.conf

Agrega los siguientes contenidos:

upstream docker-registry {
    server registry:5000;
}
server {
    listen 80;
    server_name registry.linuxtechi.com;
    return 301 https://registry.linuxtechi.com$request_uri;
}
server {
    listen 443 ssl http2;
    server_name registry.linuxtechi.com;
    ssl_certificate /etc/nginx/ssl/certificate.crt;
    ssl_certificate_key /etc/nginx/ssl/private.key;
    # Log files for Debug
    error_log  /var/log/nginx/error.log;
    access_log /var/log/nginx/access.log;
    location / {
        if ($http_user_agent ~ "^(docker/1.(3|4|5(?!.[0-9]-dev))|Go ).*$" )  {
            return 404;
        }
        proxy_pass                          http://docker-registry;
        proxy_set_header  Host              $http_host;
        proxy_set_header  X-Real-IP         $remote_addr;
        proxy_set_header  X-Forwarded-For   $proxy_add_x_forwarded_for;
        proxy_set_header  X-Forwarded-Proto $scheme;
        proxy_read_timeout                  900;
    }
}

Reemplace su nombre de dominio con el parámetro server_name y guarde el archivo.

Aumentar el tamaño de carga del archivo nginx

De forma predeterminada, nginx tiene un límite de 1 mb para cargar archivos. Como las imágenes de la ventana acoplable superan este límite, debe aumentar el tamaño de carga en el archivo de configuración de nginx. En este ejemplo, voy a crear un archivo de configuración de nginx adicional con un límite de carga de 2 GB.

Ir al directorio de configuración de nginx

$ cd myregistry/nginx/conf.d
$ vi additional.conf

Agregue la siguiente línea y guarde el archivo

client_max_body_size 2G;

Configurar certificado SSL y autenticación

Después de crear el archivo de configuración de nginx, ahora debemos configurar un certificado SSL. Debe tener un archivo de certificado SSL válido con una clave privada. Copie su archivo de certificado y clave privada en el directorio nginx/ssl como:

$ cd myregistry/nginx/ssl
$ cp /your-ssl-certificate-path/certificate.crt .
$ cp /your-private-key-path/private.key .

Si no tiene un certificado SSL comprado válido, puede generar su propio certificado SSL autofirmado. Recuerde que no se recomienda un certificado SSL autofirmado para entornos de producción. Para generar un certificado SSL autofirmado, ejecute el siguiente comando:

$ sudo openssl req -x509 -nodes -days 365 -newkey rsa:2048 -keyout 
 /etc/ssl/private/nginx-private.key -out /etc/ssl/certs/nginx-certificate.crt

Se le pedirá que envíe algunos detalles como código de país, nombre de dominio, identificación de correo electrónico. Complete los datos y continúe.

Ahora configure la autenticación básica como:

Ir al directorio de autenticación

$ cd auth

Solicite un nuevo archivo de contraseñas llamado registration.password para su usuario. En este ejemplo voy a usar el usuario linuxtechi.

$ htpasswd -Bc registry.password linuxtechi

Si obtiene el comando ‘htpasswd no encontrado’, ejecute el siguiente comando en su terminal e intente nuevamente.

$  sudo apt install apache2-utils -y

Escriba una contraseña segura e ingrese nuevamente para confirmar su contraseña. Ha agregado un usuario de autenticación básica para el registro de Docker.

Ejecutar Registro Docker

Has completado la configuración. Puede crear un registro usando el comando docker-compose.

Vaya al directorio, donde creamos el archivo docker-compose.yml

$ cd myregistry

Ahora ejecuta el siguiente comando:

$ docker-compose up -d

El registro de Docker ahora está activo, puede verificar los contenedores en ejecución usando el siguiente comando:

$ docker ps -a

Obtendrá el siguiente resultado:

docker-ps-a-comando-salida-linux

Tire de la imagen de Docker Hub a un registro privado

Para almacenar una imagen de Docker hub en un registro privado, use el comando docker pull para extraer imágenes de docker desde docker hub. En este ejemplo, voy a extraer la imagen acoplable de centos.

$ docker pull centos

Después de extraer con éxito las imágenes de Docker Hub, etiquete una imagen para etiquetarla para un registro privado.

En este ejemplo, voy a etiquetar las imágenes de centos como: registration.linuxtechi.com/linuxtechi-centos

$ etiqueta de imagen de la ventana acoplable [image name] registro.linuxtechi.com/[new-image-name]

Ejemplo:

$ docker images tag centos registry.linuxtechi.com/linuxtechi-centos

Para verificar si la imagen de la ventana acoplable está disponible localmente o no, ejecute el siguiente comando.

$ docker images

Empuje la imagen de la ventana acoplable al registro privado

Extrajo la imagen de la ventana acoplable del centro de la ventana acoplable y creó una etiqueta para el registro privado. Ahora necesita enviar la imagen de la ventana acoplable local al registro privado.

En primer lugar, inicie sesión en su registro privado con el siguiente comando:

$ docker login https://registry.linuxtechi.com/v2/

Use su propia URL de registro en lugar de ‘https://registry.linuxtechi.com’

Tu seras llamado por tu nombre de usuario y contraseña; obtendrá un mensaje de inicio de sesión exitoso como:

docker-login-private-registry-linux

Ahora puede enviar su imagen acoplable a un registro privado. Para empujar la imagen, ejecute el siguiente comando:

$ docker push registry.linuxtechi.com/linuxtechi-centos

Reemplace el nombre de su imagen después de ‘docker push’

Una vez que se completa la inserción, puede ir al navegador e ingresar la URL:

https://registry.linuxtechi.com/v2/_catalog

Reemplace registration.linuxtechi.com con su propia URL y proporcione autenticación básica. Encontrará la lista de repositorios como:

docker-private-registry-gui-linux

Extrayendo la imagen de la ventana acoplable del registro privado

Ha empujado su imagen acoplable local a su registro acoplable privado. De la misma manera, puede extraer imágenes de la ventana acoplable desde su registro privado de la ventana acoplable al servidor local.

Ejecute el siguiente comando para iniciar sesión en su servidor de registro privado.

$ docker login https://registry.linuxtechi.com

Reemplace registration.linuxtechi.com con su propia URL de registro privado y proporcione autenticación básica. Una vez que el inicio de sesión sea exitoso, ejecute el siguiente comando para extraer la imagen de la ventana acoplable del registro privado. En este ejemplo, voy a extraer la imagen de la ventana acoplable previamente insertada en el servidor local. Puede tener su propia suposición para el nombre de la imagen de la ventana acoplable.

$ docker pull registry.linuxtechi.com/linuxtechi-centos

Tendrás una salida similar a:

docker-pull-image-private-registry-linux

Conclusión:

En el artículo, aprendió cómo alojar su propio registro docker privado. También tiene una idea sobre cómo extraer imágenes del concentrador acoplable al servidor local, etiquetar la imagen y enviarla al registro privado. También aprendió cómo extraer imágenes acoplables del registro privado en el servidor local.

Leer también : Cómo instalar KVM en Ubuntu 20.04 LTS Server (Focal Fossa)

Entradas relacionadas

Deja una respuesta

Tu dirección de correo electrónico no será publicada. Los campos obligatorios están marcados con *