Sécurisez les secrets de vos applications avec Vault Dedicated et Vault Secrets Operator

Dans ce tutoriel, vous apprendrez à utiliser IBM Cloud Vault Enterprise pour gérer les secrets des applications exécutées dans votre cluster IBM Cloud Kubernetes Service à l’aide de Vault Secrets Operator, l’opérateur officiel d’ HashiCorp's Kubernetes.

Vous êtes développeur au sein d'une entreprise qui utilise l' Kubernetes Service pour déployer des applications conteneurisées sur IBM Cloud. Votre équipe utilise HashiCorp Vault pour la gestion des secrets, et vous souhaitez bénéficier d'une intégration native de Vault pour vos charges de travail Kubernetes. Vault Secrets Operator (VSO) offre une intégration poussée avec Vault et prend en charge des fonctionnalités avancées telles que les secrets dynamiques, la rotation des secrets et les méthodes d’authentification natives de Vault.

Grâce à Vault Dedicated et à Vault Secrets Operator, vous pouvez exploiter toute la puissance d’ HashiCorp Vault dans votre environnement Kubernetes. Vault Secrets Operator offre une méthode native à Kubernetes pour gérer les secrets Vault, prenant en charge à la fois les secrets statiques et dynamiques. Vous pouvez par exemple, envisager le scénario suivant :

Le schéma illustre le flux de base entre Secrets Manager et votre cluster Kubernetes.
Flux
des secrets externes

  1. En tant que développeur, vous utilisez Vault Dedicated pour stocker les secrets d'une application que vous souhaitez déployer dans un cluster Kubernetes.
  2. Vous configurez l’opérateur Vault Secrets à l’aide des ressources VaultConnection et VaultAuth pour vous connecter à votre instance Vault Dedicated.
  3. Vous créez des ressources VaultStaticSecret ou VaultDynamicSecret qui définissent les secrets à synchroniser.
  4. Au moment de l'exécution de l'application, VSO récupère les données secrètes depuis Vault Dedicated et crée des secrets Kubernetes pour votre cluster.
  5. VSO surveille et synchronise en permanence les secrets, en gérant automatiquement leur rotation et leurs mises à jour.

Vault Secrets Operator est un outil officiel d' HashiCorp. Pour obtenir de l'aide ou résoudre un problème, consultez la documentation officielle.

Avant de commencer

Avant de commencer, assurez-vous d'avoir accès à la plateforme Administrateur pour pouvoir créer des données d'identification de compte et des ressources de mise à disposition. Vous devez également satisfaire les prérequis suivants :

Configuration de votre environnement

Pour utiliser Vault Dedicated et Kubernetes Service, vous devez créer un cluster et configurer votre instance Vault Dedicated avec l’authentification AppRole.

Création d'un cluster Kubernetes

Créez un cluster d' Kubernetes s dans votre compte IBM Cloud.

  1. A partir de la ligne de commande, connectez-vous à IBM Cloud via l'interface de ligne de commande IBM Cloud.

    ibmcloud login
    

    Si la connexion échoue, exécutez la commande ibmcloud login --sso pour réessayer. Le paramètre --sso est requis lorsque vous vous connectez avec un ID fédéré. Si cette option est utilisée, allez sur le lien répertorié dans la sortie d'interface de ligne de commande pour générer un code d'accès unique.

  2. Sélectionnez le compte, la région et le groupe de ressources dans lesquels vous souhaitez créer votre cluster.

    ibmcloud target -r REGION -g RESOURCE_GROUP
    
  3. Créez un cluster Kubernetes.

    ibmcloud ks cluster create vpc-gen2 --zone ZONE --flavor FLAVOR --workers 1 --name vso-test-cluster --vpc-id VPC_ID --subnet-id SUBNET_ID
    

    La mise en service prend entre 5 et 15 minutes.

  4. Vérifiez que votre cluster a bien été provisionné.

    ibmcloud ks worker ls --cluster vso-test-cluster
    

    Attendez que le statut passe à Prêt.

  5. Définissez le contexte de votre cluster Kubernetes.

    ibmcloud ks cluster config --cluster vso-test-cluster
    kubectl config current-context
    

