Secrets et ConfigMaps

Introduction

Dans un logiciel, intégrer directement dans le code de l’application des paramètres tels que des URL de bases de données ou des mots de passe est une mauvaise pratique. Les modifications deviennent plus difficiles et les risques de sécurité augmentent.

Kubernetes répond à ce problème avec deux objets :

ConfigMap : imaginez un panneau d’affichage public. Vous y épinglez des informations, comme « La couleur d’arrière-plan est bleue » ou « L’adresse de la base de données est 10.0.0.1 ». Tout le monde dans le bureau (les Pods) peut les consulter.
Secret : cet objet sert à stocker des valeurs sensibles, comme des mots de passe ou des jetons.

Cette séparation entre le code de l’application et la configuration d’exécution est un principe majeur de conception des plateformes, et pas seulement une fonctionnalité de Kubernetes.

Dans cet atelier, vous allez :

Écrire une note sur le panneau d’affichage (ConfigMap).
Ranger un mot de passe dans le coffre-fort (Secret).
Apprendre à un Pod à lire les deux.

Créer un ConfigMap

Commençons par créer un fichier de configuration pour un serveur web. Au lieu d’intégrer ce fichier dans l’image, nous allons le stocker dans un ConfigMap.

Cette méthode applique un principe plus général de conception des conteneurs : créer une image réutilisable, puis fournir la configuration propre à chaque environnement au moment de l’exécution. L’image est ainsi plus portable, car les environnements de développement, de préproduction et de production peuvent utiliser le même conteneur avec des paramètres différents.

Commencez par créer un fichier de configuration Nginx simple nommé nginx.conf :

echo 'events {} http { server { listen 80; location / { return 200 "Hello from ConfigMap!"; } } }' > nginx.conf

Créez maintenant un ConfigMap nommé nginx-config à partir de ce fichier. Le fichier est ainsi « épinglé » sur le panneau d’affichage du cluster Kubernetes.

kubectl create configmap nginx-config --from-file=nginx.conf

Vérifiez qu’il existe :

kubectl describe configmap nginx-config

Le contenu de votre fichier nginx.conf doit apparaître dans la section « Data ».

Créer un Secret

Stockons maintenant une donnée sensible. Un Secret fonctionne de manière similaire à un ConfigMap, mais Kubernetes le traite avec davantage de précautions : les données sont masquées dans le stockage.

Soyez précis sur ce point : un Secret est plus sûr que l’intégration de mots de passe directement dans des manifests ou des images, mais l’encodage en base64 ne constitue pas un véritable chiffrement. En production, la gestion des Secrets est souvent associée au chiffrement au repos, à des règles RBAC plus strictes et à des systèmes externes de gestion des secrets.

Créez un Secret nommé app-secret pour stocker un mot de passe fictif :

kubectl create secret generic app-secret --from-literal=password=SuperSecretPass123

Vérifiez qu’il existe :

kubectl get secret app-secret

Si vous affichez ses détails, le mot de passe n’apparaîtra pas directement. Il sera masqué et encodé.

kubectl get secret app-secret -o yaml

Remarquez que le champ password contient une suite de caractères apparemment aléatoires. Il s’agit d’un encodage base64, conçu pour éviter qu’une personne ne lise la valeur par-dessus votre épaule ou qu’elle ne s’affiche accidentellement dans des journaux.

Monter un ConfigMap comme fichier

Apprenons maintenant à un Pod à lire le panneau d’affichage.

La manière la plus courante d’utiliser un ConfigMap consiste à le monter comme un fichier. Il apparaît dans le conteneur comme un fichier classique sur le disque.

Cette approche fondée sur un fichier est utile lorsqu’une application attend déjà un fichier de configuration à un chemin précis. Kubernetes projette les données du ConfigMap dans le système de fichiers du conteneur, ce qui permet à l’application de continuer à utiliser son comportement habituel de lecture de fichiers.

Créez un fichier nommé pod-config.yaml :

nano pod-config.yaml

Collez le contenu suivant. Ce Pod monte le ConfigMap nginx-config dans /etc/nginx/nginx.conf.

apiVersion: v1
kind: Pod
metadata:
  name: config-pod
spec:
  containers:
    - name: nginx
      image: nginx:alpine
      volumeMounts:
        - name: config-volume
          mountPath: /etc/nginx/nginx.conf
          subPath: nginx.conf
  volumes:
    - name: config-volume
      configMap:
        name: nginx-config

Enregistrez le fichier et quittez l’éditeur (Ctrl+X, Y, Enter).

Appliquez cette définition :

kubectl apply -f pod-config.yaml

Attendez quelques secondes que le Pod démarre. Affichez ensuite le contenu du conteneur pour vérifier que le fichier est présent :

kubectl exec config-pod -- cat /etc/nginx/nginx.conf

Vous devez voir votre configuration personnalisée. Le Pod a en quelque sorte « lu le panneau d’affichage » et utilisé le fichier correspondant.

Injecter un Secret comme variable d’environnement

Passons maintenant au Secret. Une méthode courante pour transmettre des mots de passe consiste à utiliser des variables d’environnement.

Cette méthode est pratique, mais elle met également en évidence un compromis. Les applications peuvent lire facilement les variables d’environnement, mais celles-ci peuvent être exposées par des commandes de diagnostic ou lors de l’inspection des processus. Kubernetes prend en charge l’injection par fichier et par variable d’environnement, car les applications et les profils de risque nécessitent des approches différentes.

Créez un fichier nommé pod-secret.yaml :

nano pod-secret.yaml

Collez le contenu suivant. Ce Pod récupère le champ password du Secret app-secret et l’affecte à une variable d’environnement nommée APP_PASSWORD.

apiVersion: v1
kind: Pod
metadata:
  name: secret-pod
spec:
  containers:
    - name: busybox
      image: busybox
      command: ["sleep", "3600"]
      env:
        - name: APP_PASSWORD
          valueFrom:
            secretKeyRef:
              name: app-secret
              key: password

Enregistrez le fichier et quittez l’éditeur (Ctrl+X, Y, Enter).

Appliquez cette définition :

kubectl apply -f pod-secret.yaml

Une fois le Pod démarré, vérifiez les variables d’environnement présentes dans le conteneur :

kubectl exec secret-pod -- env | grep APP_PASSWORD

Vous devez voir APP_PASSWORD=SuperSecretPass123.

L’intérêt est que la définition du Pod ne contient pas le mot de passe. Celui-ci se trouve dans le « coffre-fort » (Secret), et le Pod dispose simplement d’une clé pour y accéder au moment de l’exécution.

Résumé

Dans cet atelier, vous avez appris à séparer le code de la configuration.

Vous avez réussi à :

Utiliser un ConfigMap (panneau d’affichage) pour injecter un fichier de configuration dans un serveur.
Utiliser un Secret (coffre-fort) pour injecter un mot de passe masqué dans une application.

Vous pouvez désormais mettre à jour votre configuration ou renouveler vos mots de passe sans avoir à reconstruire vos images Docker !