Proteggi i segreti delle app con Vault Dedicated e Vault Secrets Operator

In questo tutorial imparerai come utilizzare IBM Cloud Vault Enterprise per gestire i segreti delle applicazioni in esecuzione nel tuo cluster IBM Cloud Kubernetes Service tramite il Vault Secrets Operator, HashiCorp's l'operatore ufficiale Kubernetes.

Sei uno sviluppatore che lavora in un'organizzazione che utilizza Kubernetes Service per distribuire applicazioni containerizzate su IBM Cloud. Il tuo team utilizza HashiCorp Vault per la gestione dei segreti e desideri un'integrazione nativa con Vault per i tuoi carichi di lavoro su Kubernetes. L'Operator Vault Secrets (VSO) offre un'integrazione approfondita con Vault, supportando funzionalità avanzate quali i segreti dinamici, la rotazione dei segreti e i metodi di autenticazione nativi di Vault.

Con Vault Dedicated e Vault Secrets Operator, puoi sfruttare appieno le potenzialità di " HashiCorp Vault " nel tuo ambiente Kubernetes. Vault Secrets Operator offre un modo nativo per l' Kubernetes e di gestire i segreti di Vault, supportando sia i segreti statici che quelli dinamici. Ad esempio, considera il seguente scenario:

Il diagramma illustra il flusso di base tra Secrets Manager e il cluster Kubernetes.
Flusso dei segreti esterni

  1. In qualità di sviluppatore, utilizzi Vault Dedicated per archiviare i segreti di un'applicazione che desideri distribuire in un cluster di Kubernetes.
  2. Per configurare il Vault Secrets Operator, è necessario utilizzare le risorse VaultConnection e VaultAuth per connettersi alla propria istanza di Vault Dedicated.
  3. Si creano risorse di tipo " VaultStaticSecret " o " VaultDynamicSecret " che definiscono quali segreti sincronizzare.
  4. Durante l'esecuzione dell'applicazione, VSO recupera i dati segreti da Vault Dedicated e crea dei segreti " Kubernetes " per il tuo cluster.
  5. VSO monitora e sincronizza costantemente le informazioni riservate, gestendo automaticamente la rotazione e gli aggiornamenti.

Vault Secrets Operator è uno strumento ufficiale di HashiCorp. Per assistenza e risoluzione dei problemi, consultare la documentazione ufficiale.

Prima di iniziare

Prima di iniziare, assicurati di disporre dei diritti di amministratore sulla piattaforma, in modo da poter creare le credenziali degli account e assegnare le risorse. Sono inoltre necessari i seguenti prerequisiti:

Configura l'ambiente

Per utilizzare Vault Dedicated e Kubernetes Service, è necessario creare un cluster e configurare l'istanza di Vault Dedicated con l'autenticazione AppRole.

Crea un cluster Kubernetes

Crea un cluster “ Kubernetes ” nel tuo account IBM Cloud.

  1. Dalla riga di comando, accedi a IBM Cloud tramite la CLI di IBM Cloud.

    ibmcloud login
    

    Se l'accesso non riesce, esegui il comando ibmcloud login --sso e prova di nuovo. Il parametro --sso è obbligatorio quando accedi con un ID federato. Se viene utilizzata questa opzione, vai al link elencato nell'output della CLI per generare una passcode monouso.

  2. Selezionare l'account, la regione e il gruppo di risorse in cui si desidera creare il cluster.

    ibmcloud target -r REGION -g RESOURCE_GROUP
    
  3. Creare 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
    

    Il processo di provisioning richiede dai 5 ai 15 minuti.

  4. Verifica che il tuo cluster sia stato configurato correttamente.

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

    Attendi che lo stato diventi “Pronto ”.

  5. Imposta il contesto per il tuo cluster Kubernetes.

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

Prepara la tua istanza dedicata di Vault

Configura la tua istanza dedicata di Vault con i segreti e l'autenticazione tramite AppRole per VSO.

  1. Esporta le variabili d'ambiente con i dettagli della tua istanza 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>"
    

    Sostituisci <your-vault_dedicated-instance-id> con l'ID della tua istanza di Vault Dedicated, <region> con la tua regione di Vault Dedicated e <your-vault-token> con il tuo token di Vault.

  2. Crea un segreto di prova 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
    

    Si noti che Vault Dedicated utilizza kv/ come percorso di montaggio per il motore dei segreti KV.

  3. Abilitare l’autenticazione “ AppRole ” per 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 richiede l'autenticazione tramite AppRole, Kubernetes, JWT, AWS o GCP. Non supporta l'autenticazione diretta tramite token.

  4. Creare una politica per 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. Creare un file “ AppRole ” per 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. Recupera l'ID del ruolo e l'ID segreto.

    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"
    

Installa Vault Secrets Operator

