Questa pagina è stata tradotta dall'API Cloud Translation.

Archiviazione dei dati in un gestore di secret esterno

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

Sale dell'hash AX
Password Redis
Chiavi di crittografia

Per archiviare altri tipi di informazioni in Vault, consulta:

Prerequisiti

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

Procedura

Crea i secret, i criteri e i ruoli di Vault.

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

Chiave segreta	Dati riservati
`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: i valori `contractEncryptionKey` devono essere in testo normale quando vengono creati qui. Non codificare il valore in Base64.
`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 criteri che concedono 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 degli account di servizio a cui associare i criteri:
```
chmod +x ./generate-encoded-sas.sh
./generate-encoded-sas.sh
```
L'output dovrebbe elencare i nomi degli account di servizio codificati.

Utilizzando i criteri, crea i ruoli di Vault che associano gli account di servizio 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:

Segreto	Nomi dei file secret previsti
Sale AX Hash	`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 nello stesso spazio dei nomi di Apigee, in genere il formato sarà http://vault.APIGEE_NAMESPACE.svc.cluster.local:VAULT_SERVICE_PORT.

Applica SecretProviderClasses sopra 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

Attiva il secret esterno per il sale dell'hash AX.
1. Nel file overrides.yaml, aggiungi la seguente configurazione per abilitare l'utilizzo di un segreto esterno per il sale dell'hash AX:
```
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 un segreto esterno per la password Redis:
```
redis:
  auth:
    secretProviderClass: apigee-redis-spc
```
2. Quindi, applica le modifiche eseguendo l'upgrade dei grafici operator e redis nell'ordine seguente:
```
helm upgrade operator apigee-operator/ \
  --namespace APIGEE_NAMESPACE \
  -f overrides.yaml
helm upgrade redis apigee-redis/ \
  --namespace APIGEE_NAMESPACE \
  -f overrides.yaml
```
Attiva il secret esterno per le chiavi di crittografia
1. Nel 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 env grafico Helm una volta per ogni ambiente:
```
helm upgrade ENV_NAME apigee-env/ \
  --namespace APIGEE_NAMESPACE \
  --set env=ENV_NAME \
  -f overrides.yaml
```

Esegui il rollback

Sale AX Hash

Nel file overrides.yaml, rimuovi la configurazione che ha attivato l'utilizzo di un segreto esterno per il sale dell'hash AX:
```
# 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 un segreto esterno 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 nell'ordine seguente:

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 env:

envs:
  - name: ENV_NAME
  # Comment out or delete the following line:
  # encryptionKeySecretProviderClass: apigee-envencryptionkeys-spc

Applica la modifica eseguendo l'upgrade del env grafico Helm 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 attivato l'utilizzo di segreti 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