Chiffrer votre Secret pour OVHcloud Managed Kubernetes avec Sealed Secrets (Kubeseal)

Objectif

Lorsque vous souhaitez stocker vos ressources Kubernetes sous forme de manifeste YAML, la pratique courante consiste à les conserver dans un dépôt Git. Cela vous permet également de créer, modifier et supprimer automatiquement vos clusters et ressources Kubernetes grâce à l'Infrastructure as Code et au CI/CD.

Dans l'univers Kubernetes, lorsque l'on souhaite gérer des données sensibles, l'usage est de les stocker dans un Secret au sein d'un cluster Kubernetes. Le problème est que vous ne pouvez pas stocker un Secret dans un système de contrôle de version, car le Secret n'est pas chiffré : c'est une question de sécurité.

Chez OVHcloud, nous mettons un point d'honneur à vous proposer les meilleurs produits et services. La sécurité étant pour nous un enjeu important, ce guide vous fait découvrir Sealed Secrets et la CLI kubeseal, qui vous aideront à chiffrer vos informations sensibles et à les déployer facilement sur votre OVHcloud Managed Kubernetes.

Dans ce guide, vous allez :

• Installer la CLI Kubeseal
• Déployer Sealed Secrets sur votre OVHcloud Managed Kubernetes
• Générer et déployer un SealedSecret

Vous pouvez utiliser la fonction Réinitialiser le cluster dans la section Public Cloud de l'espace client OVHcloud pour réinitialiser votre cluster avant de suivre ce tutoriel.

Secrets Kubernetes

Les Secrets Kubernetes permettent de stocker des données sensibles, comme des mots de passe, des clés, des certificats et des tokens. Les Secrets sont encodés en base64 et automatiquement décodés lorsqu'ils sont attachés à un Pod puis lus par celui-ci.

Un secret dans un cluster Kubernetes est encodé en base64, mais pas chiffré !

Ces données sont « seulement » encodées : si un utilisateur a accès à vos secrets, il peut simplement exécuter une commande base64 decode pour voir vos données sensibles (kubectl get secret my-secret -o jsonpath="{.data.password}" | base64 --decode).

Les secrets n'étant pas chiffrés, il peut être risqué de les committer dans votre dépôt Git.

Sealed Secrets

Une solution consiste à utiliser Sealed Secrets, anciennement appelé Kubeseal, un outil de Bitnami. Son objectif est de chiffrer votre Secret Kubernetes en un SealedSecret, qui peut être stocké en toute sécurité, y compris dans un dépôt public. Le SealedSecret ne peut être déchiffré que par le contrôleur exécuté dans le cluster cible, et par personne d'autre.

Comment cela fonctionne-t-il ?

Comme vous pouvez le voir sur le schéma, un sealed-secrets-controller s'exécute dans le cluster Kubernetes. Il détecte l'apparition d'un nouvel objet SealedSecret, le déchiffre (grâce à des certificats connus) et crée un Secret Kubernetes dans le même namespace que le SealedSecret.

Sealed Secrets est une application directe de la cryptographie asymétrique (à clé publique). La cryptographie à clé publique repose sur une paire de clés étroitement liées (appelées « publique » et « privée »), et tout ce qui est chiffré avec l'une ne peut être déchiffré qu'avec l'autre.

Les SealedSecrets et l'outil kubeseal sont conçus pour s'intégrer facilement dans des workflows automatisés. Une fois converti en SealedSecret, même l'utilisateur d'origine ne pourra pas récupérer le Secret original. kubeseal peut également être exécuté hors ligne, sans accès au cluster : il lui suffit de disposer d'une copie de la clé publique quelque part sur le disque.

Pour en savoir plus, consultez la page Sealed Secrets.

Prérequis

Ce tutoriel suppose que vous disposez déjà d'un cluster OVHcloud Managed Kubernetes fonctionnel, ainsi que de connaissances de base sur son fonctionnement. Pour en savoir plus sur ces sujets, consultez la documentation Déployer une application Hello World.

