Daten in einem externen Secret Manager speichern

In diesem Leitfaden erfahren Sie, wie Sie die folgenden Arten von Informationen im externen Secret-Speicherdienst Hashicorp Vault statt in Ihrer overrides.yaml-Datei speichern und verwalten.

AX-Hash Salt
Redis-Passwort
Verschlüsselungsschlüssel

Weitere Informationen zum Speichern anderer Informationen in Vault finden Sie unter:

Vorbereitung

Ein CSI-Treiber für den Kubernetes-Secrets-Speicher. Sie können ihn installieren, indem Sie der Anleitung unter CSI-Treiber für Secrets Store: Installation folgen. Unterstützte Versionen finden Sie unter Von Apigee Hybrid unterstützte Plattformen und Versionen: CSI-Treiber für Secret Store.
Den Vault-CSI-Anbieter. Folgen Sie dazu der Anleitung unter Vault-CSI-Anbieter installieren. Unterstützte Versionen finden Sie unter Von Apigee Hybrid unterstützte Plattformen und Versionen: Vault.

Vorgehensweise

Vault-Secrets, -Richtlinien und -Rollen erstellen

Verwenden Sie die Vault-Benutzeroberfläche oder ‑APIs, um Secrets zu erstellen und den Apigee-Kubernetes-Dienstkonten Berechtigungen zum Lesen dieser Secrets zu erteilen, wie hier beschrieben. Die Secrets müssen aus einem Schlüssel und einem oder mehreren Werten bestehen, wie in der folgenden Tabelle dargestellt:

Geheimer Schlüssel	Secret-Daten
`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`" } Wichtig: Die `contractEncryptionKey`-Werte müssen hier im Klartext erstellt werden. Codieren Sie den Wert nicht mit 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`" }

Erstellen Sie in Vault Richtlinien, die Zugriff auf die Secrets gewähren:

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

Erstellen Sie ein Script mit dem Namen generate-encoded-sas.sh und mit folgendem Inhalt:

# 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

Führen Sie das Skript aus, um die Liste der Dienstkontonamen zu generieren, um die Richtlinien zu binden:
```
chmod +x ./generate-encoded-sas.sh
./generate-encoded-sas.sh
```
Die Ausgabe sollte die codierten Dienstkontonamen enthalten.

Erstellen Sie mithilfe der Richtlinien Vault-Rollen, die die erforderlichen Apigee-Dienstkonten binden.

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

Erstellen Sie SecretProviderClass-Objekte.

Fügen Sie die folgenden Secrets über die SecretProviderClass-Ressourcen hinzu. Diese Ressourcen teilen dem CSI-Treiber mit, mit welchem Anbieter beim Anfordern von Secrets kommuniziert werden soll. Die folgende Tabelle zeigt die Dateinamen (objectNames), die von Apigee Hybrid erwartet werden:

Secret	Erwartete Namen der Secret-Dateien
AX-Hash Salt	`ax-hash-salt`
Redis	`redis-password`
Verschlüsselungsschlüssel der Organisation	`kmsEncryptionKey` `kvmEncryptionKey` `contractEncryptionKey`
Verschlüsselungsschlüssel der Umgebung	`kmsEncryptionKey` `kvmEncryptionKey` `envKvmEncryptionKey` `cacheEncryptionKey`

Verwenden Sie die folgenden SecretProviderClass-Vorlagen, um diese Ressourcen zu konfigurieren:

# 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 ist der Endpunkt, auf dem Ihr Vault-Server ausgeführt wird. Wenn Vault im selben Cluster und Namespace wie Apigee ausgeführt wird, lautet das Format normalerweise http://vault.APIGEE_NAMESPACE.svc.cluster.local:VAULT_SERVICE_PORT.

Wenden Sie die obige SecretProviderClasses auf den Namespace APIGEE_NAMESPACE an:

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

Aktivieren Sie das externe Secret für das AX-Hash Salt.
1. Fügen Sie in der Datei overrides.yaml die folgende Konfiguration hinzu, um die Nutzung eines externen Secrets für AX Hash Salt zu aktivieren:
```
axHashSaltSecretProviderClass: apigee-axhashsalt-spc
```
2. Wenden Sie die Änderung an, indem Sie das Helm-Diagramm org aktualisieren:
```
helm upgrade org apigee-org/ \
  --namespace APIGEE_NAMESPACE \
  -f overrides.yaml
```
Aktivieren Sie das externe Secret für das Redis-Passwort.
1. Fügen Sie in der Datei overrides.yaml die folgende Konfiguration hinzu, um die Nutzung eines externen Secrets für das Redis-Passwort zu aktivieren:
```
redis:
  auth:
    secretProviderClass: apigee-redis-spc
```
2. Wenden Sie die Änderungen an, indem Sie die Diagramme operator und redis in der folgenden Reihenfolge aktualisieren:
```
helm upgrade operator apigee-operator/ \
  --namespace APIGEE_NAMESPACE \
  -f overrides.yaml
helm upgrade redis apigee-redis/ \
  --namespace APIGEE_NAMESPACE \
  -f overrides.yaml
```
Aktivieren Sie das externe Secret für die Verschlüsselungsschlüssel.
1. Fügen Sie in Ihrer overrides.yaml-Datei die folgende Konfiguration hinzu, um die Nutzung eines externen Secrets für die Verschlüsselungsschlüssel auf Organisationsebene zu aktivieren:
```
encryptionKeySecretProviderClass: apigee-orgencryptionkeys-spc
```
2. Wenden Sie die Änderung an, indem Sie das Helm-Diagramm org aktualisieren:
```
helm upgrade org apigee-org/ \
  --namespace APIGEE_NAMESPACE \
  -f overrides.yaml
```
3. Fügen Sie in der Datei overrides.yaml für jede Umgebung die folgende Konfiguration für die umgebungsspezifischen Verschlüsselungsschlüssel hinzu:
```
envs:
- name: ENV_NAME
  encryptionKeySecretProviderClass: apigee-envencryptionkeys-spc
```
4. Wenden Sie die Änderung an. Aktualisieren Sie dazu das Helm-Diagramm env einmal für jede Umgebung:
```
helm upgrade ENV_NAME apigee-env/ \
  --namespace APIGEE_NAMESPACE \
  --set env=ENV_NAME \
  -f overrides.yaml
```

Rollback

AX-Hash Salt

Entfernen Sie in der Datei overrides.yaml die Konfiguration, die die Verwendung eines externen Secrets für das AX Hash Salt aktiviert hat:
```
# Comment out or delete the following line:
# axHashSaltSecretProviderClass: apigee-axhashsalt-spc
```

Wenden Sie die Änderung an, indem Sie das Helm-Diagramm org aktualisieren:

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

Redis-Passwort

Entfernen Sie in der Datei overrides.yaml die Konfiguration, die die Nutzung eines externen Secrets für das Redis-Passwort aktiviert hat:
```
redis:
  auth:
  # Comment out or delete the following line:
  # secretProviderClass: apigee-redis-spc
```

Wenden Sie dann die Änderungen an, indem Sie die Diagramme redis und operator in der folgenden Reihenfolge aktualisieren:

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

Verschlüsselungsschlüssel

Entfernen Sie in der Datei overrides.yaml die Konfiguration, die die Verwendung eines externen Secrets für die Verschlüsselungsschlüssel der Umgebung aktiviert hat:
```
envs:
  - name: ENV_NAME
  # Comment out or delete the following line:
  # encryptionKeySecretProviderClass: apigee-envencryptionkeys-spc
```

Wenden Sie die Änderung an. Aktualisieren Sie dazu das Helm-Diagramm env einmal für jede Umgebung:

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

Entfernen Sie in der Datei overrides.yaml die Konfiguration, die die Nutzung des externen Secrets für die Verschlüsselungsschlüssel der Organisation aktiviert hat:
```
# Comment out or delete the following line:
# encryptionKeySecretProviderClass: apigee-orgencryptionkeys-spc
```

Aktualisieren Sie dann das Helm-Diagramm org:

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