Préparez votre instance Vault Dedicated

Configurez votre instance Vault Dedicated avec des secrets et l'authentification par AppRole pour VSO.

  1. Exportez les variables d’environnement avec les informations relatives à votre instance Vault Dedicated.

    export VAULT_DEDICATED_ADDR="https://<your-vault_dedicated-instance-id>.vault.<region>.appdomain.cloud"
    export VAULT_DEDICATED_NAMESPACE="admin"
    export VAULT_TOKEN="<your-vault-token>"
    

    Remplacez <your-vault_dedicated-instance-id> par l'ID de votre instance Vault Dedicated, <region> par votre région Vault Dedicated et <your-vault-token> par votre jeton Vault.

  2. Créer un secret de test dans Vault Dedicated.

    curl -k -X POST \
      -H "X-Vault-Token: $VAULT_TOKEN" \
      -H "X-Vault-Namespace: $VAULT_DEDICATED_NAMESPACE" \
      -d '{"data":{"username":"vso-user","password":"vso-secure-pass-123"}}' \
      $VAULT_DEDICATED_ADDR/v1/kv/data/example_username_password
    

    Notez que Vault Dedicated utilise kv/ comme chemin de montage pour le moteur de secrets KV.

  3. Activer l'authentification AppRole pour VSO.

    curl -k -X POST \
      -H "X-Vault-Token: $VAULT_TOKEN" \
      -H "X-Vault-Namespace: $VAULT_DEDICATED_NAMESPACE" \
      -d '{"type":"approle"}' \
      $VAULT_DEDICATED_ADDR/v1/sys/auth/approle
    

    VSO nécessite une authentification par AppRole, Kubernetes, JWT, AWS ou GCP. Il ne prend pas en charge l'authentification directe par jeton.

  4. Élaborer une politique pour VSO.

    curl -k -X PUT \
      -H "X-Vault-Token: $VAULT_TOKEN" \
      -H "X-Vault-Namespace: $VAULT_DEDICATED_NAMESPACE" \
      -d '{"policy":"path \"kv/data/*\" { capabilities = [\"read\", \"list\"] }\npath \"kv/metadata/*\" { capabilities = [\"read\", \"list\"] }"}' \
      $VAULT_DEDICATED_ADDR/v1/sys/policies/acl/kv-read
    
  5. Créer une page À propos ( AppRole ) pour VSO.

    curl -k -X POST \
      -H "X-Vault-Token: $VAULT_TOKEN" \
      -H "X-Vault-Namespace: $VAULT_DEDICATED_NAMESPACE" \
      -d '{"policies":["kv-read"],"token_ttl":"1h","token_max_ttl":"4h"}' \
      $VAULT_DEDICATED_ADDR/v1/auth/approle/role/vso-role
    
  6. Récupérez l'ID de rôle et l'ID secret.

    export ROLE_ID=$(curl -k -X GET \
      -H "X-Vault-Token: $VAULT_TOKEN" \
      -H "X-Vault-Namespace: $VAULT_DEDICATED_NAMESPACE" \
      $VAULT_DEDICATED_ADDR/v1/auth/approle/role/vso-role/role-id | jq -r '.data.role_id')
    export SECRET_ID=$(curl -k -X POST \
      -H "X-Vault-Token: $VAULT_TOKEN" \
      -H "X-Vault-Namespace: $VAULT_DEDICATED_NAMESPACE" \
      $VAULT_DEDICATED_ADDR/v1/auth/approle/role/vso-role/secret-id | jq -r '.data.secret_id')
    echo "Role ID: $ROLE_ID"
    echo "Secret ID: $SECRET_ID"
    

Installer Vault Secrets Operator

