Configurer un registre Docker avec un certificat SSL auto-signé : Guide complet

Introduction

Docker est devenu un outil essentiel pour les développeurs et les équipes DevOps, permettant le déploiement et la gestion transparente d'applications conteneurisées. Lorsque vous travaillez avec un registre Docker privé, la sécurisation de la communication entre les clients Docker et le serveur de registre est cruciale pour protéger vos images de conteneurs.

Dans ce lab, vous apprendrez à configurer un registre Docker local et à le sécuriser à l'aide d'un certificat SSL auto-signé. Cette approche est parfaite pour les environnements de développement, les tests et les scénarios d'apprentissage où vous avez besoin d'un registre sécurisé sans acheter de certificat auprès d'une autorité de certification (CA - Certificate Authority) de confiance.

À la fin de ce tutoriel, vous disposerez d'un registre Docker fonctionnel qui utilise HTTPS pour une communication sécurisée, vous permettant de pousser et de tirer (push and pull) en toute sécurité des images Docker au sein de votre environnement de développement.

Configuration d'un registre Docker de base

Avant de sécuriser notre registre Docker avec SSL, comprenons d'abord ce qu'est un registre Docker et configurons un registre de base pour travailler avec.

Qu'est-ce qu'un registre Docker ?

Un registre Docker est un système de stockage et de distribution pour les images de conteneurs Docker. Il vous permet de :

Stocker vos images Docker dans un emplacement centralisé
Partager des images avec votre équipe ou votre organisation
Contrôler l'accès à vos images
Déployer des conteneurs à partir de vos images dans différents environnements

Docker Hub est le registre public le plus connu, mais pour de nombreuses organisations, disposer d'un registre privé est essentiel pour la sécurité, la performance et le contrôle.

Configuration d'un registre de base

Commençons par exécuter un registre Docker simple et non sécurisé :

Créez un répertoire pour stocker les données de notre registre :
```
mkdir -p ~/project/registry-data
```
Exécutez un registre Docker de base en utilisant l'image officielle :
```
docker run -d -p 5000:5000 --restart=always --name registry -v ~/project/registry-data:/var/lib/registry registry:2
```
Cette commande :
- Exécute le conteneur de registre en mode détaché (-d)
- Mappe le port 5000 sur votre hôte vers le port 5000 dans le conteneur
- Configure le conteneur pour qu'il redémarre automatiquement s'il s'arrête
- Nomme le conteneur "registry"
- Monte le répertoire que nous avons créé pour stocker les données du registre

Vérifiez que le registre est en cours d'exécution :

docker ps

Vous devriez voir une sortie similaire à :

CONTAINER ID   IMAGE        COMMAND                  CREATED         STATUS         PORTS                    NAMES
a7d8098de3a2   registry:2   "/entrypoint.sh /etc…"   5 seconds ago   Up 4 seconds   0.0.0.0:5000->5000/tcp   registry

Testez le registre en poussant une image d'exemple :

Tout d'abord, tirez (pull) une petite image :
```
docker pull hello-world
```
Taguez-la pour votre registre local :
```
docker tag hello-world localhost:5000/hello-world
```
Poussez-la vers votre registre :
```
docker push localhost:5000/hello-world
```
Vous devriez voir une sortie montrant l'image en cours de poussée vers votre registre.
Arrêtez le conteneur de registre avant de le sécuriser dans les étapes suivantes :
```
docker stop registry
docker rm registry
```

Ce registre de base fonctionne, mais présente une limitation importante : il utilise HTTP, qui n'est pas sécurisé. Les clients Docker refusent par défaut de pousser ou de tirer (push or pull) à partir de registres non sécurisés. Dans les étapes suivantes, nous sécuriserons notre registre avec SSL.

Génération d'un certificat SSL auto-signé

Maintenant que nous comprenons les bases du registre Docker, sécurisons-le en générant un certificat SSL auto-signé. Ce certificat permettra une communication HTTPS avec notre registre.

Qu'est-ce qu'un certificat auto-signé ?

Un certificat auto-signé est un certificat SSL qui n'est pas signé par une autorité de certification (CA - Certificate Authority) de confiance. Bien qu'ils ne soient pas adaptés aux environnements de production exposés à l'internet public, les certificats auto-signés sont parfaits pour le développement, les tests et les applications internes.

Générer le certificat et la clé

Nous utiliserons OpenSSL, une boîte à outils de cryptographie largement utilisée, pour créer notre certificat :

Créez un répertoire pour stocker nos certificats :

mkdir -p ~/project/registry-certs
cd ~/project/registry-certs

Générez une clé privée :
```
openssl genrsa -out registry.key 2048
```
Cette commande génère une clé privée RSA de 2048 bits. Vous ne devriez voir aucune sortie si elle réussit.

