Almacena claves de cuentas de servicio en Hashicorp Vault

Almacena secretos de cuenta de servicio en Hashicorp Vault

Esta función te permite almacenar certificados de cuentas de servicio de Google para Apigee Hybrid en Hashicorp Vault, un Secret Manager externo. Los Secret Managers externos te permiten administrar cómo se almacenan los objetos Secret en Kubernetes, incluida la administración de la residencia de datos y los controles de acceso detallados.

Si no usas Workload Identity en clústeres de GKE ni la federación de Workload Identity en EKS y AKS, tus componentes híbridos de Apigee deben autenticar las cuentas de servicio de Google para poder realizar sus tareas. Existen tres métodos para almacenar y hacer referencia a las claves de cuentas de servicio de Google en Apigee Hybrid:

  • Archivos de certificado de la cuenta de servicio (archivos .json) almacenados en un disco duro Consulta estos valores en tus anulaciones con la propiedad de configuración serviceAccountPath. Por ejemplo:
    logger:
      serviceAccountPath: service-accounts/myhybridorg-apigee-logger.json
    
  • Archivos de certificado de la cuenta de servicio (archivos .json) almacenados en un disco duro Consulta estos valores en tus anulaciones con la propiedad de configuración serviceAccountPath. Consulta Acerca de las cuentas de servicio
  • Certificados de la cuenta de servicio almacenados en un Secret de Kubernetes Consulta estos valores en tus anulaciones con la propiedad de configuración serviceAccountRef. Consulta también Cómo almacenar datos en un Secret de Kubernetes.
  • Certificados de cuentas de servicio almacenados en Hashicorp Vault, que se explican en esta guía. Haz referencia a estas en tus anulaciones con la propiedad de configuración serviceAccountSecretProviderClass.

Configura la opción para almacenar secretos de cuentas de servicio en Vault

Instala el controlador CSI y el proveedor de Vault

Si aún no instalaste el controlador de CSI en tu clúster con Helm, sigue las instrucciones que se indican en Controlador de CSI de Secrets Store: Instalación. Para obtener más información, consulta Cómo instalar el proveedor de CSI de Vault en la documentación de Vault.

Consulta Plataformas y versiones compatibles con Apigee Hybrid para conocer las versiones mínimas del controlador de CSI compatibles con Apigee Hybrid.

Crea políticas, secrets y roles de Vault

Usa la IU o las APIs de Vault a fin de crear secretos y otorgar permisos a las cuentas de servicio de Kubernetes que usa Apigee Hybrid para leerlos.

  1. Crea los secretos específicos de la organización y del entorno en el siguiente formato:
    Clave secretaDatos de los secretos
    secret/data/apigee/orgsakeys
    {
      "cassandraBackup": "***",
      "cassandraRestore": "***",
      "connectAgent": "***",
      "logger": "***",
      "mart": "***",
      "metrics": "***",
      "mint": "***",
      "udca": "***",
      "watcher": "***"
    }
    secret/data/apigee/envsakeys-ENV_NAME
    {
      "runtime": "***",
      "synchronizer": "***",
      "udca": "***". 
    }

    Reemplaza "***" en cada par por el contenido del archivo .json para la cuenta de servicio de Google correspondiente al componente de Apigee. apigee-cassandra-backup y apigee-cassandra-restore usan la cuenta de servicio apigee-cassandra. Por ejemplo:

    {
      "cassandraBackup": "{
        "type": "service_account",
        "project_id": "myhybridorg",
        "private_key_id": "PRIVATE_KEY_ID",
        "private_key": "-----BEGIN PRIVATE KEY-----\nPRIVATE_KEY_TEXT\n-----END PRIVATE KEY-----\n",
        "client_email": "apigee-cassandra@myhybridorg.iam.gserviceaccount.com",
        "client_id": "123456789012345678901",
        "auth_uri": "https://accounts.google.com/o/oauth2/auth",
        "token_uri": "https://oauth2.googleapis.com/token",
        "auth_provider_x509_cert_url": "https://www.googleapis.com/oauth2/v1/certs",
        "client_x509_cert_url": "https://www.googleapis.com/robot/v1/metadata/x509/apigee-cassandra%40myhybridorg.iam.gserviceaccount.com",
        "universe_domain": "googleapis.com"
      }",
      "cassandraRestore":...
    ...
    }
        
  2. Otorga acceso al secreto de la organización. Crea un archivo de texto llamado orgsakeys-auth-policy.txt con el siguiente contenido:
    path "secret/data/apigee/orgsakeys" {
      capabilities = ["read"]
    }
  3. En Vault, crea una política que otorgue acceso al secreto de la organización:
    vault policy write apigee-orgsakeys-auth orgsakeys-auth-policy.txt
  4. Para cada entorno, crea un archivo de texto llamado envsakeys-ENV_NAME-auth-policy.txt con el siguiente contenido:
    path "secret/data/apigee/envsakeys-ENV_NAME" {
      capabilities = ["read"]
    }

    Repite este paso para cada entorno:

  5. En Vault, crea una política que otorgue acceso al secret del entorno:
    vault policy write apigee-envsakeys-ENV_NAME-auth envsakeys-ENV_NAME-auth-policy.txt

    Repite este paso para cada entorno:

  6. Crea una secuencia de comandos generate-encoded-sas.sh con el siguiente contenido:
    # generate-encoded-sas.sh
    
    ORG=$APIGEE_ORG            # Apigee organization name
    ENVS=$APIGEE_ENV_LIST      # comma separated env names, for example: dev,prod
    
    ORG_SHORT_NAME=$(echo $ORG | head -c 15)
    ENCODE=$(echo -n $ORG | shasum -a 256 | head -c 7)
    ORG_ENCODE=$(echo "$ORG_SHORT_NAME-$ENCODE")
    NAMES=apigee-manager,apigee-cassandra-default,apigee-cassandra-backup-sa,apigee-cassandra-restore-sa,apigee-cassandra-schema-setup-${ORG_ENCODE},apigee-cassandra-schema-val-${ORG_ENCODE},apigee-cassandra-user-setup-${ORG_ENCODE},apigee-mart-${ORG_ENCODE},apigee-mint-task-scheduler-${ORG_ENCODE},apigee-connect-agent-${ORG_ENCODE},apigee-watcher-${ORG_ENCODE},apigee-udca-${ORG_ENCODE},apigee-metrics-apigee-telemetry,apigee-open-telemetry-collector-apigee-telemetry,apigee-logger-apigee-telemetry
    
    for ENV in ${ENVS//,/ }
    do
      ENV_SHORT_NAME=$(echo $ENV | head -c 15)
      ENCODE=$(echo -n $ORG:$ENV | shasum -a 256 | head -c 7)
      ENV_ENCODE=$(echo "$ORG_SHORT_NAME-$ENV_SHORT_NAME-$ENCODE")
      NAMES+=,apigee-synchronizer-${ENV_ENCODE},apigee-runtime-${ENV_ENCODE}
    done
    
    echo $NAMES
    
  7. Ejecuta la secuencia de comandos para generar la lista de nombres de la cuenta de servicio para vincular la política con lo siguiente:
    ./generate-encoded-sas.sh

    El resultado debe ser una lista de nombres de cuentas de servicio de Kubernetes separados por comas, similar al siguiente ejemplo:

    ./generate-encoded-sas.sh
    apigee-manager,apigee-cassandra-default,apigee-cassandra-backup-sa,
    apigee-cassandra-restore-sa,apigee-cassandra-schema-setup-myhybrido
    rg-5b044c1,apigee-cassandra-schema-val-myhybridorg-5b044c1,apigee-c
    assandra-user-setup-myhybridorg-5b044c1,apigee-mart-myhybridorg-5b0
    44c1,apigee-mint-task-scheduler-myhybridorg-5b044c1,apigee-connect-
    agent-myhybridorg-5b044c1,apigee-watcher-myhybridorg-5b044c1,apigee
    -udca-myhybridorg-5b044c1,apigee-metrics-apigee-telemetry,apigee-op
    en-telemetry-collector-apigee-telemetry,apigee-logger-apigee-teleme
    try,apigee-synchronizer-myhybridorg-dev-ee52aca,apigee-runtime-myhy
    bridorg-dev-ee52aca,apigee-synchronizer-myhybridorg-prod-2d0221c,ap
    igee-runtime-myhybridorg-prod-2d0221c
  8. Copia el texto de salida y sepáralo en listas, una lista con los nombres de las cuentas de servicio org y una lista separada para el nombre de la cuenta de servicio env para cada entorno. Las cuentas de servicio de org son las primeras en la lista de resultados hasta apigee-logger-apigee-telemetry.

    org del ejemplo anterior:

    apigee-manager,apigee-cassandra-default,apigee-cassandra-backup-sa,
    apigee-cassandra-restore-sa,apigee-cassandra-schema-setup-myhybrido
    rg-5b044c1,apigee-cassandra-schema-val-myhybridorg-5b044c1,apigee-c
    assandra-user-setup-myhybridorg-5b044c1,apigee-mart-myhybridorg-5b0
    44c1,apigee-mint-task-scheduler-myhybridorg-5b044c1,apigee-connect-
    agent-myhybridorg-5b044c1,apigee-watcher-myhybridorg-5b044c1,apigee
    -udca-myhybridorg-5b044c1,apigee-metrics-apigee-telemetry,apigee-op
    en-telemetry-collector-apigee-telemetry,apigee-logger-apigee-teleme
    try

    Los nombres de las cuentas de servicio env tienen el patrón apigee-synchronizer-ORG_NAME-ENV_NAME-HASH_TEXT y apigee-runtime-ORG_NAME-ENV_NAME-HASH_TEXT. Sepáralos en listas separadas para cada entorno. Por ejemplo, el resultado del ejemplo anterior se puede separar en las siguientes dos listas:

    Entorno dev:

    apigee-synchronizer-myhybridorg-dev-ee52aca,apigee-runtime-myhybrid
    org-dev-ee52aca

    Entorno prod:

    apigee-synchronizer-myhybridorg-prod-2d0221c,apigee-runtime-myhybri
    dorg-prod-2d0221c
  9. Con la política, crea un rol de Vault que vincule las cuentas de servicio de Apigee específicas de la organización:
    vault write auth/kubernetes/role/apigee-orgsakeys \
        bound_service_account_names=LIST_OF_ORG_SA_NAMES \
        bound_service_account_namespaces=apigee \
        policies=apigee-orgsakeys-auth \
        ttl=1m
    
  10. En cada entorno, crea un rol de Vault para las claves de su cuenta de servicio:
    vault write auth/kubernetes/role/apigee-envsakeys-ENV_NAME \
        bound_service_account_names=LIST_OF_ENV_NAME_SA_NAMES \
        bound_service_account_namespaces=apigee \
        policies=apigee-envsakeys-ENV_NAME-auth \ 
        ttl=1m
    

    Repite este paso para cada entorno.

Crear objetos SecretProviderClass

El recurso SecretProviderClass le indica al controlador de CSI con qué proveedor se debe comunicar cuando solicita secrets. Las claves de la cuenta de servicio deben configurarse a través de este objeto. En la siguiente tabla, se muestran los nombres de archivos (objectNames) que espera Apigee Hybrid:

Cuenta de servicioNombres de archivos de secrets esperados
Copia de seguridad de Cassandra cassandraBackup
Restablecimiento de Cassandra cassandraRestore
Agente de Connect connectAgent
Logger logger
MART mart
Métricas metrics
Monetización mint
Entorno de ejecución runtime
Sincronizador synchronizer
UDCA udca
Watcher watcher
  1. Usa la siguiente plantilla de SecretProviderClass para configurar este recurso para los secretos específicos de la organización:
    apiVersion: secrets-store.csi.x-k8s.io/v1
    kind: SecretProviderClass
    metadata:
      name: apigee-orgsakeys-spc
    spec:
      provider: vault
      parameters:
        roleName: apigee-orgsakeys
        vaultAddress: VAULT_ADDRESS
        # "objectName" is an alias used within the SecretProviderClass to reference
        # that specific secret. This will also be the filename containing the secret.
        # Apigee Hybrid expects these exact values so they must not be changed.
        # "secretPath" is the path in Vault where the secret should be retrieved.
        # "secretKey" is the key within the Vault secret response to extract a value from.
        objects: |
          - objectName: "cassandraBackup"
            secretPath: ""
            secretKey: ""
          - objectName: "cassandraRestore"
            secretPath: ""
            secretKey: ""
          - objectName: "connectAgent"
            secretPath: ""
            secretKey: ""
          - objectName: "logger"
            secretPath: ""
            secretKey: ""
          - objectName: "mart"
            secretPath: ""
            secretKey: ""
          - objectName: "metrics"
            secretPath: ""
            secretKey: ""
          - objectName: "mint"
            secretPath: ""
            secretKey: ""
          - objectName: "udca"
            secretPath: ""
            secretKey: ""
          - objectName: "watcher"
            secretPath: ""
            secretKey: ""
    

    VAULT_ADDRESS es el extremo en el que se ejecuta tu servidor de Vault. Si Vault se ejecuta en el mismo clúster que Apigee, el formato suele ser http://vault.APIGEE_NAMESPACE.svc.cluster.local:VAULT_SERVICE_PORT.

    Guarda la plantilla en un archivo llamado spc-org.yaml.

  2. Aplica el SecretProviderClass específico de la organización a tu espacio de nombres de Apigee:
    kubectl -n APIGEE_NAMESPACE apply -f spc-org.yaml
  3. En cada entorno, usa la siguiente plantilla SecretProviderClass para configurar este recurso para los secretos específicos del entorno. Repite este paso para cada entorno:
    apiVersion: secrets-store.csi.x-k8s.io/v1
    kind: SecretProviderClass
    metadata:
      name: apigee-envsakeys-ENV_NAME-spc
    spec:
      provider: vault
      parameters:
        roleName: apigee-envsakeys-ENV_NAME
        vaultAddress: VAULT_ADDRESS
        # "objectName" is an alias used within the SecretProviderClass to reference
        # that specific secret. This will also be the filename containing the secret.
        # Apigee Hybrid expects these exact values so they must not be changed.
        # "secretPath" is the path in Vault where the secret should be retrieved.
        # "secretKey" is the key within the Vault secret response to extract a value from.
        objects: |
          - objectName: "runtime"
            secretPath: ""
            secretKey: ""
          - objectName: "synchronizer"
            secretPath: ""
            secretKey: ""
          - objectName: "udca"
            secretPath: ""
            secretKey: ""
    

    VAULT_ADDRESS es el extremo en el que se ejecuta tu servidor de Vault. Si Vault se ejecuta en el mismo clúster y espacio de nombres que Apigee, el formato por lo general será http://vault.APIGEE_NAMESPACE.svc.cluster.local:VAULT_SERVICE_PORT.

    Guarda la plantilla en un archivo llamado spc-env-ENV_NAME.yaml.

  4. Para cada entorno, aplica el SecretProviderClass específico del entorno al espacio de nombres de Apigee:
    kubectl -n APIGEE_NAMESPACE apply -f spc-env-ENV_NAME.yaml

    Repite este paso para cada entorno.

Habilita secretos externos para cuentas de servicio de Google

  1. En tu archivo de anulación, agrega las propiedades de configuración serviceAccountSecretProviderClass y envs[].serviceAccountSecretProviderClass para habilitar el uso de secretos externos para las cuentas de servicio de Google. Puedes quitar o marcar como comentario las propiedades de configuración serviceAccountPath y serviceAccountPaths:
    serviceAccountSecretProviderClass: apigee-orgsakeys-spc
    
    envs:
      - name: ENV_NAME
        serviceAccountSecretProviderClass: apigee-envsakeys-ENV_NAME-spc
  2. Aplica cada gráfico de Helm:
    helm upgrade datastore apigee-datastore/ \
        --install \
        --namespace APIGEE_NAMESPACE \
        --atomic \
        -f overrides.yaml
    
    helm upgrade telemetry apigee-telemetry/ \
        --install \
        --namespace APIGEE_NAMESPACE \
        --atomic \
        -f overrides.yaml
    
    helm upgrade redis apigee-redis/ \
        --install \
        --namespace APIGEE_NAMESPACE \
        --atomic \
        -f overrides.yaml
    
    helm upgrade ORG_NAME apigee-org/ \
        --install \
        --namespace APIGEE_NAMESPACE \
        --atomic \
        -f overrides.yaml
    
  3. Para cada entorno, aplica el gráfico apigee-env:
    helm upgrade ENV_NAME apigee-env/ \
        --install \
        --namespace APIGEE_NAMESPACE \
        --set env=ENV_NAME \
        --atomic \
        -f overrides.yaml
    

Revierte al uso de archivos de certificación de cuenta de servicio

Si necesitas revertir al uso de archivos de certificación de cuenta de servicio de Google almacenados, usa el siguiente procedimiento:

  1. Actualiza tu archivo de anulación como sigue:
    1. Quita o marca como cometario las líneas serviceAccountSecretProviderClass y envs:serviceAccountSecretProviderClass.
    2. Agrega las propiedades de configuración serviceAccountPath y serviceAccountPaths con las rutas de acceso a las cuentas de servicio adecuadas.

    Por ejemplo:

    # serviceAccountSecretProviderClass: apigee-orgsakeys-spc - (commented out)
    
    cassandra:
      backup:
        serviceAccountPath: service-accounts/myhybridorg-apigee-cassandra.json
      restore:
        serviceAccountPath: service-accounts/myhybridorg-apigee-cassandra.json
    
    connectAgent:
      serviceAccountPath: service-accounts/myhybridorg-apigee-mart.json
    
    envs:
      - name: test
      # serviceAccountSecretProviderClass: apigee-envsakeys-spc - (commented out)
        serviceAccountPaths:
          runtime: service-accounts/myhybridorg-apigee-runtime.json
          synchronizer: service-accounts/myhybridorg-apigee-synchronizer.json
    
    logger:
      serviceAccountPath: service-accounts/myhybridorg-apigee-logger.json
    
    mart:
      serviceAccountPath: service-accounts/myhybridorg-apigee-mart.json
    
    metrics:
      serviceAccountPath: service-accounts/myhybridorg-apigee-metrics.json
    
    udca:
      serviceAccountPath: service-accounts/myhybridorg-apigee-udca.json
    
    watcher:
      serviceAccountPath: service-accounts/myhybridorg-apigee-watcher.json
    
  2. Aplica cada gráfico de Helm:
    helm upgrade datastore apigee-datastore/ \
        --install \
        --namespace APIGEE_NAMESPACE \
        --atomic \
        -f overrides.yaml
    
    helm upgrade telemetry apigee-telemetry/ \
        --install \
        --namespace APIGEE_NAMESPACE \
        --atomic \
        -f overrides.yaml
    
    helm upgrade redis apigee-redis/ \
        --install \
        --namespace APIGEE_NAMESPACE \
        --atomic \
        -f overrides.yaml
    
    helm upgrade ORG_NAME apigee-org/ \
        --install \
        --namespace APIGEE_NAMESPACE \
        --atomic \
        -f overrides.yaml
    
  3. Para cada entorno, aplica el gráfico apigee-env:
    helm upgrade ENV_NAME apigee-env/ \
        --install \
        --namespace APIGEE_NAMESPACE \
        --set env=ENV_NAME \
        --atomic \
        -f overrides.yaml
    

    Repite este paso para cada entorno.