Installez l'opérateur Vault Secrets à l'aide de Helm.

  1. Ajoutez le référentiel HashiCorp Helm.

    helm repo add hashicorp https://helm.releases.hashicorp.com
    helm repo update
    
  2. Installer Vault Secrets Operator.

    helm install vault-secrets-operator \
      hashicorp/vault-secrets-operator \
      --namespace vault-secrets-operator-system \
      --create-namespace \
      --version 0.9.0
    
  3. Vérification de l'installation.

    kubectl get pods -n vault-secrets-operator-system
    

    Attendez que tous les pods soient à l'état Running.

  4. Vérifiez que les définitions de ressources personnalisées (CRD) sont installées.

    kubectl get crd | grep vault
    

    Vous devriez voir des CRD tels que vaultauths, vaultconnections, vaultdynamicsecrets, et vaultstaticsecrets.

Configurer VaultConnection et VaultAuth

Configurez VSO pour qu'il se connecte à votre instance Vault Dedicated à l'aide des ressources VaultConnection et VaultAuth.

Créer un VaultConnection

  1. Créez un secret Kubernetes à l'aide de l' AppRole SecretID.

    kubectl create secret generic approle-secret \
      --namespace default \
      --from-literal=id="$SECRET_ID"
    

    La clé doit être nommée id pour que VSO puisse la reconnaître.

  2. Créez un fichier vaultconnection.yaml.

    touch vaultconnection.yaml
    
  3. Ajoutez la configuration suivante.

    apiVersion: secrets.hashicorp.com/v1beta1
    kind: VaultConnection
    metadata:
      name: vault-connection
      namespace: default
    spec:
      address: "<VAULT_DEDICATED_ADDR>"
      skipTLSVerify: true
    

    Remplacez <VAULT_DEDICATED_ADDR> par l'adresse de votre instance Vault Dedicated. En production, configurez l' TLS appropriée au lieu d'utiliser skipTLSVerify.

  4. Appliquer les directives de style VaultConnection.

    kubectl apply -f vaultconnection.yaml
    

Créer un VaultAuth

  1. Créez un fichier vaultauth.yaml.

    touch vaultauth.yaml
    
  2. Ajoutez la configuration suivante.

    apiVersion: secrets.hashicorp.com/v1beta1
    kind: VaultAuth
    metadata:
      name: vault-dedicates-auth
      namespace: default
    spec:
      vaultConnectionRef: vault-dedicated-connection
      method: appRole
      mount: approle
      namespace: admin
      appRole:
        roleId: vso-role
        secretRef: approle-secret
    
  3. Appliquer les directives de style d' VaultAuth ().

    kubectl apply -f vaultauth.yaml
    
  4. Vérifiez l'état de l' VaultAuth.

    kubectl get vaultauth vault-dedicated-auth -n default
    kubectl describe vaultauth vault-dedicated-auth -n default
    

Créer un VaultStaticSecret

Créer une ressource VaultStaticSecret pour synchroniser les secrets de Vault Dedicated vers Kubernetes.

  1. Créez un fichier vaultstaticsecret.yaml.

    touch vaultstaticsecret.yaml
    
  2. Ajoutez la configuration suivante.

    apiVersion: secrets.hashicorp.com/v1beta1
    kind: VaultStaticSecret
    metadata:
      name: vault-dedicated-app-secret
      namespace: default
    spec:
      vaultAuthRef: vault-dedicated-auth
      mount: kv
      type: kv-v2
      path: example_username_password
      refreshAfter: 1h
      destination:
        name: my-k8s-secret-vso
        create: true
    

    Cette configuration récupère le secret depuis kv/data/example_username_password dans Vault Dedicated et crée un secret Kubernetes nommé my-k8s-secret-vso. Le secret est actualisé toutes les heures.

  3. Appliquer les directives de style VaultStaticSecret.

    kubectl apply -f vaultstaticsecret.yaml
    
  4. Vérifiez que la clé secrète a bien été synchronisée.

    kubectl get vaultstaticsecret vault-dedicated-app-secret -n default
    kubectl get secret my-k8s-secret-vso -n default -o json | jq '.data | map_values(@base64d)'
    

    Exemple de sortie :

    {
        "password": "vso-secure-pass-123",
        "username": "vso-user"
    }
    

