La Registry sous Docker

Installer Docker compose :

apt install apache2-utils

On va créer une Registry délivrée via un serveur nginx.

Création des répertoire requis :

mkdir -p /mnt/registry/{nginx,auth}
cd registry/
mkdir -p nginx/{conf.d,ssl}

Aller dans :

cd nginx/conf.d/

Créer du fichier de configuration de la registry :

vim registry.conf

Insérer le contenu suivant :

upstream docker-registry {
    server registry:5000;
}

server {
    listen 80;
    server_name registry.local;
    return 301 https://registry.local$request_uri;
}

server {
    listen 443 ssl http2;
    server_name registry.local;

    ssl_certificate /etc/nginx/ssl/fullchain.pem;
    ssl_certificate_key /etc/nginx/ssl/privkey.pem;

    # Log files for Debug
    error_log  /var/log/nginx/error.log;
    access_log /var/log/nginx/access.log;

    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://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;
    }
}

Créer le fichier :

vim additional.conf

Ajouter le paramètre permettant à nginx de prendre en charge des fichiers jusqu'à 2Go

client_max_body_size 2G;

Créer le certificat SSL de notre registry :

cd /mnt/registry/nginx/ssl
openssl genrsa -out privkey.pem 2048
openssl req -new -sha256 -key /mnt/registry/nginx/ssl/privkey.pem -out ${HOME}/request.csr -subj "/C=FR/ST=Paris/L=Paris/O=Company/OU=IT Department/CN=registry.local"
openssl x509 -req -days 365 -in ${HOME}/request.csr -signkey /mnt/registry/nginx/ssl/privkey.pem -out /mnt/registry/nginx/ssl/fullchain.pem

Pour retreindre l'accès à la registry, nous allons créer un compte utilisateur :

cd /mnt/registry/auth/
htpasswd -Bc registry.passwd benoit

Créer un fichier Docker compose :

vim /mnt/registry/docker-compose.yml

Avec le contenu suivant :

version: '3'
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:
      - registrydata:/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:
  registrydata:
    driver: local

Quelques explications de la configuration :

• version : Indiquer la version Docker compose à utiliser.
• Registry → image : La registry sera un conteneur créé à partir de l'image registry:2 du Docker Hub.
• restart: always : Permet de s'assure de démarrer Docker Registry en tant que service dès que vous démarrez le système.

Lancer les conteneurs de registry :

cd /mnt/registry
docker compose up -d

Pour vérifier le fonctionnement :

docker ps
docker compose ps

A CORRIGER

Il faut autoriser le client à utiliser une registry avec un certificat non valide.

Récupérer l'IP du conteneur et l'enregistrement registry.local au fichier /etc/hosts :

REGIP=$(docker inspect -f {{.NetworkSettings.Networks.registry_mynet.IPAddress}} nginx)
echo "${REGIP} registry.local" >> /etc/hosts

Editer le fichier suivant :

vim /etc/docker/daemon.json

Et ajouter les lignes suivantes :

{
  "insecure-registries" : ["registry.local:443"]
}

Relancer le service Docker :

systemctl restart docker

Pour se connecter à la Registry :

docker login https://127.0.0.1/

Séquence et résultat :

Username: benoit
Password:
WARNING! Your password will be stored unencrypted in /root/.docker/config.json.
Configure a credential helper to remove this warning. See
https://docs.docker.com/engine/reference/commandline/login/#credentials-store

Login Succeeded

Avant de pousser une image, il faut la retagguer avec l'adresse de la registry 127.0.0.1 par exemple :

docker image tag httpd:latest 127.0.0.1/myhttpd:v1

Ensuite on peut la pousser

docker push 127.0.0.1/myhttpd:v1

Vérification :

curl -u benoit --insecure https://127.0.0.1/v2/_catalog

Résultat attendu :

Enter host password for user 'benoit':
{"repositories":["myhttpd"]}

ou

curl -u benoit --insecure https://127.0.0.1/v2/myhttpd/tags/list

Pour utiliser une image de notre Registry :

docker run -d 127.0.0.1/myhttpd:v1