Questa pagina è stata tradotta dall'API Cloud Translation.

Archiviazione dei dati in un gestore di secret esterno

Archiviazione dei dati in un gestore dei secret esterno

Questa guida spiega come archiviare e gestire i seguenti tipi di informazioni nel servizio di archiviazione dei secret esterni, Hashicorp Vault, anziché nel file overrides.yaml.

AX Hash Salt
Password Redis
Chiavi di crittografia

Per archiviare altri tipi di informazioni in Vault, vedi:

Prerequisiti

Un driver CSI di Kubernetes Secrets Store. Puoi installarlo seguendo le istruzioni riportate in Secrets Store CSI Driver: Installation. Per le versioni supportate, consulta Piattaforme e versioni supportate di Apigee Hybrid: driver CSI Secret Store.
Il provider CSI Vault. Puoi installarlo seguendo le istruzioni riportate in Installazione del provider CSI Vault. Per le versioni supportate, consulta Piattaforme e versioni supportate di Apigee hybrid: Vault.

Procedura

Crea i secret, le policy e i ruoli di Vault.

Utilizza l'interfaccia utente o le API di Vault per creare secret e concedere le autorizzazioni agli account di servizio Kubernetes di Apigee per leggere questi secret, come descritto qui. I secret devono essere costituiti da una chiave e uno o più valori, come mostrato nella tabella seguente:

Chiave segreta	Dati secret
`secret/data/apigee/axhashsalt`	{ "ax-hash-salt": "`AX_HASH_SALT_VALUE`" }
`secret/data/apigee/redis`	{ "redis-password": "`REDIS_PASSWORD_VALUE`" }
`secret/data/apigee/orgencryptionkeys`	{ "kmsEncryptionKey": "`KMS_ENCRYPTION_KEY_VALUE`" "kvmEncryptionKey": "`KVM_ENCRYPTION_KEY_VALUE`" "contractEncryptionKey": "`CONTRACT_ENCRYPTION_KEY_VALUE`" } Importante: il valore di `contractEncryptionKey` deve essere una stringa codificata in base64 con una lunghezza di 16, 24 o 32 caratteri. Per saperne di più, consulta la sezione Crittografia dei dati.
`secret/data/apigee/envencryptionkeys`	{ "cacheEncryptionKey": "`CACHE_ENCRYPTION_KEY_VALUE`" "kvmEncryptionKey": "`KVM_ENCRYPTION_KEY_VALUE`" "envKvmEncryptionKey": "`ENV_KVM_ENCRYPTION_KEY_VALUE`" "kmsEncryptionKey": "`KMS_ENCRYPTION_KEY_VALUE`" }

In Vault, crea policy che concedano l'accesso ai secret:

cat axhashsalt-auth-policy.txt
path "secret/data/apigee/axhashsalt" {
  capabilities = ["read"]
}
cat redis-auth-policy.txt
path "secret/data/apigee/redis" {
  capabilities = ["read"]
}
cat orgencryptionkeys-auth-policy.txt
path "secret/data/apigee/orgencryptionkeys" {
  capabilities = ["read"]
}
cat envencryptionkeys-auth-policy.txt
path "secret/data/apigee/envencryptionkeys" {
  capabilities = ["read"]
}

vault policy write apigee-axhashsalt-auth axhashsalt-auth-policy.txt
vault policy write apigee-redis-auth redis-auth-policy.txt
vault policy write apigee-orgencryptionkeys-auth orgencryptionkeys-auth-policy.txt
vault policy write apigee-envencryptionkeys-auth envencryptionkeys-auth-policy.txt

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-redis-default,apigee-redis-envoy-default,apigee-mart-${ORG_ENCODE},apigee-mint-task-scheduler-${ORG_ENCODE}"

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-runtime-${ENV_ENCODE},apigee-synchronizer-${ENV_ENCODE}
done

echo $NAMES

Esegui lo script per generare l'elenco dei nomi dei account di servizio a cui associare i criteri:
```
chmod +x ./generate-encoded-sas.sh
./generate-encoded-sas.sh
```
L'output deve elencare i nomi dei account di servizio codificati.

Utilizzando i criteri, crea ruoli Vault che associano i service account Apigee richiesti.