En pratique

Installer la CLI kubeseal

L'utilitaire kubeseal utilise la cryptographie asymétrique pour chiffrer des secrets que seul le contrôleur peut déchiffrer.

Avec la CLI kubeseal, vous pouvez spécifier un certificat de clé pour le scellement des secrets.

Pour installer la CLI, suivez les instructions correspondant à votre système d'exploitation.

Vous pouvez, par exemple, l'installer via Homebrew :

brew install kubeseal

Testez ensuite si la CLI est correctement installée sur votre ordinateur :

kubeseal --version

La sortie devrait ressembler à ceci :

$ brew install kubeseal
Running `brew update --preinstall`...
==> Auto-updated Homebrew!
...
==> Pouring kubeseal--0.17.3.arm64_big_sur.bottle.tar.gz
🍺  /Users/avache/homebrew/Cellar/kubeseal/0.17.3: 5 files, 35.3MB
==> Running `brew cleanup kubeseal`...
Disable this behaviour by setting HOMEBREW_NO_INSTALL_CLEANUP.
Hide these hints with HOMEBREW_NO_ENV_HINTS (see `man brew`).

$ kubeseal --version
kubeseal version: v0.17.3

Installation de Sealed Secrets

Pour ce tutoriel, nous utilisons le chart Helm de Sealed Secrets.

Ajoutez le dépôt Helm de Sealed Secrets :

helm repo add sealed-secrets https://bitnami-labs.github.io/sealed-secrets
helm repo update

Ces commandes ajoutent le dépôt Helm de Kyverno à votre dépôt local de charts Helm et mettent à jour les dépôts de charts installés :

$ helm repo add sealed-secrets https://bitnami-labs.github.io/sealed-secrets

"sealed-secrets" has been added to your repositories

$ helm repo update

Hang tight while we grab the latest from your chart repositories...
...Successfully got an update from the "sealed-secrets" chart repository
...
...Successfully got an update from the "bitnami" chart repository
Update Complete. ⎈Happy Helming!⎈

Installez la dernière version de Sealed Secrets avec la commande helm install :

helm install sealed-secrets-controller sealed-secrets/sealed-secrets --namespace kube-system 

Cette commande installe la dernière version de Sealed Secrets :

$ helm install sealed-secrets-controller sealed-secrets/sealed-secrets --namespace kube-system
NAME: sealed-secrets-controller
LAST DEPLOYED: Wed Feb 16 14:59:42 2022
NAMESPACE: kube-system
STATUS: deployed
REVISION: 1
TEST SUITE: None
NOTES:
** Please be patient while the chart is being deployed **

You should now be able to create sealed secrets.

1. Install the client-side tool (kubeseal) as explained in the docs below:

    https://github.com/bitnami-labs/sealed-secrets#installation-from-source

2. Create a sealed secret file running the command below:

    kubectl create secret generic secret-name --dry-run=client --from-literal=foo=bar -o [json|yaml] | \
    kubeseal \
      --controller-name=sealed-secrets-controller \
      --controller-namespace=kube-system \
      --format yaml > mysealedsecret.[json|yaml]

The file mysealedsecret.[json|yaml] is a commitable file.

If you would rather not need access to the cluster to generate the sealed secret you can run:

    kubeseal \
      --controller-name=sealed-secrets-controller \
      --controller-namespace=kube-system \
      --fetch-cert > mycert.pem

to retrieve the public cert used for encryption and store it locally. You can then run 'kubeseal --cert mycert.pem' instead of using the local cert e.g.

    kubectl create secret generic secret-name --dry-run=client --from-literal=foo=bar -o [json|yaml] | \
    kubeseal \
      --controller-name=sealed-secrets-controller \
      --controller-namespace=kube-system \
      --format [json|yaml] --cert mycert.pem > mysealedsecret.[json|yaml]

3. Apply the sealed secret

    kubectl create -f mysealedsecret.[json|yaml]

