====== La Registry sous Docker ======

===== Créer sa propre Registry =====

==== Prérequis ====

Installer Docker compose :
  apt install apache2-utils

==== Préparation des dossiers et fichiers requis ====

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

==== Préparation de lancement des conteneur pour la Registry ====
 
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

==== Configuration du client Docker ====

:!: 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

==== Se connecter et pousser une image sur la Registry ====

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