Sichere Geheimnisse für Apps mit Vault Dedicated und Vault Secrets Operator

In diesem Tutorial erfahren Sie, wie Sie mit IBM Cloud und Vault Enterprise Geheimnisse für Anwendungen verwalten, die in Ihrem IBM Cloud Kubernetes Service-Cluster ausgeführt werden. Dazu nutzen Sie den Vault Secrets Operator, den offiziellen HashiCorp's- Kubernetes-Operator.

Sie sind Entwickler in einem Unternehmen, das Kubernetes Service nutzt, um containerisierte Anwendungen auf IBM Cloud bereitzustellen. Ihr Team nutzt HashiCorp Vault für die Verwaltung vertraulicher Daten, und Sie wünschen sich eine native Vault-Integration für Ihre Kubernetes-Workloads. Der Vault Secrets Operator (VSO) bietet eine umfassende Integration mit Vault und unterstützt erweiterte Funktionen wie dynamische Geheimnisse, die Rotation von Geheimnissen und Vault-native Authentifizierungsmethoden.

Mit Vault Dedicated und Vault Secrets Operator können Sie die volle Leistungsfähigkeit von HashiCorp Vault in Ihrer Kubernetes-Umgebung nutzen. Der Vault Secrets Operator bietet eine für Kubernetes native Möglichkeit, mit Vault-Geheimnissen zu arbeiten, und unterstützt dabei sowohl statische als auch dynamische Geheimnisse. Nehmen Sie beispielsweise folgendes Szenario an:

Das Diagramm zeigt den grundlegenden Ablauf zwischen Secrets Manager und Ihrem Kubernetes-Cluster.
Fluss
externer Geheimnisse

  1. Als Entwickler nutzen Sie Vault Dedicated, um Geheimnisse für eine Anwendung zu speichern, die Sie in einem Kubernetes-Cluster bereitstellen möchten.
  2. Sie konfigurieren den Vault Secrets Operator mithilfe der Ressourcen VaultConnection und VaultAuth, um eine Verbindung zu Ihrer Vault Dedicated-Instanz herzustellen.
  3. Sie erstellen VaultStaticSecret- oder VaultDynamicSecret-Ressourcen, die festlegen, welche Geheimnisse synchronisiert werden sollen.
  4. Zur Laufzeit der Anwendung ruft VSO die geheimen Daten aus Vault Dedicated ab und erstellt Kubernetes-Geheimnisse für Ihren Cluster.
  5. VSO überwacht und synchronisiert Geheimnisse kontinuierlich und übernimmt dabei automatisch die Rotation und Aktualisierung.

Vault Secrets Operator ist ein offizielles HashiCorp-Tool. Informationen zu Support und Fehlerbehebung finden Sie in der offiziellen Dokumentation.

Vorbereitende Schritte

Stellen Sie vor dem ersten Start sicher, dass Sie über den Administrator-Plattformzugriff verfügen, damit Sie Kontoberechtigungsnachweise und Einrichtungsressourcen erstellen können. Außerdem müssen die folgenden Voraussetzungen erfüllt sein:

Umgebung einrichten

Um mit Vault Dedicated und Kubernetes Service arbeiten zu können, müssen Sie einen Cluster erstellen und Ihre Vault Dedicated-Instanz mit der AppRole-Authentifizierung konfigurieren.

Kubernetes-Cluster erstellen

Erstellen Sie einen Kubernetes-Cluster in Ihrem IBM Cloud-Konto.

  1. Melden Sie sich in der Befehlszeile bei IBM Cloud über die IBM Cloud-CLI an.

    ibmcloud login
    

    Wenn die Anmeldung fehlschlägt, führen Sie den Befehl ibmcloud login --sso aus, um es erneut zu versuchen. Der Parameter --sso ist erforderlich, wenn Sie sich mit einer föderierten ID anmelden. Wenn diese Option verwendet wird, rufen Sie den Link auf, der in der Ausgabe der Befehlszeilenschnittstelle aufgelistet ist, um einen einmalig verwendbaren Kenncode zu generieren.

  2. Wählen Sie das Konto, die Region und die Ressourcengruppe aus, in der Sie Ihren Cluster erstellen möchten.

    ibmcloud target -r REGION -g RESOURCE_GROUP
    
  3. Erstellen Sie einen Kubernetes-Cluster.

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

    Die Bereitstellung dauert 5 bis 15 Minuten.

  4. Stellen Sie sicher, dass Ihr Cluster erfolgreich bereitgestellt wurde.

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

    Warten Sie, bis sich der Status auf Bereit ändert.

  5. Schaffen Sie den Kontext für Ihren Kubernetes-Cluster.

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

Bereiten Sie Ihre Vault Dedicated-Instanz vor

Konfigurieren Sie Ihre Vault Dedicated-Instanz mit Geheimnissen und der AppRole-Authentifizierung für VSO.

  1. Exportieren Sie Umgebungsvariablen mit den Details Ihrer Vault Dedicated-Instanz.

    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>"
    

    Ersetzen Sie <your-vault_dedicated-instance-id> durch Ihre Vault Dedicated-Instanz-ID, <region> durch Ihre Vault Dedicated-Region und <your-vault-token> durch Ihr Vault-Token.

  2. Erstellen Sie ein Testgeheimnis in 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
    

    Beachten Sie, dass Vault Dedicated kv/ als Einhängepfad für die KV-Secrets-Engine verwendet.

  3. Aktivieren Sie die AppRole-Authentifizierung für 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 erfordert eine Authentifizierung über AppRole, ( Kubernetes ), JWT ( AWS ) oder GCP. Eine direkte Token-Authentifizierung wird nicht unterstützt.

  4. Erstellen Sie eine Richtlinie für 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. Erstellen Sie eine AppRole für 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. Rufen Sie die Rollen-ID und die geheime ID ab.

    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"
    

Vault Secrets Operator installieren

Installieren Sie den Vault Secrets Operator mithilfe von Helm.

  1. Fügen Sie das Repository HashiCorp Helm hinzu.

    helm repo add hashicorp https://helm.releases.hashicorp.com
    helm repo update
    
  2. Installieren Sie den Vault Secrets Operator.

    helm install vault-secrets-operator \
      hashicorp/vault-secrets-operator \
      --namespace vault-secrets-operator-system \
      --create-namespace \
      --version 0.9.0
    
  3. Überprüfen Sie die Installation.

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

    Warten Sie, bis sich alle Pods im Status Running befinden.

  4. Stellen Sie sicher, dass die Custom Resource Definitions (CRDs) installiert sind.

    kubectl get crd | grep vault
    

    Sie sollten CRDs wie vaultauths, vaultconnections, vaultdynamicsecrets, und sehen vaultstaticsecrets.

VaultConnection und VaultAuth konfigurieren

Konfigurieren Sie VSO so, dass eine Verbindung zu Ihrer Vault Dedicated-Instanz hergestellt wird, und nutzen Sie dabei die Ressourcen unter VaultConnection und VaultAuth.

VaultConnection erstellen

  1. Erstellen Sie ein Kubernetes-Geheimnis mit dem AppRole SecretID.

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

    Der Schlüssel muss so benannt sein, id dass VSO ihn erkennt.

  2. Erstellen Sie eine vaultconnection.yaml-Datei.

    touch vaultconnection.yaml
    
  3. Fügen Sie die folgende Konfiguration hinzu.

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

    Ersetzen Sie <VAULT_DEDICATED_ADDR> durch die Adresse Ihrer Vault Dedicated-Instanz. Konfigurieren Sie für die Produktion die richtige TLS, anstatt zu verwenden skipTLSVerify.

  4. Beachten Sie die VaultConnection.

    kubectl apply -f vaultconnection.yaml
    

