Almacenar claves de cuentas de servicio en HashiCorp Vault

Almacenar secretos de cuentas 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 gestor de secretos externo. Los gestores de secretos externos te permiten gestionar cómo se almacenan los datos en Kubernetes, así como la residencia de los datos y los controles de acceso detallados.

Si no usas Workload Identity en clústeres de GKE ni Workload Identity Federation en EKS y AKS, tus componentes de Apigee hybrid deben autenticar las cuentas de servicio de Google para poder realizar sus tareas. Hay tres métodos para almacenar y hacer referencia a las claves de cuentas de servicio de Google en Apigee hybrid:

• Archivos de certificado de cuenta de servicio (archivos .json) almacenados en un disco duro. Haz referencia a ellas en tus anulaciones con la propiedad de configuración serviceAccountPath. Por ejemplo:

  logger:
    serviceAccountPath: service-accounts/myhybridorg-apigee-logger.json
  

• Archivos de certificado de cuenta de servicio (archivos .json) almacenados en un disco duro. Haz referencia a ellas en tus anulaciones con la propiedad de configuración serviceAccountPath. Consulta Información sobre las cuentas de servicio.
• Certificados de cuentas de servicio almacenados en un secreto de Kubernetes. Haz referencia a ellas en tus anulaciones con la propiedad de configuración serviceAccountRef. Consulta Almacenar datos en un secreto de Kubernetes.
• Certificados de cuentas de servicio almacenados en HashiCorp Vault, tal como se explica en esta guía. Haz referencia a ellas en tus anulaciones con la propiedad de configuración serviceAccountSecretProviderClass.

Configurar el almacenamiento de secretos de cuentas de servicio en Vault

Instalar el controlador de CSI y el proveedor de Vault

Si aún no has instalado el controlador CSI en tu clúster con Helm, sigue las instrucciones que se indican en Controlador CSI de Secrets Store: instalación. Para obtener más información, consulta el artículo Instalar el proveedor de CSI de Vault en la documentación de Vault.

Consulta las plataformas y versiones compatibles con Apigee hybrid para ver las versiones mínimas del controlador CSI compatibles con Apigee hybrid.

Crear secretos, políticas y roles de Vault

Usa la interfaz de usuario o las APIs de Vault para crear secretos y conceder permisos a las cuentas de servicio de Kubernetes que usa Apigee Hybrid para leer esos secretos.

1. Crea los secretos específicos de la organización y del entorno con el siguiente formato:

   Clave secreta	Datos secretos
   secret/data/apigee/orgsakeys	{ "cassandraBackup": "***", "cassandraRestore": "***", "connectAgent": "***", "logger": "***", "mart": "***", "metrics": "***", "mint": "***", "udca": "***", "watcher": "***" }
   secret/data/apigee/envsakeys-ENV_NAME	{ "runtime": "***", "synchronizer": "***", "udca": "***". }

   Sustituye el "***" de cada par por el contenido del archivo .json de la cuenta de servicio de Google correspondiente al componente de Apigee. Tanto apigee-cassandra-backup como 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. Concede 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 conceda acceso al secreto de la organización:

   vault policy write apigee-orgsakeys-auth orgsakeys-auth-policy.txt

4. En 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 en cada entorno.

5. En Vault, crea una política que conceda acceso al secreto del entorno:

   vault policy write apigee-envsakeys-ENV_NAME-auth envsakeys-ENV_NAME-auth-policy.txt

   Repite este paso en cada entorno.

6. Crea una secuencia de comandos llamada 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 cuentas de servicio a las que se va a vincular la política:

   ./generate-encoded-sas.sh

   El resultado debe ser una lista de nombres de cuentas de servicio de Kubernetes separados por comas, como en el 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 para los nombres de las cuentas de servicio org y otra para los nombres de las cuentas de servicio env de cada entorno. Las cuentas de servicio de org son las primeras de la lista de resultados, hasta apigee-logger-apigee-telemetry.

   Lista de nombres de servicios 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 siguen el patrón apigee-synchronizer-ORG_NAME-ENV_NAME-HASH_TEXT y apigee-runtime-ORG_NAME-ENV_NAME-HASH_TEXT. Sepáralos en listas independientes para cada entorno. Por ejemplo, la salida del ejemplo anterior se puede separar en las dos listas siguientes:

   dev entorno:

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

   prod entorno:

   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 sus claves de 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 en cada entorno.

