Memorizzazione delle chiavi dell'account di servizio in Hashicorp Vault

Archiviazione dei secret degli account di servizio in Hashicorp Vault

Questa funzionalità ti consente di archiviare i certificati degli account di servizio Google per Apigee Hybrid in Hashicorp Vault, un gestore di secret esterno. I gestori di secret esterni ti consentono di gestire la modalità di archiviazione dei dati in Kubernetes, tra cui la gestione della residenza dei dati e dei controlli di accesso granulari.

Se non utilizzi Workload Identity sui cluster GKE o la federazione delle identità per i carichi di lavoro su EKS e AKS, i componenti ibridi di Apigee devono autenticare gli account di servizio Google per poter svolgere le loro attività. Esistono tre metodi per archiviare e fare riferimento alle chiavi dell'account di servizio Google in Apigee hybrid:

  • File delle credenziali dell'account di servizio (file .json) archiviati su un disco rigido. Fai riferimento a questi valori nelle sostituzioni con la proprietà di configurazione serviceAccountPath. Ad esempio: 
    logger:
  serviceAccountPath: service-accounts/myhybridorg-apigee-logger.json
  • File delle credenziali dell'account di servizio (file .json) archiviati su un disco rigido. Fai riferimento a questi valori nelle sostituzioni con la proprietà di configurazione serviceAccountPath. Consulta Informazioni sugli account di servizio.
  • I certificati degli account di servizio archiviati in un secret Kubernetes. Fai riferimento a questi valori nelle sostituzioni con la proprietà di configurazione serviceAccountRef. Consulta Archiviazione dei dati in un secret Kubernetes.
  • I certificati degli account di servizio archiviati in Hashicorp Vault, come spiegato in questa guida. Fai riferimento a questi valori nelle sostituzioni con la proprietà di configurazione serviceAccountSecretProviderClass.

Configurare la memorizzazione dei secret dell'account di servizio in Vault

Installa il driver CSI e il provider Vault

Se non hai ancora installato il driver CSI nel tuo cluster utilizzando Helm, segui le istruzioni riportate in Secrets Store CSI Driver: Installation (Driver CSI Secrets Store: installazione). Per ulteriori informazioni, consulta la sezione Installazione del provider CSI di Vault nella documentazione di Vault.

Consulta la sezione Piattaforme e versioni supportate da Apigee hybrid per le versioni minime del driver CSI supportate da Apigee hybrid.

Creare secret, criteri e ruoli di Vault

Utilizza l'interfaccia utente o le API di Vault per creare secret e concedere le autorizzazioni per gli account di servizio Kubernetes utilizzati da Apigee Hybrid per leggere questi secret.

  1. Crea gli secret specifici per l'organizzazione e l'ambiente nel seguente formato:
    Chiave secretDati secret 
    secret/data/apigee/orgsakeys
    		 
    {
  "cassandraBackup": "***",
  "cassandraRestore": "***",
  "connectAgent": "***",
  "logger": "***",
  "mart": "***",
  "metrics": "***",
  "mint": "***",
  "udca": "***",
  "watcher": "***"
}
    		 
    secret/data/apigee/envsakeys-ENV_NAME
    		 
    {
  "runtime": "***",
  "synchronizer": "***",
  "udca": "***". 
}

    Sostituisci "***" in ogni coppia con i contenuti del file .json per l'account di servizio Google corrispondente al componente apigee. apigee-cassandra-backup e apigee-cassandra-restore utilizzano entrambi l'account di servizio apigee-cassandra. Ad esempio: 

    {
  "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. Concedi l'accesso al secret dell'organizzazione. Crea un file di testo denominato orgsakeys-auth-policy.txt con i seguenti contenuti: 
    path "secret/data/apigee/orgsakeys" {
  capabilities = ["read"]
}
  3. In Vault, crea un criterio che conceda l'accesso al secret dell'organizzazione: 
    vault policy write apigee-orgsakeys-auth orgsakeys-auth-policy.txt
  4. Per ogni ambiente, crea un file di testo denominato envsakeys-ENV_NAME-auth-policy.txt con i seguenti contenuti: 
    path "secret/data/apigee/envsakeys-ENV_NAME" {
  capabilities = ["read"]
}

    Ripeti questo passaggio per ogni ambiente.

  5. In Vault, crea un criterio che conceda l'accesso al secret dell'ambiente: 
    vault policy write apigee-envsakeys-ENV_NAME-auth envsakeys-ENV_NAME-auth-policy.txt

    Ripeti questo passaggio per ogni ambiente.

  6. Crea uno script denominato generate-encoded-sas.sh con i seguenti contenuti: 
    # 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. Esegui lo script per generare l'elenco dei nomi degli account di servizio a cui associare il criterio: 
    ./generate-encoded-sas.sh

    L'output dovrebbe essere un elenco di nomi di account di servizio Kubernetes separati da virgole, simile al seguente esempio: 

    ./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 il testo di output e separalo in elenchi, un elenco per i nomi degli account di servizio org e un elenco separato per il nome dell'account di servizio env per ogni ambiente. Gli account di servizio org sono i primi nell'elenco di output fino a apigee-logger-apigee-telemetry.

    L'elenco dei nomi dei servizi org dell'esempio precedente: 

    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

    I nomi degli account di servizio env hanno il pattern apigee-synchronizer-ORG_NAME-ENV_NAME-HASH_TEXT e apigee-runtime-ORG_NAME-ENV_NAME-HASH_TEXT. Separali in elenchi distinti per ogni ambiente. Ad esempio, l'output dell'esempio precedente può essere suddiviso nei seguenti due elenchi:

    dev ambiente: 

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

    prod ambiente: 

    apigee-synchronizer-myhybridorg-prod-2d0221c,apigee-runtime-myhybri
dorg-prod-2d0221c
  9. Utilizzando il criterio, crea un ruolo Vault che vincola gli account di servizio Apigee specifici dell'organizzazione: 
    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. Per ogni ambiente, crea un ruolo Vault per le relative chiavi dell'account di servizio: 
    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

    Ripeti questo passaggio per ogni ambiente.

Creare oggetti SecretProviderClass

La risorsa SecretProviderClass indica al driver CSI con quale fornitore comunicare quando richiede i secret. Le chiavi dell'account di servizio devono essere configurate tramite questo oggetto. La tabella seguente mostra i nomi dei file (objectNames) previsti da Apigee Hybrid:

Service accountNomi dei file secret previsti
Backup di Cassandra cassandraBackup
Ripristino di Cassandra cassandraRestore
Agente Connect connectAgent
Logger logger
MART mart
Metriche metrics
Monetizzazione mint
Runtime runtime
Sincronizzatore synchronizer
UDCA udca
Watcher watcher
  1. Utilizza il seguente modello SecretProviderClass per configurare questa risorsa per i secret specifici dell'organizzazione: 
    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 è l'endpoint in cui è in esecuzione il server Vault. Se Vault è in esecuzione nello stesso cluster di Apigee, in genere il formato sarà http://vault.APIGEE_NAMESPACE.svc.cluster.local:VAULT_SERVICE_PORT.

    Salva il modello in un file denominato spc-org.yaml.

  2. Applica SecretProviderClass specifico per l'organizzazione allo spazio dei nomi apigee: 
    kubectl -n APIGEE_NAMESPACE apply -f spc-org.yaml
  3. Per ogni ambiente, utilizza il seguente modello SecretProviderClass per configurare questa risorsa per i secret specifici dell'ambiente. Ripeti questo passaggio per ogni ambiente: 
    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 è l'endpoint in cui è in esecuzione il server Vault. Se Vault è in esecuzione nello stesso cluster e nello stesso spazio dei nomi di Apigee, in genere il formato sarà http://vault.APIGEE_NAMESPACE.svc.cluster.local:VAULT_SERVICE_PORT.

    Salva il modello in un file denominato spc-env-ENV_NAME.yaml.

  4. Per ogni ambiente, applica SecretProviderClass specifico per l'ambiente allo spazio dei nomi apigee: 
    kubectl -n APIGEE_NAMESPACE apply -f spc-env-ENV_NAME.yaml

    Ripeti questo passaggio per ogni ambiente.

Attivare i secret esterni per gli account di servizio Google

  1. Nel file delle sostituzioni, aggiungi le proprietà di configurazione serviceAccountSecretProviderClass e envs[].serviceAccountSecretProviderClass per abilitare l'utilizzo di secret esterni per gli account di servizio Google. Puoi rimuovere o commentare le proprietà di configurazione serviceAccountPath e serviceAccountPaths: 
    serviceAccountSecretProviderClass: apigee-orgsakeys-spc

envs:
  - name: ENV_NAME
    serviceAccountSecretProviderClass: apigee-envsakeys-ENV_NAME-spc
  2. Applica ogni grafico 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. Per ogni ambiente, applica il grafico apigee-env: 
    helm upgrade ENV_NAME apigee-env/ \
    --install \
    --namespace APIGEE_NAMESPACE \
    --set env=ENV_NAME \
    --atomic \
    -f overrides.yaml

Ripristino del precedente utilizzo dei file delle credenziali dell'account di servizio

Se devi eseguire il rollback all'utilizzo dei file dei certificati dell'account di servizio Google archiviati, segui la procedura riportata di seguito:

  1. Aggiorna il file delle sostituzioni:
    1. Rimuovi o commenta le righe serviceAccountSecretProviderClass e envs:serviceAccountSecretProviderClass.
    2. Aggiungi le proprietà di configurazione serviceAccountPath e serviceAccountPaths con i percorsi agli account di servizio appropriati.

    Ad esempio:

    # 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. Applica ogni grafico 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. Per ogni ambiente, applica il grafico apigee-env: 
    helm upgrade ENV_NAME apigee-env/ \
    --install \
    --namespace APIGEE_NAMESPACE \
    --set env=ENV_NAME \
    --atomic \
    -f overrides.yaml

    Ripeti questo passaggio per ogni ambiente.