Diese Seite wurde von der Cloud Translation API übersetzt.

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 der Datei „overrides.yaml“ speichern und verwalten.

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

Informationen zum Speichern anderer Arten von Informationen in Vault finden Sie unter:

Vorbereitung

Ein CSI-Treiber für den Kubernetes-Secrets-Speicher. Folgen Sie dazu der Anleitung unter CSI-Treiber für Secrets-Speicher: Installation. Informationen zu den unterstützten Versionen finden Sie unter Von Apigee Hybrid unterstützte Plattformen und Versionen: Secret Store CSI-Treiber.
Der Vault-CSI-Anbieter. Folgen Sie dazu der Anleitung unter Vault-CSI-Anbieter installieren. Informationen zu den unterstützten 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:Der Wert von `contractEncryptionKey` muss ein base64-codierter String mit einer Länge von 16, 24 oder 32 Zeichen sein. Weitere Informationen finden Sie unter Datenverschlüsselung.
`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 Script aus, um die Liste der Dienstkontonamen zu generieren und die Richtlinien an folgende 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 von Apigee Hybrid erwarteten Dateinamen (objectNames):

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, unter dem Ihr Vault-Server ausgeführt wird. Wenn Vault in demselben Cluster und Namespace wie Apigee ausgeführt wird, ist das Format in der Regel 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 das 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 Ihrer overrides.yaml-Datei 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 der Datei overrides.yaml 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, indem Sie das Helm-Diagramm env einmal für jede Umgebung aktualisieren:
```
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 Verwendung 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 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, indem Sie das Helm-Diagramm env einmal für jede Umgebung aktualisieren:

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
```

Führen Sie dann ein Upgrade des org-Helm-Diagramms aus:

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