Protege los secretos de las aplicaciones con Vault Dedicated y Vault Secrets Operator

En este tutorial, aprenderás a utilizar IBM Cloud Vault Enterprise para gestionar secretos de aplicaciones que se ejecutan en tu clúster de IBM Cloud Kubernetes Service mediante el operador Vault Secrets, HashiCorp's operador oficial de Kubernetes.

Eres desarrollador en una organización que utiliza Kubernetes Service para implementar aplicaciones en contenedores en IBM Cloud. Tu equipo utiliza HashiCorp Vault para la gestión de secretos y deseas una integración nativa con Vault para tus cargas de trabajo de Kubernetes. El Vault Secrets Operator (VSO) ofrece una integración profunda con Vault y admite funciones avanzadas como secretos dinámicos, rotación de secretos y métodos de autenticación nativos de Vault.

Con Vault Dedicated y Vault Secrets Operator, puedes aprovechar todo el potencial de HashiCorp Vault en tu entorno de Kubernetes. Vault Secrets Operator ofrece una forma nativa de Kubernetes para trabajar con secretos de Vault, compatible tanto con secretos estáticos como dinámicos. Por ejemplo, considere el siguiente escenario:

El diagrama muestra el flujo básico entre Secrets Manager y tu clúster de Kubernetes. Flujo" caption-side="bottom"} de secretos{: caption="externos

  1. Como desarrollador, utilizas Vault Dedicated para almacenar secretos de una aplicación que deseas implementar en un clúster de Kubernetes.
  2. El operador de secretos de Vault se configura con los recursos VaultConnection y VaultAuth para conectarse a su instancia dedicada de Vault.
  3. Se crean recursos de VaultStaticSecret o VaultDynamicSecret que definen qué secretos se deben sincronizar.
  4. En el momento de la ejecución de la aplicación, VSO recupera los datos secretos de Vault Dedicated y crea secretos de Kubernetes para tu clúster.
  5. VSO supervisa y sincroniza continuamente los secretos, gestionando automáticamente su rotación y actualización.

Vault Secrets Operator es una herramienta oficial de HashiCorp. Para obtener asistencia y resolver problemas, consulta la documentación oficial.

Antes de empezar

Antes de empezar, asegúrese de que tiene Acceso a la plataforma Administrador para poder crear credenciales de cuenta y recursos de suministro. También necesita los siguientes requisitos previos:

Configurar el entorno

Para trabajar con Vault Dedicated y Kubernetes Service, debes crear un clúster y configurar tu instancia de Vault Dedicated con la autenticación AppRole.

Creación de un clúster de Kubernetes

Crea un clúster de Kubernetes en tu cuenta de IBM Cloud.

  1. Desde la línea de mandatos, inicie la sesión en IBM Cloud mediante la CLI de IBM Cloud.

    ibmcloud login
    

    Si el inicio de sesión falla, ejecute el mandato ibmcloud login --sso para volver a intentarlo. Se requiere el parámetro --sso para iniciar sesión con un ID federado. Si se utiliza esta opción, vaya al enlace que se muestra en la salida de la CLI para generar una contraseña de uso único.

  2. Selecciona la cuenta, la región y el grupo de recursos en los que deseas crear tu clúster.

    ibmcloud target -r REGION -g RESOURCE_GROUP
    
  3. Cree un clúster de 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
    

    El aprovisionamiento tarda entre 5 y 15 minutos.

  4. Comprueba que tu clúster se haya aprovisionado correctamente.

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

    Espera a que el estado cambie a Listo.

  5. Establece el contexto para tu clúster de Kubernetes.

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

Prepara tu instancia dedicada de Vault

Configura tu instancia dedicada de Vault con secretos y autenticación AppRole para VSO.

  1. Exporta las variables de entorno junto con los datos de tu instancia de 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>"
    

    Sustituye <your-vault_dedicated-instance-id> por el ID de tu instancia de Vault Dedicated, <region> por tu región de Vault Dedicated y <your-vault-token> por tu token de Vault.

  2. Crea un secreto de prueba en 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
    

    Ten en cuenta que Vault Dedicated utiliza kv/ como ruta de montaje para el motor de secretos KV.

  3. Habilitar la autenticación AppRole para 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 requiere autenticación mediante AppRole, Kubernetes, JWT, AWS o GCP. No admite la autenticación directa mediante token.

  4. Elaborar una política para 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. Crear un AppRole para 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. Obtén el ID de rol y el ID secreto.

    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"
    

Instalar Vault Secrets Operator

Instala Vault Secrets Operator utilizando Helm.

  1. Añade el repositorio HashiCorp Helm.

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

    helm install vault-secrets-operator \
      hashicorp/vault-secrets-operator \
      --namespace vault-secrets-operator-system \
      --create-namespace \
      --version 0.9.0
    
  3. Verifique la instalación.

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

    Espera hasta que todos los pods estén en estado Running.

  4. Comprueba que las definiciones de recursos personalizados (CRD) estén instaladas.

    kubectl get crd | grep vault
    

    Deberías ver CRD como vaultauths, vaultconnections, vaultdynamicsecrets, y vaultstaticsecrets.

Configurar VaultConnection y VaultAuth

Configura VSO para conectarte a tu instancia de Vault Dedicated utilizando los recursos VaultConnection y VaultAuth.

Crear un VaultConnection

  1. Crea un secreto de Kubernetes con el servicio AppRole SecretID.

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

    La clave debe tener un nombre para id que VSO la reconozca.

  2. Cree un archivo vaultconnection.yaml.

    touch vaultconnection.yaml
    
  3. Añade la siguiente configuración.

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

    Sustituye <VAULT_DEDICATED_ADDR> por la dirección de tu instancia dedicada de Vault. Para la producción, configura el TLS adecuado en lugar de utilizar skipTLSVerify.

  4. Aplica el estilo VaultConnection.

    kubectl apply -f vaultconnection.yaml
    

Crear un VaultAuth

  1. Cree un archivo vaultauth.yaml.

    touch vaultauth.yaml
    
  2. Añade la siguiente configuración.

    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. Aplica el estilo VaultAuth.

    kubectl apply -f vaultauth.yaml
    
  4. Comprueba el estado de VaultAuth.

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

Crear un VaultStaticSecret

Crea un recurso VaultStaticSecret para sincronizar los secretos de Vault Dedicated con Kubernetes.

  1. Cree un archivo vaultstaticsecret.yaml.

    touch vaultstaticsecret.yaml
    
  2. Añade la siguiente configuración.

    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
    

    Esta configuración recupera el secreto de kv/data/example_username_password en Vault Dedicated y crea un secreto de Kubernetes denominado my-k8s-secret-vso. El secreto se actualiza cada hora.

  3. Aplica el estilo VaultStaticSecret.

    kubectl apply -f vaultstaticsecret.yaml
    
  4. Comprueba que el secreto se haya sincronizado.

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

    Salida de ejemplo:

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

Despliegue una aplicación en el clúster

Implementa una aplicación que utilice los secretos sincronizados desde Vault Dedicated.

  1. Crea una implementación de prueba.

    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. Comprueba los registros del pod.

    kubectl logs test-app-vso -n default
    

    Salida esperada:

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

(Opcional) Limpiar los recursos

Si ya no necesitas los recursos, elimínalos de tu cuenta.

  1. Elimina el espacio de nombres de prueba y los recursos.

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

    helm uninstall vault-secrets-operator -n vault-secrets-operator-system
    kubectl delete namespace vault-secrets-operator-system
    
  3. Elimina tu clúster de prueba.

    ibmcloud ks cluster rm --cluster vso-test-cluster
    
  4. Limpiar los datos de prueba 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
    

Notas de interés

Aspectos clave a tener en cuenta al utilizar Vault Secrets Operator:

  1. Métodos de autenticación: VSO no admite la autenticación directa mediante token. Debe utilizar los métodos de autenticación AppRole, Kubernetes, JWT, AWS o GCP.

  2. SecretID Nombre de la clave: al crear un secreto de Kubernetes para la autenticación de AppRole, la clave debe llamarse id, y no secret-id ni secretId.

  3. Intervalo de actualización: El refreshAfter campo determina la frecuencia con la que VSO comprueba si hay actualizaciones de secretos. Equilibrio entre la frescura y la carga de la API.

  4. Implementaciones automáticas: utiliza en rolloutRestartTargets tu VaultStaticSecret para reiniciar automáticamente las implementaciones cuando cambien los secretos.

  5. Ruta de montaje de Vault Dedicated: Vault Dedicated utiliza kv/ como ruta de montaje predeterminada para el motor de secretos KV, en lugar de secret/.

  6. Espacios de nombres de Vault Dedicated: Vault Dedicated utiliza los espacios de nombres de Vault Enterprise. El espacio de nombres predeterminado es admin. Especifica siempre el espacio de nombres correcto en la configuración de VaultAuth.

  7. TLS Configuración: Para el entorno de producción, configura la validación adecuada del certificado TLS en lugar de utilizar skipTLSVerify.

Próximos pasos

¡Buen trabajo! En este tutorial, has aprendido a utilizar Vault Secrets Operator para integrar Vault Dedicated con tu clúster de Kubernetes. Descubre más funciones de VSO: