Cómo crear un registro Docker privado en Ubuntu Linux

¿Está buscando un lugar para almacenar de forma segura sus imágenes de Docker personalizadas para sus proyectos personales o utilizarlas dentro de su organización? ¿O tal vez un sistema centralizado para administrar sus procesos de implementación e integración continua? ¿Un lugar donde pueda extraer y cargar sus imágenes personalizadas para su aplicación a voluntad y mejorar la tasa de implementación?

¡No busque más! ¡Un registro privado de Docker hace que todo eso sea posible! Este tutorial paso a paso lo guiará en la creación de su propio registro Docker privado. ¡Sumérgete para empezar!

Requisitos previos

Para seguir este tutorial, asegúrese de tener lo siguiente:

• Dos Ubuntu 20.04 LTS dispositivos. Uno alojará el registro de Docker y el otro actuará como una máquina cliente para enviar solicitudes a su registro de Docker.

• NGINX solo se requiere en la máquina host para configurar el cifrado SSL y la autenticación HTTP.
• Un nombre de dominio registrado. NGINX enrutará el tráfico a su nombre de dominio registrado a su registro de Docker que se ejecuta en un contenedor.
• Necesita Docker tanto en el host como en el equipo cliente para este tutorial. La instalación predeterminada es suficiente.

• Docker-compose en la máquina host de registro de Docker para configurar e iniciar los componentes de su registro de Docker. Relacionado:Todo lo que necesita saber sobre el uso de Docker Compose

Configurando el registro de Docker

El primer paso que debe realizar es configurar el registro de Docker en el dispositivo host, que se proporciona como una imagen gratuita en Docker Hub.

En lugar de limitarse a emitir comandos de Docker para realizar esta tarea, creará un docker-compose.yml expediente. El archivo utiliza el formato de archivo docker-compose y puede configurar los componentes necesarios para el registro de Docker con relativa facilidad.

Para continuar, abra su cliente SSH favorito y conéctese al dispositivo que será el servidor de registro.

1. En el /inicio directorio, cree un directorio llamado docker-registry con el mkdir comando:

# Creating working directory
mkdir docker-registry

2. Navegue hasta el docker-registry directorio:

# Navigate to the working directory
cd ~/docker-registry

3. Dentro del docker-registry directorio, cree un subdirectorio llamado datos . Dentro de los datos El directorio es donde el registro de Docker almacenará las imágenes de Docker. Los datos El directorio actúa como un sistema de archivos para el registro de Docker para conservar las imágenes de Docker.

# Create filesystem to persist data
mkdir data

4. Dentro del docker-registry directorio, cree un docker-compose.yml archivo:

# Create the docker-compose file
nano docker-compose.yml 

Encontrará configuraciones para establecer el registro en el archivo recién creado. Entre las configuraciones, notará:

• Establece el registry servicio con el registry:latest imagen con el latest etiqueta.
• Establece la política de reinicio para el registry servicio a always . Siempre que el motor de Docker se esté ejecutando, el registry el servicio siempre se reiniciará cuando se detenga.
• Los ports sección mapea el puerto 5000 en el contenedor de registro al puerto 5000 en la máquina host.
• El registry servicio en el environment establece la variable de entorno REGISTRY_STORAGE_FILESYSTEM_ROOTDIRECTORY a los datos directorio creado anteriormente.
• Docker requiere un volumen para conservar las imágenes de Docker en el registry envase. Agregará los volumes objeto para mapear los /datos directorio en la máquina host al /data directorio en el contenedor.

El mapeo almacenará los datos en el sistema de archivos de la máquina host en lugar de dentro del contenedor. Dado que Docker ahora almacena los datos en la máquina host, se pueden realizar copias de seguridad, migrar, cifrar o reemplazar.

A continuación, puede ver la configuración completa de YAML para los componentes necesarios para iniciar y ejecutar el registro de Docker. Copie el código YAML a continuación y péguelo en docker-compose.yml archivo que creaste y guárdalo con CTRL + S y presiona CTRL + X para salir:

version: '3.3' 
services:
  registry:
    image: registry:latest 
		restart: always
    ports:
    - "5000:5000"
    environment:
      REGISTRY_STORAGE_FILESYSTEM_ROOTDIRECTORY: /data 
    volumes:
      - ./data:/data 

Docker-compose ejecuta múltiples contenedores como una sola aplicación. docker-compose.yml El archivo configura estos múltiples contenedores como parte de los servicios.

5. Ahora ejecute el archivo docker-compose y cree e inicie el registro de Docker:

# Start docker registry application
sudo docker-compose up

En el resultado del comando a continuación, puede ver el registro de Docker ejecutándose. Para cerrar la aplicación, presiona CTRL + C .

Configuración de NGINX

Ahora que tiene configurado el registro de Docker, es hora de configurar NGINX en la máquina host. NGINX reenviará el tráfico desde los dispositivos cliente al registro de Docker. Para este tutorial, reenviará el tráfico a través de un nombre de dominio. Siga leyendo para abordar este paso.

Inicialmente, deberá configurar el reenvío de puertos NGINX para su dominio a través de /etc/nginx/sites-disponible/your_domain_name archivo.

1. Cree el archivo con el siguiente comando:

# Creating configuration for your domain
sudo nano /etc/nginx/sites-available/your_domain_name 

Encontrará muchas referencias a your_domain_name en las siguientes secciones . Esta cadena es un marcador de posición. No olvide reemplazarlo con un nombre de dominio de su propiedad cuando pruebe los comandos usted mismo. En los ejemplos Registry.joeshiett.xyz es el nombre de dominio seleccionado.

2. Copie la siguiente configuración de NGINX y agréguela a your_domain_name archivo que creaste:

server {
	listen 80;
  # Replace your_domain_name with your domain name
  server_name your_domain_name;

    location / {
      # 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;
      }

      proxy_pass                          http://localhost:5000;
      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;
    }
}

3. El reenvío de puertos aún no está completo. Primero debe adjuntar un enlace simbólico. Vinculará /etc/nginx/sites-disponible/your_domain_name archivo de configuración a /etc/nginx/sites-enabled/. El comando completo sigue:

cd /etc/nginx/sites-enabled/ && sudo ln -s /etc/nginx/sites-available/your_domain_name .

4. Reinicie el servicio NGINX después de crear el enlace simbólico:

# Restarting Nginx service
sudo systemctl restart nginx 

Abra el navegador en su dispositivo cliente y vaya a https://your_domain_name/v2/ para acceder a v2 punto final, la API HTTP de Docker.

La siguiente imagen muestra el resultado esperado del terminal host después de navegar al enlace. La imagen también muestra que el navegador envió un GET solicitud a la API HTTP de Docker a través de v2 punto final

Después de navegar a v2 punto final a través del enlace, un objeto JSON vacío:{} – se mostrará en la ventana del navegador.

Configuración del tamaño de carga del archivo NGINX

El límite de tamaño de carga predeterminado de NGINX es 1m , donde m significa megabyte. El límite predeterminado no es suficiente para cargar imágenes de Docker en su registro. Para cambiar este valor, edite nginx.conf, por lo que NGINX acepta cargas de archivos grandes.

1. Una vez más, inicie sesión en la máquina host.

2. Edite el /etc/nginx/nginx.conf archivo:

3. Bajo el http sección en nginx.conf archivo, agregue la siguiente línea para aumentar el tamaño de carga para acomodar 8192 megabytes y guarde el archivo:

client_max_body_size 8192m;

La configuración se verá algo así:

Configuración de SSL

Se requiere un certificado SSL para asegurar la conexión al registro de Docker. Para agregar un certificado SSL, debe instalar Certbot en el host de registro.

Puede instalar Certbot con el administrador de paquetes instantáneos. El administrador de paquetes Snap ya viene preinstalado en Ubuntu 20.04.

1. Para instalar Certbot, ejecute el siguiente comando en su máquina host:

# Install certbot using the snap package manager
sudo snap install --classic certbot

2. Agregue Certbot a PATH para que los comandos de Certbot puedan funcionar creando un enlace simbólico:

# Attaching certbot to PATH
sudo ln -s /snap/bin/certbot /usr/bin/certbot

3. Ejecute este comando para obtener un certificado y hacer que Certbot edite su configuración de NGINX automáticamente, y también habilite el acceso HTTPS para su dominio:

# Creating a certificate and enabling HTTPS access
sudo certbot --nginx

Certbot modificará el your_domain_name archivo de configuración en /etc/nginx/sites-enabled/ directorio y aplique un certificado SSL a su nombre de dominio.

La siguiente imagen muestra cuál es la configuración final para su /etc/nginx/sites-enabled/your_domain_name el archivo se verá después de que Certbot haya aplicado los certificados.

Si navega a https://your_domain_name/ , encontrará que es seguro con el certificado de Certbot.

Configurar la autenticación HTTP para Docker Registry

Siempre es una buena idea tener buenas prácticas de seguridad. Por lo tanto, protegerá su registro de Docker y restringirá el acceso solo a usted y a otros usuarios que desee agregar. Utilizará la autenticación HTTP, proporcionada por HTTP Basic Auth .

