Docker – Registry avec GitLab

La registry est un dépôt d’images docker. Son utilisation est centrale dans l’architecture que je veux metttre en place comme indiqué dans Docker – un pas vers la registry. Il restait le choix d’utiliser Gitlab en tant que Registry ou bien l’implementation conteneur registry de docker même.

Sauvegarde et sécurité

Le registry sera un élément de l’infrastructure et en tant que tel il devra être sauvegardé. Or le service Gitlab est déjà defini avec un mapping vers le systèmes de fichier hôte. Sauvegarder ce montage permet de sauvegarder toutes les données de Gitlab: sources et registry !

De plus l’utilisation du registery impose de s’y connecter en HTTPS. Le client docker (docker CLI) est configuré ainsi par défaut. Je vais garder ce paramétrage qui sera fort utile dans le cas où je voudrais déplacer mon registry ailleur que sur localhost.

Il faut donc mettre en place un frontal pour faire le TLS, or mon service gitlab est déjà dernier un proxy SSL.

Enfin mon besoin de limiter les droits des accès de la production et de la préprod en lecture au registry et dépôt de source est déjà pris en charge par des mécanismes de clé et de jeton de déploiement.

Toutes ces considérations me font choisir l’utilisation du registry intégré à Gitlab.

Mise en oeuvre

Sa mise en oeuvre est très simple. Le fichier docker-compose.yml devient:

version: "3.7"
services:

 web:
   image: 'gitlab/gitlab-ce:latest'
   restart: always
   hostname: 'gitlab.bressure.net'
   environment:
     GITLAB_OMNIBUS_CONFIG: |
       external_url '//gitlab.bressure.net'
       nginx['listen_port'] = 80
       nginx['listen_https'] = false

       registry_external_url '//registry.bressure.net'
       registry_nginx['listen_portex'] = 80
       registry_nginx['listen_https'] = false
       # Add any other gitlab.rb configuration here, each on its own line

       gitlab_rails['gitlab_shell_ssh_port'] = 2222
   ports:
      - '8080:80'    
      - '2222:22'
      
   volumes:
     - '/srv/gitlab/config:/etc/gitlab'
     - '/srv/gitlab/logs:/var/log/gitlab'
     - '/srv/gitlab/data:/var/opt/gitlab'

Il suffit déclarer l’url externe du registry pour que gitlab affiche le lien dans l’interface du projet. Voici le schéma d’architecture :

Il permet l’utilisation suivante:

  1. sur la machine hôte on développe avec un éditeur
  2. COMMIT en local
  3. exécute en local et dans le cas particulier qui me concerne on lance un conteneur dit de DEV en local
  4. on verifie le fonctionnement attendu (test)
  5. on pousse les source sur GitLab par un PUSH
  6. on pousse eventulement l’image dans le registry

On remarque la mise à disposition de la preprod et à la prod des livrables se fait par 2 biais selon le type de livrable:

  • repository Git (Gitlab) pour les applications afin d’obtenir leur composition en terme de services ie en terme d’images. Il s’agit concrètement récupérer les fichiers docker-compose.yml
  • registry docker (Gitlab) pour les images. Je fais finir par y arriver quand les images actuelles ne me suffiront plus…

CI /CD

On remarque que les étapes 3,4 et 6 pourraient être effectuées par l’Integration Continue (IC). En effet une fois poussée sur Gitlab, le code doit passer des tests. Si ces derniers sont concluants, un livrable doit être produit (jar, ear, image docker….) et dans la cas d’application on peut même déployer directement en preprod.

Cela ouvre la voie vers l’exploration de la construction.

A suivre dans le prochain billet

Docker – Un pas vers la registry

Dans l’article précédent Docker – le réseau je suis arrivé à la conclusion de mettre en place 2 VM hébergeant chacune une infrastructure de service complète. L’une devra être la copie de l’autre et servira d’étape de validation préproduction avant d’installer réellement en production.

Afin d’assurer la prédictibilité de le l’exécution, ces 2 VM ne devront faire aucune construction d’image mais utiliser des images pré-construites mises à disposition dans ce que Docker appelle une registry dont Docker Hub est un exemple.

Registry autohebergée

Dans le schéma ci-dessus Gitlab sert de dépôt Git mais les VM de prod et preprod ne devront pas s’en servir que pour rapatrier les définitions des applications (docker-compose.yml) et ces dernières ne devront pas comporter des instructions de construction d’images mais uniquement des references vers les images récupérées dans le registry privé.

Je ne sais pas encore comment interdire cela. Peut-être en mettant des controle lors du push des fichiers de docker-compose.yml et en interdisant aux machines de prod et preprod d’accéder aux répertoires autres que ceux des applications au sein du dépôt Git.

Automatisation des constructions

Gitlab est également une plateforme d’intégration continue et de déploiement continu. Je vais pouvoir m’en servir pour construire mes images docker et déployer les applications en preprod. En investiguant le sujet j’ai decouvert que Gitlab est aussi une registry… à voir si je passe tout sur Gitlab ou bien je garde le registry de docker.

La suite au prochain billet…