Erstellen von VaultAuth

  1. Erstellen Sie eine vaultauth.yaml-Datei.

    touch vaultauth.yaml
    
  2. Fügen Sie die folgende Konfiguration hinzu.

    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. Beachten Sie die VaultAuth.

    kubectl apply -f vaultauth.yaml
    
  4. Überprüfen Sie den Status von VaultAuth.

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

Erstellen von VaultStaticSecret

Erstellen Sie eine VaultStaticSecret-Ressource, um Geheimnisse von Vault Dedicated mit Kubernetes zu synchronisieren.

  1. Erstellen Sie eine vaultstaticsecret.yaml-Datei.

    touch vaultstaticsecret.yaml
    
  2. Fügen Sie die folgende Konfiguration hinzu.

    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
    

    Diese Konfiguration ruft das Geheimnis aus in kv/data/example_username_password Vault Dedicated ab und erstellt ein Kubernetes-Geheimnis mit dem Namen my-k8s-secret-vso. Das Geheimnis wird stündlich aktualisiert.

  3. Beachten Sie die VaultStaticSecret.

    kubectl apply -f vaultstaticsecret.yaml
    
  4. Überprüfen Sie, ob das Geheimnis synchronisiert wurde.

    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)'
    

    Beispielausgabe:

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

App für den Cluster implementieren

Stellen Sie eine Anwendung bereit, die die synchronisierten Geheimnisse aus Vault Dedicated verwendet.

  1. Erstellen Sie eine Testbereitstellung.

    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. Überprüfen Sie die Pod-Protokolle.

    kubectl logs test-app-vso -n default
    

    Erwartete Ausgabe:

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

(Optional) Ressourcen bereinigen

Wenn Sie die Ressourcen nicht mehr benötigen, entfernen Sie sie aus Ihrem Konto.

  1. Löschen Sie den Test-Namespace und die Ressourcen.

    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. Vault Secrets Operator deinstallieren.

    helm uninstall vault-secrets-operator -n vault-secrets-operator-system
    kubectl delete namespace vault-secrets-operator-system
    
  3. Löschen Sie Ihren Testcluster.

    ibmcloud ks cluster rm --cluster vso-test-cluster
    
  4. Bereinigung der Testdaten in 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
    

Wichtige Hinweise

Wichtige Überlegungen bei der Verwendung des Vault Secrets Operator:

  1. Authentifizierungsmethoden: VSO unterstützt keine direkte Token-Authentifizierung. Sie müssen eine der folgenden Authentifizierungsmethoden verwenden: AppRole, ( Kubernetes ), JWT ( AWS ) oder GCP.

  2. SecretID Schlüsselname: Beim Erstellen eines Kubernetes-Geheimnisses für die AppRole-Authentifizierung muss der Schlüssel heißen id, nicht oder secret-id secretId.

  3. Aktualisierungsintervall: Das refreshAfter Feld legt fest, wie oft VSO nach Aktualisierungen der Geheimnisse sucht. Ausgewogenes Verhältnis zwischen Aktualität und API-Auslastung.

  4. Automatische Rollouts: Verwenden Sie in rolloutRestartTargets Ihrem VaultStaticSecret, um Deployments automatisch neu zu starten, wenn sich Geheimnisse ändern.

  5. Vault Dedicated-Einbindungspfad: Vault Dedicated verwendet kv/ als Standard-Einbindungspfad für die KV-Secrets-Engine, nicht secret/.

  6. Vault Dedicated-Namespaces: Vault Dedicated verwendet Vault Enterprise-Namespaces. Der Standard-Namespace lautet admin. Geben Sie in Ihrer VaultAuth-Konfiguration stets den richtigen Namespace an.

  7. TLS Konfiguration: Konfigurieren Sie für die Produktion die ordnungsgemäße Zertifikatsvalidierung unter TLS, anstatt zu verwenden skipTLSVerify.

Nächste Schritte

Gut gemacht! In diesem Tutorial haben Sie gelernt, wie Sie den Vault Secrets Operator verwenden, um Vault Dedicated in Ihren Kubernetes-Cluster zu integrieren. Entdecken Sie weitere Funktionen von VSO: