Cette page a été traduite par l'API Cloud Translation.

Stocker des données dans un gestionnaire de secrets externe

Ce guide vous explique comment stocker et gérer les types d'informations suivants dans le service de stockage de secrets externe, Hashicorp Vault, au lieu de le faire dans votre fichier overrides.yaml.

Sel de hachage AX
Mot de passe Redis
Clés de chiffrement

Pour stocker d'autres types d'informations dans Vault, consultez les sections suivantes :

Prérequis

Un pilote CSI Secrets Store Kubernetes. Vous pouvez l'installer en suivant les instructions de la section Pilote CSI Secrets Store : installation. Pour connaître les versions prises en charge, consultez Plates-formes et versions compatibles avec Apigee hybrid: pilote CSI Secret Store.
Le fournisseur CSI Vault Vous pouvez l'installer en suivant les instructions de la section Installer le fournisseur CSI Vault. Pour connaître les versions prises en charge, consultez Plates-formes et versions prises en charge avec Apigee hybrid : Vault.

Procédure

Créez des secrets, des règles et des rôles Vault.

Utilisez l'interface utilisateur ou les API Vault pour créer des secrets et accorder des autorisations aux comptes de service Apigee Kubernetes afin de lire ces secrets comme décrit ici. Les secrets doivent se composer d'une clé et d'une ou plusieurs valeurs, comme indiqué dans le tableau suivant:

Clé secrète	Données secrètes
`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`" } Important:La valeur `contractEncryptionKey` doit être une chaîne encodée en base64 d'une longueur de 16, 24 ou 32 caractères. Pour en savoir plus, consultez la section Chiffrement des données.
`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`" }

Dans Vault, créez des règles qui accordent l'accès aux secrets :

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

Créez un script nommé generate-encoded-sas.sh avec le contenu suivant :

# 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

Exécutez le script pour générer la liste des noms de comptes de service à laquelle lier les règles :
```
chmod +x ./generate-encoded-sas.sh
./generate-encoded-sas.sh
```
Le résultat doit lister les noms de compte de service encodés.

À l'aide des règles, créez des rôles Vault qui associent les comptes de service Apigee requis.

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

Créez des objets SecretProviderClass.

Ajoutez les secrets suivants via les ressources SecretProviderClass. Ces ressources indiquent au pilote CSI avec quel fournisseur il doit communiquer lorsqu'il demande des secrets. Le tableau suivant présente les noms de fichiers (objectNames) attendus par Apigee hybrid :

Secret	Noms de fichiers de secrets attendus
Sel de hachage AX	`ax-hash-salt`
Redis	`redis-password`
Clés de chiffrement de l'organisation	`kmsEncryptionKey` `kvmEncryptionKey` `contractEncryptionKey`
Clés de chiffrement de l'environnement	`kmsEncryptionKey` `kvmEncryptionKey` `envKvmEncryptionKey` `cacheEncryptionKey`

Utilisez les modèles SecretProviderClass suivants pour configurer ces ressources :

# 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 est le point de terminaison sur lequel votre serveur Vault est exécuté. Si Vault s'exécute dans le même cluster et le même espace de noms qu'Apigee, le format est généralement http://vault.APIGEE_NAMESPACE.svc.cluster.local:VAULT_SERVICE_PORT.

Appliquez la valeur SecretProviderClasses ci-dessus à l'espace de noms 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

Activez le secret externe pour AX Hash Salt.
1. Dans votre fichier overrides.yaml, ajoutez la configuration suivante pour activer l'utilisation des secrets externes pour AX Hash Salt :
```
axHashSaltSecretProviderClass: apigee-axhashsalt-spc
```
2. Appliquez la modification en mettant à niveau le chart Helm org :
```
helm upgrade org apigee-org/ \
  --namespace APIGEE_NAMESPACE \
  -f overrides.yaml
```
Activez le secret externe pour le mot de passe Redis.
1. Dans votre fichier overrides.yaml, ajoutez la configuration suivante pour activer l'utilisation des secrets externes pour le mot de passe Redis :
```
redis:
  auth:
    secretProviderClass: apigee-redis-spc
```
2. Appliquez ensuite les modifications en mettant à niveau les charts operator et redis dans l'ordre suivant :
```
helm upgrade operator apigee-operator/ \
  --namespace APIGEE_NAMESPACE \
  -f overrides.yaml
helm upgrade redis apigee-redis/ \
  --namespace APIGEE_NAMESPACE \
  -f overrides.yaml
```
Activez le secret externe pour les clés de chiffrement.
1. Dans votre fichier overrides.yaml, ajoutez la configuration suivante pour activer l'utilisation des secrets externes pour les clés de chiffrement au niveau de l'organisation:
```
encryptionKeySecretProviderClass: apigee-orgencryptionkeys-spc
```
2. Appliquez la modification en mettant à niveau le chart Helm org:
```
helm upgrade org apigee-org/ \
  --namespace APIGEE_NAMESPACE \
  -f overrides.yaml
```
3. Dans votre fichier overrides.yaml pour chaque environnement, ajoutez la configuration suivante pour les clés de chiffrement spécifiques à l'environnement:
```
envs:
- name: ENV_NAME
  encryptionKeySecretProviderClass: apigee-envencryptionkeys-spc
```
4. Appliquez la modification en mettant à niveau le chart Helm env une fois pour chaque environnement :
```
helm upgrade ENV_NAME apigee-env/ \
  --namespace APIGEE_NAMESPACE \
  --set env=ENV_NAME \
  -f overrides.yaml
```

Rollback

Sel de hachage AX

Dans votre fichier overrides.yaml, supprimez la configuration qui a activé l'utilisation des secrets externes pour AX Hash Salt :
```
# Comment out or delete the following line:
# axHashSaltSecretProviderClass: apigee-axhashsalt-spc
```

Appliquez la modification en mettant à niveau le chart Helm org :

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

Mot de passe Redis

Dans votre fichier overrides.yaml, supprimez la configuration qui a activé l'utilisation des secrets externes pour le mot de passe Redis :
```
redis:
  auth:
  # Comment out or delete the following line:
  # secretProviderClass: apigee-redis-spc
```

Appliquez ensuite les modifications en mettant à niveau les charts redis et operator dans l'ordre suivant :

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

Clés de chiffrement

Dans votre fichier overrides.yaml, supprimez la configuration qui a activé l'utilisation des secrets externes pour les clés de chiffrement env:
```
envs:
  - name: ENV_NAME
  # Comment out or delete the following line:
  # encryptionKeySecretProviderClass: apigee-envencryptionkeys-spc
```

Appliquez la modification en mettant à niveau le chart Helm env une fois pour chaque environnement :

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

Dans votre fichier overrides.yaml, supprimez la configuration qui a activé l'utilisation des secrets externes pour les clés de chiffrement de l'organisation:
```
# Comment out or delete the following line:
# encryptionKeySecretProviderClass: apigee-orgencryptionkeys-spc
```

Puis mettez à niveau le chart Helm org :

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