Créez une demande de signature de certificat (CSR - Certificate Signing Request) en utilisant la clé privée :

openssl req -new -key registry.key -out registry.csr

Vous serez invité à saisir des informations qui seront incluses dans votre certificat :

Country Name (2 letter code) [AU]:US
State or Province Name (full name) [Some-State]:California
Locality Name (eg, city) []:San Francisco
Organization Name (eg, company) [Internet Widgits Pty Ltd]:Example Company
Organizational Unit Name (eg, section) []:IT
Common Name (e.g. server FQDN or YOUR name) []:localhost
Email Address []:[email protected]

Remarque : Pour Common Name, entrez localhost puisque nous nous connecterons au registre sur notre machine locale.

Il vous sera également demandé :

Please enter the following 'extra' attributes
to be sent with your certificate request
A challenge password []:
An optional company name []:

Vous pouvez laisser ces champs vides en appuyant sur Entrée.

Générez le certificat auto-signé en utilisant le CSR :

openssl x509 -req -days 365 -in registry.csr -signkey registry.key -out registry.crt

Cette commande crée un certificat auto-signé valable 365 jours.

Vous devriez voir une sortie similaire à :

Signature ok
subject=C = US, ST = California, L = San Francisco, O = Example Company, OU = IT, CN = localhost, emailAddress = [email protected]
Getting Private key

Vérifiez que les fichiers de certificat et de clé ont été créés :

ls -l

Vous devriez voir trois fichiers :

total 12
-rw-r--r-- 1 labex labex 1220 [date] registry.crt
-rw-r--r-- 1 labex labex 1054 [date] registry.csr
-rw-r--r-- 1 labex labex 1679 [date] registry.key

Nous avons maintenant les fichiers nécessaires pour sécuriser notre registre Docker. Dans l'étape suivante, nous configurerons notre registre pour qu'il utilise ce certificat pour la communication HTTPS.

Configuration du registre Docker avec le certificat SSL

Maintenant que nous avons notre certificat auto-signé, nous pouvons configurer notre registre Docker pour qu'il utilise SSL pour une communication sécurisée.

Configuration du registre sécurisé

Tout d'abord, créons un fichier de configuration simple pour notre registre. Ce fichier spécifiera les paramètres HTTPS :
```
mkdir -p ~/project/registry-config
cd ~/project/registry-config
nano config.yml
```
Ajoutez la configuration suivante au fichier :
```
version: 0.1
storage:
  filesystem:
    rootdirectory: /var/lib/registry
http:
  addr: 0.0.0.0:5000
  tls:
    certificate: /certs/registry.crt
    key: /certs/registry.key
```
Cette configuration indique au registre de :
- Utiliser le système de fichiers pour le stockage
- Écouter sur toutes les interfaces sur le port 5000
- Utiliser TLS (HTTPS) avec notre certificat et notre clé
Enregistrez et quittez en appuyant sur Ctrl+X, puis Y, puis Entrée.
Exécutons maintenant notre registre avec le certificat SSL :
```
docker run -d -p 5000:5000 --restart=always --name registry \
  -v ~/project/registry-data:/var/lib/registry \
  -v ~/project/registry-certs:/certs \
  -v ~/project/registry-config/config.yml:/etc/docker/registry/config.yml \
  registry:2
```
Cette commande :
- Monte notre répertoire de certificats et de clés
- Monte notre fichier de configuration
- Utilise le même répertoire de données que nous avons créé précédemment
Vérifiez que le registre est en cours d'exécution :
```
docker ps
```
Vous devriez voir une sortie indiquant que le conteneur du registre est en cours d'exécution.

Configuration du client Docker pour faire confiance au certificat

Par défaut, les clients Docker ne font pas confiance aux certificats auto-signés. Nous devons dire à Docker de faire confiance à notre certificat :

Créez un répertoire pour que Docker stocke les certificats de confiance :
```
sudo mkdir -p /etc/docker/certs.d/localhost:5000
```

Copiez notre certificat dans ce répertoire :

sudo cp ~/project/registry-certs/registry.crt /etc/docker/certs.d/localhost:5000/ca.crt

Redémarrez le service Docker pour prendre en compte les modifications :
```
sudo systemctl restart docker
```
Cela peut prendre quelques secondes.
Puisque le redémarrage de Docker arrêtera notre conteneur de registre, redémarrons-le :
```
docker start registry
```
Vérifiez à nouveau que le registre est en cours d'exécution :
```
docker ps
```

Maintenant, notre registre Docker est configuré pour utiliser HTTPS avec notre certificat auto-signé, et notre client Docker est configuré pour faire confiance à ce certificat lors de la connexion à localhost:5000.

