Utiliser External Secret Operator pour gérer les secrets

Ce guide pratique vous montre comment utiliser External Secret Operator (ESO) pour récupérer des secrets stockés dans Vault et les utiliser dans vos déploiements Kubernetes sur la plateforme Atlas.

Prérequis

• Avoir un compte sur la plateforme Atlas
• Être administrateur de workspace ou avoir les droits nécessaires
• Avoir un DeploymentTarget déjà créé
• Avoir des secrets stockés dans Vault

Qu'est-ce qu'External Secret Operator ?

External Secret Operator (ESO) est un contrôleur Kubernetes qui permet de récupérer des secrets depuis des sources externes (comme Vault) et de les synchroniser avec des secrets Kubernetes. Dans la plateforme Atlas, ESO est déjà configuré et prêt à être utilisé dans chaque DeploymentTarget.

Note : Sous le capot, les secrets des ressources comme les buckets et les DatabaseClusters sont automatiquement livrés aux DeploymentTargets spécifiés via External Secret Operator. Ce guide vous montre comment utiliser ESO pour récupérer vos propres secrets personnalisés.

Création d'un ExternalSecret

Pour récupérer un secret depuis Vault et le synchroniser avec un secret Kubernetes, vous devez créer une ressource ExternalSecret. Voici un exemple simple :

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22

apiVersion: external-secrets.io/v1beta1
kind: ExternalSecret
metadata:
  name: mon-external-secret
spec:
  # Intervalle de rafraîchissement du secret
  refreshInterval: "15s"
  # Référence au SecretStore qui contient les informations de connexion à Vault
  # "local-secret-store" est un SecretStore crée automatiquement par Atlas
  # pour chaque DeploymentTarget
  secretStoreRef:
    kind: SecretStore
    name: local-secret-store
  # Secret Kubernetes cible qui sera créé ou mis à jour
  target:
    name: mon-secret-kubernetes
  # Données à récupérer depuis Vault
  data:
  - secretKey: ma-cle-secrete
    remoteRef:
      key: secret/mon-chemin-vault
      property: ma-valeur

Cet exemple créera ou mettra à jour un secret Kubernetes nommé mon-secret-kubernetes avec une clé ma-cle-secrete dont la valeur sera récupérée depuis Vault à l'emplacement secret/mon-chemin-vault et la propriété ma-valeur.

Exemple plus avancé avec des templates

External Secret Operator permet également d'utiliser des templates pour transformer les données récupérées avant de les stocker dans le secret Kubernetes. Voici un exemple plus avancé qui crée des identifiants de registre Docker (regcreds) à partir de données stockées dans Vault :

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34

apiVersion: external-secrets.io/v1beta1
kind: ExternalSecret
metadata:
  name: harbor-regcreds
spec:
  # Récupérer toutes les données depuis une clé Vault
  dataFrom:
  - extract:
      conversionStrategy: Default
      decodingStrategy: None
      key: harbor/atlas-regcreds
      metadataPolicy: None
  # Intervalle de rafraîchissement du secret
  refreshInterval: 1h
  # Référence au ClusterSecretStore qui contient les informations de connexion à Vault
  # "local-secret-store" est un SecretStore crée automatiquement par Atlas
  # pour chaque DeploymentTarget
  secretStoreRef:
    kind: SecretStore
    name: local-secret-store
  # Secret Kubernetes cible qui sera créé ou mis à jour
  target:
    creationPolicy: Owner
    deletionPolicy: Retain
    name: harbor-regcreds
    # Template pour transformer les données récupérées
    template:
      data:
        # Création d'un fichier de configuration Docker au format JSON
        .dockerconfigjson: '{"auths":{"{{ .host }}":{"auth":"{{ printf "%s:%s" .username .password | b64enc }}"}}}'
      engineVersion: v2
      mergePolicy: Replace
      # Type de secret Kubernetes
      type: kubernetes.io/dockerconfigjson

Dans cet exemple :

• Les données sont récupérées depuis Vault à l'emplacement harbor/atlas-regcreds
• Ces données doivent contenir les clés host, username et password
• Le template transforme ces données en un fichier de configuration Docker au format JSON
• Le secret Kubernetes créé est de type kubernetes.io/dockerconfigjson, qui est utilisé pour l'authentification auprès des registres Docker