Running 'kubectl get secret secret-name -o [json|yaml]' will show the decrypted secret that was generated from the sealed secret.

Both the SealedSecret and generated Secret must have the same name and namespace.

Une fois le chart Helm déployé, celui-ci va :

• créer la CRD SealedSecret
• installer le contrôleur dans le namespace kube-system
• créer un compte de service sealed-secrets-controller dans le namespace kube-system
• et les rôles RBAC nécessaires.

Vous pouvez vérifier que le pod sealed-secrets-controller est bien en cours d'exécution :

$ kubectl get pod -n kube-system -l app.kubernetes.io/name=sealed-secrets
NAME                                         READY   STATUS    RESTARTS   AGE
sealed-secrets-controller-5fb95c87fd-pnvmk   1/1     Running   0          2m43s

Récupérer la paire de clés générée

Au démarrage du sealed-secrets-controller, une paire de clés de certificat est générée. Il peut être utile de la stocker dans un outil de gestion des secrets comme Vault.

Exécutez la commande suivante pour récupérer le contenu du secret contenant la paire de clés générée :

kubectl get secret -l sealedsecrets.bitnami.com/sealed-secrets-key -o yaml -n kube-system

La sortie devrait ressembler à ceci :

$ kubectl get secret -l sealedsecrets.bitnami.com/sealed-secrets-key -o yaml -n kube-system

apiVersion: v1
items:
- apiVersion: v1
  data:
    tls.crt: <sensitive-data-encoded-in-base64>
    tls.key: <sensitive-data-encoded-in-base64>
  kind: Secret
  metadata:
    creationTimestamp: "2022-02-16T13:42:25Z"
    generateName: sealed-secrets-key
    labels:
      sealedsecrets.bitnami.com/sealed-secrets-key: active
    name: sealed-secrets-keyvzwdp
    namespace: kube-system
    resourceVersion: "2305607283"
    uid: b2b6669a-358a-462e-a284-3d743434f82f
  type: kubernetes.io/tls
kind: List
metadata:
  resourceVersion: ""
  selfLink: ""

Avec ces informations, vous pouvez maintenant décoder en base64 les fichiers tls.crt et tls.key, les stocker localement ainsi que dans votre outil de gestion des secrets, afin de les réutiliser plus tard pour récupérer les sealed secrets.

Vous pouvez utiliser le plugin kubectl kubectl view-secret afin de récupérer facilement la clé et le certificat et de les stocker localement :

SEALEDKEY=$(kubectl get secret -l sealedsecrets.bitnami.com/sealed-secrets-key -n kube-system -o name)

kubectl view-secret $SEALEDKEY tls.crt -n kube-system > tls.crt

kubectl view-secret $SEALEDKEY tls.key -n kube-system > tls.key

Créer un sealed-secret

Commencez par générer un secret Kubernetes. Dans cet exemple, vous allez créer, dans un fichier YAML, un secret nommé my-token contenant un token nommé my_token avec la valeur 123456789abc123def456ghi789 :

kubectl create secret generic my-token --from-literal=my_token='123456789abc123def456ghi789' --dry-run=client -o yaml -n my-namespace > my-token.yaml

Vous pouvez ensuite afficher le secret :

cat my-token.yaml

La sortie devrait ressembler à ceci :

$ kubectl create secret generic my-token --from-literal=my_token='123456789abc123def456ghi789' --dry-run=client -o yaml -n my-namespace > my-token.yaml

$ cat my-token.yaml
apiVersion: v1
data:
  my_token: MTIzNDU2Nzg5YWJjMTIzZGVmNDU2Z2hpNzg5
kind: Secret
metadata:
  creationTimestamp: null
  name: my-token
  namespace: my-namespace

Scellez ensuite le secret, avec le certificat généré que vous avez récupéré et stocké précédemment :

kubeseal --cert tls.crt --format=yaml < my-token.yaml > mysealedtoken.yaml

La sortie devrait ressembler à ceci :

$ kubeseal --cert tls.crt --format=yaml < my-token.yaml > mysealedtoken.yaml