Crear objetos SecretProviderClass

El recurso SecretProviderClass indica al controlador CSI con qué proveedor debe comunicarse al solicitar secretos. Las claves de cuenta de servicio deben configurarse mediante este objeto. En la siguiente tabla se muestran los nombres de archivo (objectNames) que espera Apigee Hybrid:

Cuenta de servicio	Nombres de archivo de secretos esperados
Copia de seguridad de Cassandra	cassandraBackup
Restauración de Cassandra	cassandraRestore
Agente de Connect	connectAgent
Logger	logger
MART	mart
Métricas	metrics
Monetización	mint
Tiempo de ejecución	runtime
Sincronizador	synchronizer
UDCA	udca
Watcher	watcher

1. Usa la siguiente plantilla 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 endpoint en el que se ejecuta tu servidor de Vault. Si Vault se ejecuta en el mismo clúster que Apigee, el formato será generalmente 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 apply -f spc-org.yaml

3. En cada entorno, utilice la siguiente plantilla SecretProviderClass para configurar este recurso con los secretos específicos del entorno. Repite este paso en 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 endpoint en el que se ejecuta tu servidor de Vault. Si Vault se ejecuta en el mismo clúster que Apigee, el formato será generalmente http://vault.APIGEE_NAMESPACE.svc.cluster.local:VAULT_SERVICE_PORT.

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

4. En cada entorno, aplica el SecretProviderClass específico del entorno a tu espacio de nombres de Apigee:

   kubectl -n apigee apply -f spc-env-ENV_NAME.yaml

   Repite este paso en cada entorno.

Habilitar secretos externos para cuentas de servicio de Google

1. En el archivo de anulaciones, añade las propiedades de configuración serviceAccountSecretProviderClass y envs[].serviceAccountSecretProviderClass para habilitar el uso de secretos externos en las cuentas de servicio de Google. Puedes quitar o comentar 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 \
       --atomic \
       -f overrides.yaml
   

   helm upgrade telemetry apigee-telemetry/ \
       --install \
       --namespace apigee \
       --atomic \
       -f overrides.yaml
   

   helm upgrade redis apigee-redis/ \
       --install \
       --namespace apigee \
       --atomic \
       -f overrides.yaml
   

   helm upgrade ORG_NAME apigee-org/ \
       --install \
       --namespace apigee \
       --atomic \
       -f overrides.yaml
   

3. En cada entorno, aplica el gráfico apigee-env:

   helm upgrade ENV_NAME apigee-env/ \
       --install \
       --namespace apigee \
       --set env=ENV_NAME \
       --atomic \
       -f overrides.yaml
   

Volver a usar archivos de certificado de cuenta de servicio

Si necesitas volver a usar los archivos de certificado de la cuenta de servicio de Google almacenados, sigue este procedimiento:

1. Actualiza el archivo de anulaciones:
   1. Elimina o comenta las líneas serviceAccountSecretProviderClass y envs:serviceAccountSecretProviderClass.
   2. Añade las propiedades de configuración serviceAccountPath y serviceAccountPaths con las rutas a las cuentas de servicio correspondientes.

   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 \
       --atomic \
       -f overrides.yaml
   

   helm upgrade telemetry apigee-telemetry/ \
       --install \
       --namespace apigee \
       --atomic \
       -f overrides.yaml
   

   helm upgrade redis apigee-redis/ \
       --install \
       --namespace apigee \
       --atomic \
       -f overrides.yaml
   

   helm upgrade ORG_NAME apigee-org/ \
       --install \
       --namespace apigee \
       --atomic \
       -f overrides.yaml
   

3. En cada entorno, aplica el gráfico apigee-env:

   helm upgrade ENV_NAME apigee-env/ \
       --install \
       --namespace apigee \
       --set env=ENV_NAME \
       --atomic \
       -f overrides.yaml
   

   Repite este paso en cada entorno.