vault write auth/kubernetes/role/apigee-axhashsalt \
	bound_service_account_names=BOUND_SA_NAMES \
	bound_service_account_namespaces=APIGEE_NAMESPACE \
	policies=apigee-axhashsalt-auth \
	ttl=1m

vault write auth/kubernetes/role/apigee-redis \
	bound_service_account_names=BOUND_SA_NAMES \
	bound_service_account_namespaces=APIGEE_NAMESPACE \
	policies=apigee-redis-auth \
	ttl=1m

vault write auth/kubernetes/role/apigee-orgencryptionkeys \
	bound_service_account_names=BOUND_SA_NAMES \
	bound_service_account_namespaces=APIGEE_NAMESPACE \
	policies=apigee-orgencryptionkeys-auth \
	ttl=1m

vault write auth/kubernetes/role/apigee-envencryptionkeys \
	bound_service_account_names=BOUND_SA_NAMES \
	bound_service_account_namespaces=APIGEE_NAMESPACE \
	policies=apigee-envencryptionkeys-auth \
	ttl=1m

Crea oggetti SecretProviderClass.

Aggiungi i seguenti secret tramite le risorse SecretProviderClass. Queste risorse indicano al driver CSI con quale provider comunicare quando richiede i secret. La tabella seguente mostra i nomi dei file (objectNames) previsti da Apigee hybrid:

Secret	Nomi dei file secret previsti
AX Hash Salt	`ax-hash-salt`
Redis	`redis-password`
Chiavi di crittografia dell'organizzazione	`kmsEncryptionKey` `kvmEncryptionKey` `contractEncryptionKey`
Chiavi di crittografia dell'ambiente	`kmsEncryptionKey` `kvmEncryptionKey` `envKvmEncryptionKey` `cacheEncryptionKey`

Utilizza i seguenti modelli SecretProviderClass per configurare queste risorse:

# axhashsalt-spc.yaml

apiVersion: secrets-store.csi.x-k8s.io/v1
kind: SecretProviderClass
metadata:
  name: apigee-axhashsalt-spc
spec:
  provider: vault
  parameters:
    roleName: apigee-axhashsalt
    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: "ax-hash-salt"
        secretPath: ""
        secretKey: ""

# redis-spc.yaml

apiVersion: secrets-store.csi.x-k8s.io/v1
kind: SecretProviderClass
metadata:
  name: apigee-redis-spc
spec:
  provider: vault
  parameters:
    roleName: apigee-redis
    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: "redis-password"
        secretPath: ""
        secretKey: ""

# orgencryptionkeys-spc.yaml

apiVersion: secrets-store.csi.x-k8s.io/v1
kind: SecretProviderClass
metadata:
  name: apigee-orgencryptionkeys-spc
spec:
  provider: vault
  parameters:
    roleName: apigee-orgencryptionkeys
    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: "kmsEncryptionKey"
        secretPath: ""
        secretKey: ""
      - objectName: "kvmEncryptionKey"
        secretPath: ""
        secretKey: ""
      - objectName: "contractEncryptionKey"
        secretPath: ""
        secretKey: ""

# envencryptionkeys-spc.yaml

apiVersion: secrets-store.csi.x-k8s.io/v1
kind: SecretProviderClass
metadata:
  name: apigee-envencryptionkeys-spc
spec:
  provider: vault
  parameters:
    roleName: apigee-envencryptionkeys
    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: "cacheEncryptionKey"
        secretPath: ""
        secretKey: ""
      - objectName: "kvmEncryptionKey"
        secretPath: ""
        secretKey: ""
      - objectName: "envKvmEncryptionKey"
        secretPath: ""
        secretKey: ""
      - objectName: "kmsEncryptionKey"
        secretPath: ""
        secretKey: ""

VAULT_ADDRESS è l'endpoint in cui è in esecuzione il server Vault. Se Vault è in esecuzione nello stesso cluster e spazio dei nomi di Apigee, il formato sarà in genere http://vault.APIGEE_NAMESPACE.svc.cluster.local:VAULT_SERVICE_PORT.

Applica il SecretProviderClasses precedente allo spazio dei nomi APIGEE_NAMESPACE:

kubectl -n APIGEE_NAMESPACE apply -f axhashsalt-spc.yaml
kubectl -n APIGEE_NAMESPACE apply -f redis-spc.yaml
kubectl -n APIGEE_NAMESPACE apply -f orgencryptionkeys-spc.yaml
kubectl -n APIGEE_NAMESPACE apply -f envencryptionkeys-spc.yaml

Abilita il secret esterno per AX Hash Salt.
1. Nel file overrides.yaml, aggiungi la seguente configurazione per abilitare l'utilizzo di secret esterni per l'AX Hash Salt:
```
axHashSaltSecretProviderClass: apigee-axhashsalt-spc
```
2. Applica la modifica eseguendo l'upgrade del grafico Helm org:
```
helm upgrade org apigee-org/ \
  --namespace APIGEE_NAMESPACE \
  -f overrides.yaml
```
Attiva il secret esterno per la password Redis.
1. Nel file overrides.yaml, aggiungi la seguente configurazione per attivare l'utilizzo di secret esterni per la password Redis:
```
redis:
  auth:
    secretProviderClass: apigee-redis-spc
```
2. Quindi applica le modifiche eseguendo l'upgrade dei grafici operator e redis nel seguente ordine:
```
helm upgrade operator apigee-operator/ \
  --namespace APIGEE_NAMESPACE \
  -f overrides.yaml
helm upgrade redis apigee-redis/ \
  --namespace APIGEE_NAMESPACE \
  -f overrides.yaml
```
Abilita il secret esterno per le chiavi di crittografia
1. All'interno del file overrides.yaml, aggiungi la seguente configurazione per abilitare l'utilizzo di secret esterni per le chiavi di crittografia a livello di organizzazione:
```
encryptionKeySecretProviderClass: apigee-orgencryptionkeys-spc
```
2. Applica la modifica eseguendo l'upgrade del grafico Helm org:
```
helm upgrade org apigee-org/ \
  --namespace APIGEE_NAMESPACE \
  -f overrides.yaml
```
3. All'interno del file overrides.yaml per ogni ambiente, aggiungi la seguente configurazione per le chiavi di crittografia specifiche dell'ambiente:
```
envs:
- name: ENV_NAME
  encryptionKeySecretProviderClass: apigee-envencryptionkeys-spc
```
4. Applica la modifica eseguendo l'upgrade del grafico Helm env una volta per ogni ambiente:
```
helm upgrade ENV_NAME apigee-env/ \
  --namespace APIGEE_NAMESPACE \
  --set env=ENV_NAME \
  -f overrides.yaml
```

Esegui il rollback

AX Hash Salt

Nel file overrides.yaml, rimuovi la configurazione che ha abilitato l'utilizzo di secret esterni per l'AX Hash Salt:
```
# Comment out or delete the following line:
# axHashSaltSecretProviderClass: apigee-axhashsalt-spc
```

Applica la modifica eseguendo l'upgrade del grafico Helm org:

helm upgrade org apigee-org/ \
  --namespace APIGEE_NAMESPACE \
  -f overrides.yaml

Password Redis

Nel file overrides.yaml, rimuovi la configurazione che ha attivato l'utilizzo di secret esterni per la password Redis:
```
redis:
  auth:
  # Comment out or delete the following line:
  # secretProviderClass: apigee-redis-spc
```

Quindi applica le modifiche eseguendo l'upgrade dei grafici redis e operator nel seguente ordine:

helm upgrade redis apigee-redis/ \
  --namespace APIGEE_NAMESPACE \
  -f overrides.yaml
helm upgrade operator apigee-operator/ \
  --namespace APIGEE_NAMESPACE \
  -f overrides.yaml

Chiavi di crittografia

Nel file overrides.yaml, rimuovi la configurazione che ha attivato l'utilizzo di secret esterni per le chiavi di crittografia delle variabili di ambiente:
```
envs:
  - name: ENV_NAME
  # Comment out or delete the following line:
  # encryptionKeySecretProviderClass: apigee-envencryptionkeys-spc
```

Applica la modifica eseguendo l'upgrade del grafico Helm env una volta per ogni ambiente:

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

Nel file overrides.yaml, rimuovi la configurazione che ha abilitato l'utilizzo di secret esterni per le chiavi di crittografia dell'organizzazione:
```
# Comment out or delete the following line:
# encryptionKeySecretProviderClass: apigee-orgencryptionkeys-spc
```

Quindi, esegui l'upgrade del grafico Helm org:

helm upgrade org apigee-org/ \
  --namespace APIGEE_NAMESPACE \
  -f overrides.yaml