$ cat mysealedtoken.yaml
apiVersion: bitnami.com/v1alpha1
kind: SealedSecret
metadata:
  creationTimestamp: null
  name: my-token
  namespace: my-namespace
spec:
  encryptedData:
    my_token: <sensitive-data>
  template:
    data: null
    metadata:
      creationTimestamp: null
      name: my-token
      namespace: my-namespace

Créez le nouveau namespace my-namespace et appliquez la ressource SealedSecret à l'intérieur :

kubectl create ns my-namespace
kubectl apply -f mysealedtoken.yaml -n my-namespace

La sortie devrait ressembler à ceci :

$ kubectl create ns my-namespace
kubectl apply -f mycleanedsealedtoken.yaml -n my-namespace

$ kubectl apply -f mysealedtoken.yaml -n my-namespace
sealedsecret.bitnami.com/my-token created

Après la création du SealedSecret, le sealed-secrets-controller crée automatiquement un Secret Kubernetes.

Vous pouvez vérifier leur existence avec la commande suivante :

kubectl get sealedsecret -n my-namespace

kubectl get secret -n my-namespace

$ kubectl get sealedsecret -n my-namespace
NAME       AGE
my-token   89s

$ kubectl get secret -n my-namespace
NAME                  TYPE                                  DATA   AGE
my-token              Opaque                                1      93s

Si vous avez déjà installé le plugin kubectl view-secret, vous pouvez également vérifier que le Secret généré contient bien le token que vous avez scellé :

kubectl view-secret my-token -n my-namespace

Vous devriez obtenir la sortie suivante :

$ kubectl view-secret my-token -n my-namespace
Choosing key: my_token
123456789abc123def456ghi789%

Débogage / Dépannage

Certains problèmes peuvent survenir. Si un Secret n'est jamais créé après la création d'un SealedSecret, l'une des explications les plus courantes est que vous avez probablement scellé le secret avec un certificat différent de celui que le contrôleur connaît.

Pour déboguer/dépanner le comportement du sealed-secrets-controller, vous pouvez consulter ses logs :

kubectl logs $(kubectl get pod -n kube-system -l app.kubernetes.io/name=sealed-secrets -o name) -n kube-system

Lorsque tout fonctionne correctement, vous devriez voir la sortie suivante :

$ kubectl logs $(kubectl get pod -n kube-system -l app.kubernetes.io/name=sealed-secrets -o name) -n kube-system

controller version: 0.17.3
2022/02/16 13:59:46 Starting sealed-secrets controller version: 0.17.3
2022/02/16 13:59:46 Searching for existing private keys
2022/02/16 13:59:46 ----- sealed-secrets-keyvzwdp
2022/02/16 13:59:46 HTTP server serving on :8080
2022/02/17 09:43:49 Updating my-namespace/my-token
2022/02/17 09:43:49 Event(v1.ObjectReference{Kind:"SealedSecret", Namespace:"my-namespace", Name:"my-token", UID:"e2f1778d-67b6-4cb6-b243-c82871886f70", APIVersion:"bitnami.com/v1alpha1", ResourceVersion:"2318609909", FieldPath:""}): type: 'Normal' reason: 'Unsealed' SealedSecret unsealed successfully

Suppression (nettoyage)

Commencez par supprimer le namespace my-namespace que vous avez créé dans ce guide :

kubectl delete ns my-namespace

Pour désinstaller Sealed Secrets, puisque vous l'avez installé via Helm, vous pouvez utiliser la commande helm uninstall afin de supprimer le chart Helm installé de Sealed Secrets :

helm uninstall sealed-secrets-controller sealed-secrets/sealed-secrets --namespace kube-system 

Aller plus loin

• Pour une formation ou une assistance technique sur la mise en œuvre de nos solutions, contactez votre commercial ou consultez la page Professional Services pour obtenir un devis et faire analyser votre projet par nos experts.

• Échangez avec notre communauté d'utilisateurs.