Déployer une application dans le cluster

Déployez une application qui utilise les secrets synchronisés depuis Vault Dedicated.

  1. Créer un déploiement de test.

    cat <<EOF | kubectl apply -f -
    apiVersion: v1
    kind: Pod
    metadata:
      name: test-app-vso
      namespace: default
    spec:
      containers:
      - name: app
        image: busybox
        command: ['sh', '-c', 'echo "Username: \$USERNAME"; echo "Password: \$PASSWORD"; sleep 3600']
        env:
        - name: USERNAME
          valueFrom:
            secretKeyRef:
              name: my-k8s-secret-vso
              key: username
        - name: PASSWORD
          valueFrom:
            secretKeyRef:
              name: my-k8s-secret-vso
              key: password
    EOF
    
  2. Vérifiez les journaux du pod.

    kubectl logs test-app-vso -n default
    

    Sortie attendue :

    Username: vso-user
    Password: vso-secure-pass-123
    

(Facultatif) Nettoyer les ressources

Si vous n'avez plus besoin de ces ressources, supprimez-les de votre compte.

  1. Supprimez l'espace de noms et les ressources de test.

    kubectl delete pod test-app-vso -n default
    kubectl delete vaultstaticsecret vault-dedicated-app-secret -n default
    kubectl delete vaultauth vault-dedicated-auth -n default
    kubectl delete vaultconnection vault-dedicated-connection -n default
    kubectl delete secret approle-secret -n default
    
  2. Désinstaller Vault Secrets Operator.

    helm uninstall vault-secrets-operator -n vault-secrets-operator-system
    kubectl delete namespace vault-secrets-operator-system
    
  3. Supprimez votre cluster de test.

    ibmcloud ks cluster rm --cluster vso-test-cluster
    
  4. Nettoyer les données de test de Vault Dedicated.

    curl -k -X DELETE \
      -H "X-Vault-Token: $VAULT_TOKEN" \
      -H "X-Vault-Namespace: $VAULT_DEDICATED_NAMESPACE" \
      $VAULT_DEDICATED_ADDR/v1/kv/metadata/example_username_password
    

Remarques d'intérêt

Éléments clés à prendre en compte lors de l'utilisation de Vault Secrets Operator :

  1. Méthodes d'authentification: VSO ne prend pas en charge l'authentification directe par jeton. Vous devez utiliser les méthodes d'authentification suivantes : AppRole, Kubernetes, JWT, AWS ou GCP.

  2. SecretID Nom de la clé: lors de la création d'un secret Kubernetes pour l'authentification AppRole, la clé doit être nommée id, et non secret-id ou secretId.

  3. Intervalle de rafraîchissement: ce champ refreshAfter détermine la fréquence à laquelle VSO vérifie les mises à jour des secrets. Équilibre entre la fraîcheur des données et la charge sur l’API.

  4. Déploiements automatiques: utilisez dans rolloutRestartTargets votre VaultStaticSecret pour relancer automatiquement les déploiements lorsque les secrets changent.

  5. Chemin de montage de Vault Dedicated: Vault Dedicated utilise kv/ comme chemin de montage par défaut pour le moteur de secrets KV, et non secret/.

  6. Espaces de noms Vault Dedicated: Vault Dedicated utilise les espaces de noms de Vault Enterprise. L'espace de noms par défaut est admin. Veillez à toujours spécifier l'espace de noms correct dans la configuration de votre VaultAuth.

  7. TLS Configuration: pour la production, configurez une validation correcte des certificats d' TLS au lieu d'utiliser skipTLSVerify.

Etapes suivantes

Bon travail ! Dans ce tutoriel, vous avez appris à utiliser Vault Secrets Operator pour intégrer Vault Dedicated à votre cluster Kubernetes. Découvrez d’autres fonctionnalités de VSO :