Utilisation des secrets dans vos déploiements

Une fois que vous avez créé un ExternalSecret et que le secret Kubernetes correspondant a été créé, vous pouvez l'utiliser dans vos déploiements Kubernetes comme n'importe quel autre secret.

Exemple d'utilisation comme variables d'environnement

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

apiVersion: apps/v1
kind: Deployment
metadata:
  name: mon-application
spec:
  replicas: 1
  selector:
    matchLabels:
      app: mon-application
  template:
    metadata:
      labels:
        app: mon-application
    spec:
      containers:
      - name: mon-application
        image: mon-image:latest
        env:
        - name: API_KEY
          valueFrom:
            secretKeyRef:
              name: mon-secret-kubernetes
              key: ma-cle-secrete

Exemple d'utilisation comme volume

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

apiVersion: apps/v1
kind: Deployment
metadata:
  name: mon-application
spec:
  replicas: 1
  selector:
    matchLabels:
      app: mon-application
  template:
    metadata:
      labels:
        app: mon-application
    spec:
      containers:
      - name: mon-application
        image: mon-image:latest
        volumeMounts:
        - name: secrets
          mountPath: "/app/secrets"
          readOnly: true
      volumes:
      - name: secrets
        secret:
          secretName: mon-secret-kubernetes

Exemple d'utilisation comme identifiants de registre Docker

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19

apiVersion: apps/v1
kind: Deployment
metadata:
  name: mon-application
spec:
  replicas: 1
  selector:
    matchLabels:
      app: mon-application
  template:
    metadata:
      labels:
        app: mon-application
    spec:
      containers:
      - name: mon-application
        image: registry.example.com/mon-image:latest
      imagePullSecrets:
      - name: harbor-regcreds

Vérification de l'état des ExternalSecrets

Vous pouvez vérifier l'état de vos ExternalSecrets en utilisant la commande kubectl :

1

kubectl get externalsecrets -n <namespace>

Pour voir les détails d'un ExternalSecret spécifique :

1

kubectl describe externalsecret <nom-de-l-externalsecret> -n <namespace>

Bonnes pratiques

Sécurité

• Limitez l'accès aux secrets aux personnes qui en ont besoin, en suivant le principe du moindre privilège.
• Utilisez des templates pour transformer les données sensibles si nécessaire.
• Évitez de stocker des secrets dans vos fichiers de configuration versionnés.

Organisation

• Utilisez des noms significatifs pour vos ExternalSecrets et vos secrets Kubernetes.
• Regroupez les secrets liés à une même application ou à un même service.
• Documentez vos ExternalSecrets pour faciliter leur utilisation par les autres membres de l'équipe.

Performance

• Utilisez un intervalle de rafraîchissement approprié pour vos ExternalSecrets. Un intervalle trop court peut surcharger Vault, tandis qu'un intervalle trop long peut retarder la propagation des changements.
• Regroupez plusieurs secrets dans un seul ExternalSecret si possible pour réduire le nombre de requêtes à Vault.

Résolution des problèmes courants

L'ExternalSecret ne crée pas de secret Kubernetes

• Vérifiez que l'ExternalSecret est correctement configuré.
• Vérifiez que le SecretStore ou ClusterSecretStore référencé existe et est correctement configuré.
• Vérifiez que vous avez les droits nécessaires pour accéder au secret dans Vault.
• Vérifiez les logs du pod External Secret Operator pour plus d'informations.

Le secret Kubernetes est créé mais ne contient pas les données attendues

• Vérifiez que le chemin et la propriété spécifiés dans remoteRef sont corrects.
• Vérifiez que le template est correctement configuré si vous en utilisez un.
• Vérifiez que les données existent dans Vault à l'emplacement spécifié.

Le déploiement ne peut pas accéder au secret

• Vérifiez que le secret Kubernetes a été créé avec succès.
• Vérifiez que le nom du secret et la clé référencés dans le déploiement sont corrects.
• Vérifiez que le déploiement a les droits nécessaires pour accéder au secret.

Ressources supplémentaires

• Documentation officielle d'External Secret Operator
• Documentation de Vault
• Guide de gestion des secrets avec Vault