Test du registre Docker sécurisé

Maintenant que notre registre Docker est en cours d'exécution avec SSL, testons-le en poussant et en tirant des images. Cela confirmera que tout fonctionne correctement.

Test avec une image d'exemple

Tout d'abord, tirons une image d'exemple à utiliser pour les tests :
```
docker pull alpine:latest
```
Vous devriez voir une sortie montrant Docker en train de télécharger l'image Alpine Linux.
Taguez l'image pour notre registre sécurisé :
```
docker tag alpine:latest localhost:5000/alpine:latest
```
Cette commande crée un nouveau tag qui pointe vers notre registre local.

Poussez l'image vers notre registre sécurisé :

docker push localhost:5000/alpine:latest

Vous devriez voir une sortie montrant les couches d'images en cours de poussée vers votre registre :

The push refers to repository [localhost:5000/alpine]
213ec9aee27d: Pushed
latest: digest: sha256:69e70a79f2d41ab5d637de98c1e0b055206ba40a8145e7bddb55ccc04e13cf8f size: 528

Supprimez l'image locale pour vous assurer que nous tirons du registre :
```
docker rmi localhost:5000/alpine:latest
docker rmi alpine:latest
```

Tirez l'image de notre registre sécurisé :

docker pull localhost:5000/alpine:latest

Vous devriez voir une sortie montrant Docker en train de télécharger l'image depuis votre registre :

latest: Pulling from alpine
213ec9aee27d: Pull complete
Digest: sha256:69e70a79f2d41ab5d637de98c1e0b055206ba40a8145e7bddb55ccc04e13cf8f
Status: Downloaded newer image for localhost:5000/alpine:latest
localhost:5000/alpine:latest

Vérification du contenu du registre

Examinons le contenu de notre registre en utilisant l'API Docker Registry :

Listez tous les référentiels dans le registre :
```
curl -X GET https://localhost:5000/v2/_catalog --cacert ~/project/registry-certs/registry.crt
```
Vous devriez voir une sortie comme :
```
{ "repositories": ["alpine", "hello-world"] }
```
Cela montre toutes les images que nous avons poussées vers notre registre.

Listez tous les tags pour le référentiel alpine :

curl -X GET https://localhost:5000/v2/alpine/tags/list --cacert ~/project/registry-certs/registry.crt

Vous devriez voir une sortie comme :

{ "name": "alpine", "tags": ["latest"] }

Comprendre ce que nous avons accompli

Passons en revue ce que nous avons fait :

Mise en place d'un registre Docker avec HTTPS en utilisant un certificat SSL auto-signé
Configuration de notre client Docker pour faire confiance à ce certificat
Poussée et tirage réussis d'images vers et depuis notre registre sécurisé

Cette configuration fournit :

Communication chiffrée : Toutes les données transférées entre le client Docker et le registre sont chiffrées.
Fondation d'authentification : SSL est la première étape vers la mise en œuvre de l'authentification.
Compatibilité du client Docker : Les clients Docker nécessitent HTTPS par défaut pour les registres non-localhost.

Vous pouvez maintenant utiliser ce registre sécurisé pour vos besoins de développement et de test. Pour les environnements de production, vous utiliseriez généralement un certificat d'une autorité de certification (CA - Certificate Authority) de confiance au lieu d'un certificat auto-signé.

Résumé

Félicitations ! Vous avez réussi à configurer un registre Docker sécurisé en utilisant un certificat SSL auto-signé. Voici ce que vous avez accompli :

Mise en place d'un registre Docker de base et compréhension de son objectif et de ses fonctionnalités
Génération d'un certificat SSL auto-signé pour sécuriser votre registre
Configuration du registre Docker pour utiliser HTTPS avec votre certificat
Configuration de votre client Docker pour faire confiance au certificat auto-signé
Test réussi du registre sécurisé en poussant et en tirant des images

Ces compétences vous permettent de créer des registres privés sécurisés pour vos environnements de développement et de test. Les registres privés vous donnent le contrôle sur l'endroit où vos images Docker sont stockées et qui peut y accéder, tandis que le chiffrement SSL garantit que vos données restent sécurisées pendant la transmission.

Pour les environnements de production, vous utiliseriez généralement des certificats d'une autorité de certification (CA - Certificate Authority) de confiance, mais le processus de configuration serait similaire à ce que vous avez appris dans ce laboratoire.

Vous pouvez maintenant implémenter en toute confiance des registres Docker sécurisés dans vos propres projets et flux de travail de développement, améliorant ainsi la sécurité de vos applications conteneurisées.

Comment configurer un registre Docker pour utiliser un certificat SSL auto-signé