1. La autenticación HTTP requiere un htpasswd archivo con su nombre de usuario y contraseña. Para crear el htpasswd autenticación, deberá instalar apache2-utils paquete:

# Installing apache2-utils package
sudo apt-get install apache2-utils

2. Después de instalar apache2-utils crear un registry.credentials archivo en /etc/nginx directorio con el httpasswd dominio. Agregue un nombre de usuario preferido reemplazando your_username en el comando de abajo. A continuación, agregue una contraseña de su preferencia cuando se le solicite. El comando completo y su salida están a continuación.

# Creating to creating auth credentials
sudo htpasswd -c /etc/nginx/registry.credentials your_username

3. Después de crear el registry.credentials archivo, navegue a su archivo de configuración NGINX para su registro de Docker en /etc/nginx/sites-disponible/your_domain_name . Agregue el siguiente texto al archivo de configuración de NGINX en el server sección:

server {
	...
	...
	location / {
			...
			auth_basic            "Basic Auth";
      auth_basic_user_file  "/etc/nginx/registry.credentials";
			...
	}
}

4. Reinicie NGINX una vez más y vuelva a aplicar las configuraciones con el siguiente comando:

# Restarting nginx
sudo systemctl restart nginx

La siguiente imagen muestra que cuando intenta acceder a https://your_domain_name/ en su navegador, se le pedirá que ingrese su nombre de usuario y contraseña. Para este tutorial, el registro de Docker se ejecuta en un subdominio registry.joeshiett.xyz , con SSL habilitado.

Enviar imagen a repositorio privado de Docker

Ahora que su registro de Docker se está ejecutando y es capaz de aceptar cargas de archivos más grandes, le enviará una imagen. Para enviar una imagen a su registro de Docker, debe acceder a su máquina cliente.

Si no tiene una imagen de Docker almacenada localmente en su máquina cliente, puede obtener una gratuita de Docker Hub.

1. Ejecute el siguiente comando para extraer una imagen de Alpine Linux desde Docker hub, establezca el nombre de la imagen como test-image y ejecute el contenedor en el shell interactivo:

# Pull and run Alpine container
sudo docker run --name test-image -it alpine:latest /bin/sh

2. Una vez dentro del contenedor Alpine, cree un archivo llamado TEST . Este archivo será la confirmación de que la imagen que extraerá de su registro de Docker es la que está modificando ahora:

# create a file called TEST
touch /TEST

3. Salga del shell interactivo escribiendo exit en su terminal.

4. Ahora cree una imagen Docker desde el contenedor Alpine Docker llamado test-image , acabas de personalizar:

# Creating Docker image
sudo docker commit test-image your_domain_name/test-image:latest

La imagen de Alpine que extrajo y personalizó anteriormente ahora está disponible localmente con un repositorio llamado your_domain_name/test-image y etiquetar latest .

5. Para enviar su imagen recién creada a su registro de Docker, inicie sesión en su registro de Docker con el siguiente comando:

# Login to Docker registry
sudo docker login https://your_domain_name 

Se le pedirá que ingrese su nombre de usuario y contraseña que configuró en la sección anterior. La salida será:

...
Login Succeeded
...

6. Después de iniciar sesión, inserte la imagen etiquetada en su repositorio de Docker:# Pushing docker image sudo docker push your_domain_name/test-image:latest

# Pushing docker image
sudo docker push your_domain_name/test-image:latest

La salida del comando se verá así:

Extraer imagen del repositorio Docker privado

Ahora que ha enviado con éxito su imagen de Docker a su repositorio privado de Docker, es hora de extraer la imagen que acaba de enviar.

1. En primer lugar, debe iniciar sesión en su repositorio privado de Docker:# Login to Docker registry sudo docker login https://your_domain_name

# Login to Docker registry
sudo docker login https://your_domain_name 

2. Después de iniciar sesión, extraerá la imagen de Docker creada anteriormente:

# Pull Docker image from Docker registry
sudo docker pull your_domain_name/test-image

En la imagen a continuación, puede ver que Docker extrae la test-image exitosamente.

3. Es hora de ejecutar un shell interactivo:

sudo docker run -it your_domain_name/test-image /bin/sh

4. Mientras está en el shell interactivo, ejecute el siguiente comando:

ls

En la imagen a continuación, puede ver que la PRUEBA El archivo creado anteriormente está dentro del contenedor.

¡Ahora ha probado con éxito su registro de Docker y está listo para comenzar!

Conclusión

En este tutorial, creó su propio registro Docker privado. Ha instalado los requisitos previos necesarios; configurar la autenticación SSL y HTTP. Y finalmente empujaste y sacaste una imagen de tu registro.

Entonces, ¿qué paquetes planea enviar a su registro?