Installa Vault Secrets Operator utilizzando Helm.

  1. Aggiungi il repository HashiCorp Helm.

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

    helm install vault-secrets-operator \
      hashicorp/vault-secrets-operator \
      --namespace vault-secrets-operator-system \
      --create-namespace \
      --version 0.9.0
    
  3. Verificare l'installazione.

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

    Attendere che tutti i pod siano nello stato “Running ”.

  4. Verificare che le definizioni delle risorse personalizzate (CRD) siano installate.

    kubectl get crd | grep vault
    

    Dovresti consultare CRD come vaultauths, vaultconnections, vaultdynamicsecrets e vaultstaticsecrets.

Configurare VaultConnection e VaultAuth

Configurare VSO per connettersi all'istanza Vault Dedicated utilizzando le risorse VaultConnection e VaultAuth.

Crea VaultConnection

  1. Crea un segreto " Kubernetes " utilizzando l' AppRole SecretID.

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

    Affinché VSO la riconosca, la chiave deve essere denominata “ id ”.

  2. Crea un file denominato “ vaultconnection.yaml ”.

    touch vaultconnection.yaml
    
  3. Aggiungere la seguente configurazione.

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

    Sostituisci <VAULT_DEDICATED_ADDR> con l'indirizzo della tua istanza Vault Dedicated. Per l'ambiente di produzione, configurare un TLS corretto invece di utilizzare skipTLSVerify.

  4. Applicare l' VaultConnection.

    kubectl apply -f vaultconnection.yaml
    

Crea VaultAuth

  1. Crea un file denominato “ vaultauth.yaml ”.

    touch vaultauth.yaml
    
  2. Aggiungere la seguente configurazione.

    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. Applicare l' VaultAuth.

    kubectl apply -f vaultauth.yaml
    
  4. Verificare lo stato di " VaultAuth ".

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

Crea VaultStaticSecret

Crea una risorsa " VaultStaticSecret " per sincronizzare i segreti da Vault Dedicated a Kubernetes.

  1. Crea un file denominato “ vaultstaticsecret.yaml ”.

    touch vaultstaticsecret.yaml
    
  2. Aggiungere la seguente configurazione.

    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
    

    Questa configurazione recupera il segreto da kv/data/example_username_password in Vault Dedicated e crea un segreto Kubernetes denominato my-k8s-secret-vso. Il segreto si aggiorna ogni ora.

  3. Applicare l' VaultStaticSecret.

    kubectl apply -f vaultstaticsecret.yaml
    
  4. Verifica che il segreto sia stato sincronizzato.

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

    Output di esempio:

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

Distribuire un'app sul cluster

Distribuisci un'applicazione che utilizza i segreti sincronizzati da Vault Dedicated.

  1. Crea una distribuzione di prova.

    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. Controlla i log del pod.

    kubectl logs test-app-vso -n default
    

    Output previsto:

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

(Facoltativo) Liberare le risorse

Se non hai più bisogno delle risorse, rimuovile dal tuo account.

  1. Elimina lo spazio dei nomi di prova e le risorse.

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

    helm uninstall vault-secrets-operator -n vault-secrets-operator-system
    kubectl delete namespace vault-secrets-operator-system
    
  3. Elimina il tuo cluster di prova.

    ibmcloud ks cluster rm --cluster vso-test-cluster
    
  4. Eliminare i dati di test dedicati dal Vault.

    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
    

Note di interesse

Aspetti fondamentali da tenere in considerazione quando si utilizza Vault Secrets Operator:

  1. Metodi di autenticazione: VSO non supporta l'autenticazione diretta tramite token. È necessario utilizzare i metodi di autenticazione AppRole, Kubernetes, JWT, AWS o GCP.

  2. SecretID Nome della chiave: quando si crea un segreto " Kubernetes " per l'autenticazione tramite " AppRole ", la chiave deve essere denominata " id", non " secret-id " né " secretId".

  3. Intervallo di aggiornamento: il campo " refreshAfter " determina la frequenza con cui VSO verifica la presenza di aggiornamenti dei segreti. Equilibrio tra freschezza e carico API.

  4. Distribuzioni automatiche: utilizza rolloutRestartTargets nel tuo VaultStaticSecret per riavviare automaticamente le distribuzioni quando i segreti cambiano.

  5. Percorso di montaggio di Vault Dedicated: Vault Dedicated utilizza kv/ come percorso di montaggio predefinito per il motore dei segreti KV, anziché secret/.

  6. Spazi dei nomi di Vault Dedicated: Vault Dedicated utilizza gli spazi dei nomi di Vault Enterprise. Lo spazio dei nomi predefinito è admin. Specificare sempre lo spazio dei nomi corretto nella configurazione di VaultAuth.

  7. TLS Configurazione: in ambiente di produzione, configurare una corretta verifica dei certificati TLS invece di utilizzare skipTLSVerify.

Passi successivi

Ottimo lavoro! In questo tutorial hai imparato a utilizzare Vault Secrets Operator per integrare Vault Dedicated con il tuo cluster di Kubernetes. Scopri altre funzionalità di VSO: