Diese Seite wurde von der Cloud Translation API übersetzt.

Schritt 5: Dienstkonto-Authentifizierung einrichten

Übersicht

In diesem Schritt wird erläutert, wie Sie die Authentifizierungsmethoden für die Google Cloud-Dienstkonten einrichten, die Sie im vorherigen Schritt erstellt haben.

Wählen Sie die Anleitung für die Authentifizierungsmethode aus, die Sie verwenden möchten. Eine Übersicht über die verschiedenen Authentifizierungsmethoden finden Sie unter Authentifizierungsmethoden für Dienstkonten in Apigee Hybrid.

Kubernetes-Secrets

Dienstkonten

Sie müssen Kubernetes-Secrets für die folgenden Dienstkonten erstellen:

Produktion

apigee-cassandra
apigee-logger
apigee-mart
apigee-metrics
apigee-mint-task-scheduler (wenn Sie die Monetarisierung für Apigee Hybrid verwenden)
apigee-runtime
apigee-synchronizer
apigee-udca
apigee-watcher

Non-prod

apigee-non-prod

Sie geben jedes dieser Secrets im Schritt Überschreibungsdatei erstellen an.

In diesem Verfahren werden die folgenden optionalen Umgebungsvariablen verwendet:

$APIGEE_HELM_CHARTS_HOME
$APIGEE_NAMESPACE
$PROJECT_ID

Wenn Sie diese Variablen nicht definiert haben, ersetzen Sie für jede Variable in den Codebeispielen den entsprechenden Wert.

Kubernetes-Secrets erstellen

Erstellen Sie die Kubernetes-Secrets zum Speichern der Dienstkontoschlüssel.

Der Befehl kubectl create secret in den folgenden Codebeispielen hat die Struktur:

kubectl create secret generic SECRET_NAME \
  --from-file="client_secret.json=PATH_TO_SERVICE_ACCOUNT_KEY" \
  -n $APIGEE_NAMESPACE

Hinweis: Bei den folgenden Befehlen wird davon ausgegangen, dass Sie die Dienstkontoschlüsseldateien in Schritt 4: Dienstkonten erstellen in das Verzeichnis $APIGEE_HELM_CHARTS_HOME/service-accounts/ heruntergeladen haben. Wenn Sie die Schlüssel in ein anderes Verzeichnis heruntergeladen haben, bearbeiten Sie die Befehle entsprechend.

Produktion

kubectl create secret generic apigee-logger-svc-account \
  --from-file="client_secret.json=$APIGEE_HELM_CHARTS_HOME/service-accounts/$PROJECT_ID-apigee-logger.json" \
  -n $APIGEE_NAMESPACE

kubectl create secret generic apigee-metrics-svc-account \
  --from-file="client_secret.json=$APIGEE_HELM_CHARTS_HOME/service-accounts/$PROJECT_ID-apigee-metrics.json" \
  -n $APIGEE_NAMESPACE

kubectl create secret generic apigee-watcher-svc-account \
  --from-file="client_secret.json=$APIGEE_HELM_CHARTS_HOME/service-accounts/$PROJECT_ID-apigee-watcher.json" \
  -n $APIGEE_NAMESPACE

kubectl create secret generic apigee-udca-svc-account \
  --from-file="client_secret.json=$APIGEE_HELM_CHARTS_HOME/service-accounts/$PROJECT_ID-apigee-udca.json" \
  -n $APIGEE_NAMESPACE
    
kubectl create secret generic apigee-mart-svc-account \
  --from-file="client_secret.json=$APIGEE_HELM_CHARTS_HOME/service-accounts/$PROJECT_ID-apigee-mart.json" \
  -n $APIGEE_NAMESPACE

kubectl create secret generic apigee-synchronizer-svc-account \
  --from-file="client_secret.json=$APIGEE_HELM_CHARTS_HOME/service-accounts/$PROJECT_ID-apigee-synchronizer.json" \
  -n $APIGEE_NAMESPACE

kubectl create secret generic apigee-runtime-svc-account \
  --from-file="client_secret.json=$APIGEE_HELM_CHARTS_HOME/service-accounts/$PROJECT_ID-apigee-runtime.json" \
  -n $APIGEE_NAMESPACE

Wenn Sie Monetization for Apigee Hybrid verwenden, müssen Sie auch ein Kubernetes-Secret für das apigee-mint-task-scheduler-Dienstkonto erstellen:

kubectl create secret generic apigee-mint-task-scheduler-svc-account \
  --from-file="client_secret.json=$APIGEE_HELM_CHARTS_HOME/service-accounts/$PROJECT_ID-apigee-mint-task-scheduler.json" \
  -n APIGEE_NAMESPACE

Non-prod

kubectl create secret generic apigee-non-prod-svc-account \
  --from-file="client_secret.json=$APIGEE_HELM_CHARTS_HOME/service-accounts/$PROJECT_ID-apigee-non-prod.json" \
  -n $APIGEE_NAMESPACE

Optional: Sie können die JSON-Dateien für das Dienstkonto löschen, nachdem Sie die Kubernetes-Secrets erstellt haben.

Weitere Informationen zur Verwendung von Kubernetes-Secrets mit Apigee Hybrid finden Sie unter Dienstkontoschlüssel in Kubernetes-Secrets speichern.

JSON-Dateien

Es sind keine zusätzlichen Schritte erforderlich, um die Authentifizierung mit JSON-Dateien einzurichten. Fahren Sie mit Schritt 6: TLS-Zertifikate erstellen fort.

Vault

Zum Speichern von Dienstkonto-Secrets in Vault einrichten

CSI-Treiber und Vault-Anbieter installieren

Wenn Sie den CSI-Treiber noch nicht mit Helm in Ihrem Cluster installiert haben, folgen Sie der Anleitung unter CSI-Treiber für den Secrets-Speicher: Installation. Weitere Informationen finden Sie in der Vault-Dokumentation unter Vault-CSI-Anbieter installieren.

Informationen zu den von Apigee Hybrid unterstützten Mindestversionen von CSI-Treibern finden Sie unter Von Apigee Hybrid unterstützte Plattformen und Versionen.

Vault-Secrets, -Richtlinien und -Rollen erstellen

Verwenden Sie die Vault-UI oder -APIs, um Secrets zu erstellen und den von Apigee Hybrid verwendeten Kubernetes-Dienstkonten die Berechtigung zum Lesen dieser Secrets zu erteilen.

Erstellen Sie die organisations- und umgebungsspezifischen Secrets im folgenden Format:

Geheimer Schlüssel Secret-Daten

Geheimer Schlüssel	Secret-Daten
secret/data/apigee/orgsakeys	{ "cassandraBackup": "*", "cassandraRestore": "", "connectAgent": "", "logger": "", "mart": "", "metrics": "", "mint": "", "udca": "", "watcher": "" } Hinweis:** `mint` ist nur erforderlich, wenn Sie Monetization for Apigee Hybrid (v1.15.1 und höher) verwenden.
secret/data/apigee/envsakeys-`ENV_NAME`	{ "runtime": "*", "synchronizer": "", "udca": "**". }

secret/data/apigee/orgsakeys

{
    "cassandraBackup": "***",
    "cassandraRestore": "***",
    "connectAgent": "***",
    "logger": "***",
    "mart": "***",
    "metrics": "***",
    "mint": "***",
    "udca": "***",
    "watcher": "***"
}

Hinweis: mint ist nur erforderlich, wenn Sie Monetization for Apigee Hybrid (v1.15.1 und höher) verwenden.

secret/data/apigee/envsakeys-ENV_NAME

{
    "runtime": "***",
    "synchronizer": "***",
    "udca": "***".
}

Ersetzen Sie das "***" in jedem Paar durch den Inhalt der JSON-Datei für das Google-Dienstkonto, das der Apigee-Komponente entspricht. apigee-cassandra-backup und apigee-cassandra-restore verwenden beide das Dienstkonto apigee-cassandra. Beispiel:

{
    "cassandraBackup": "{
        "type": "service_account",
        "project_id": "myhybridorg",
        "private_key_id": "PRIVATE_KEY_ID",
        "private_key": "-----BEGIN PRIVATE KEY-----\nPRIVATE_KEY_TEXT\n-----END PRIVATE KEY-----\n",
        "client_email": "apigee-cassandra@myhybridorg.iam.gserviceaccount.com",
        "client_id": "123456789012345678901",
        "auth_uri": "https://accounts.google.com/o/oauth2/auth",
        "token_uri": "https://oauth2.googleapis.com/token",
        "auth_provider_x509_cert_url": "https://www.googleapis.com/oauth2/v1/certs",
        "client_x509_cert_url": "https://www.googleapis.com/robot/v1/metadata/x509/apigee-cassandra%40myhybridorg.iam.gserviceaccount.com",
        "universe_domain": "googleapis.com"
    }",
    "cassandraRestore":...
...
}

Gewähren Sie Zugriff auf das Organisations-Secret. Erstellen Sie eine Textdatei mit dem Namen „orgsakeys-auth-policy.txt“ und folgendem Inhalt:
```
path "secret/data/apigee/orgsakeys" {
    capabilities = ["read"]
}
```
Erstellen Sie in Vault eine Richtlinie, die Zugriff auf das Organisations-Secret gewährt:
```
vault policy write apigee-orgsakeys-auth orgsakeys-auth-policy.txt
```
Erstellen Sie für jede Umgebung eine Textdatei mit dem Namen envsakeys-ENV_NAME-auth-policy.txt und folgendem Inhalt:
```
path "secret/data/apigee/envsakeys-ENV_NAME" {
    capabilities = ["read"]
}
```
Wiederholen Sie diesen Schritt für jede Umgebung.
Erstellen Sie in Vault eine Richtlinie, die Zugriff auf das Umgebung-Secret gewährt:
```
vault policy write apigee-envsakeys-ENV_NAME-auth envsakeys-ENV_NAME-auth-policy.txt
```
Wiederholen Sie diesen Schritt für jede Umgebung.

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-cassandra-default,apigee-cassandra-backup-sa,apigee-cassandra-restore-sa,apigee-cassandra-schema-setup-${ORG_ENCODE},apigee-cassandra-schema-val-${ORG_ENCODE},apigee-cassandra-user-setup-${ORG_ENCODE},apigee-mart-${ORG_ENCODE},apigee-mint-task-scheduler-${ORG_ENCODE},apigee-connect-agent-${ORG_ENCODE},apigee-watcher-${ORG_ENCODE},apigee-udca-${ORG_ENCODE},apigee-metrics-apigee-telemetry,apigee-open-telemetry-collector-apigee-telemetry,apigee-logger-apigee-telemetry

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

echo $NAMES

Hinweis: Entfernen Sie apigee-mint-task-scheduler-${ORG_ENCODE}, wenn Sie die Monetarisierung für Apigee Hybrid nicht verwenden.

Führen Sie das Skript aus, um die Liste der Dienstkontonamen zu generieren und die Richtlinie an folgende zu binden:

./generate-encoded-sas.sh

Die Ausgabe sollte eine durch Kommas getrennte Liste von Kubernetes-Dienstkontonamen sein, ähnlich dem folgenden Beispiel:

./generate-encoded-sas.sh
apigee-manager,apigee-cassandra-default,apigee-cassandra-backup-sa,
apigee-cassandra-restore-sa,apigee-cassandra-schema-setup-myhybrido
rg-5b044c1,apigee-cassandra-schema-val-myhybridorg-5b044c1,apigee-c
assandra-user-setup-myhybridorg-5b044c1,apigee-mart-myhybridorg-5b0
44c1,apigee-mint-task-scheduler-myhybridorg-5b044c1,apigee-connect-
agent-myhybridorg-5b044c1,apigee-watcher-myhybridorg-5b044c1,apigee
-udca-myhybridorg-5b044c1,apigee-metrics-apigee-telemetry,apigee-op
en-telemetry-collector-apigee-telemetry,apigee-logger-apigee-teleme
try,apigee-synchronizer-myhybridorg-dev-ee52aca,apigee-runtime-myhy
bridorg-dev-ee52aca,apigee-synchronizer-myhybridorg-prod-2d0221c,ap
igee-runtime-myhybridorg-prod-2d0221c

Kopieren Sie den Ausgabetext in Listen und teilen Sie ihn auf: eine Liste für die org Dienstkontonamen und eine separate Liste für den env Dienstkontonamen für jede Umgebung. Die org-Dienstkonten stehen in der Ausgabeliste bis apigee-logger-apigee-telemetry an erster Stelle.

org-Dienstnamen aus dem vorherigen Beispiel:

apigee-manager,apigee-cassandra-default,apigee-cassandra-backup-sa,
apigee-cassandra-restore-sa,apigee-cassandra-schema-setup-myhybrido
rg-5b044c1,apigee-cassandra-schema-val-myhybridorg-5b044c1,apigee-c
assandra-user-setup-myhybridorg-5b044c1,apigee-mart-myhybridorg-5b0
44c1,apigee-mint-task-scheduler-myhybridorg-5b044c1,apigee-connect-
agent-myhybridorg-5b044c1,apigee-watcher-myhybridorg-5b044c1,apigee
-udca-myhybridorg-5b044c1,apigee-metrics-apigee-telemetry,apigee-op
en-telemetry-collector-apigee-telemetry,apigee-logger-apigee-teleme
try

Die Namen der env-Dienstkonten haben das Muster apigee-synchronizer-ORG_NAME-ENV_NAME-HASH_TEXT und apigee-runtime-ORG_NAME-ENV_NAME-HASH_TEXT. Trennen Sie sie in separate Listen für jede Umgebung. Die Ausgabe aus dem vorherigen Beispiel kann beispielsweise in die folgenden beiden Listen unterteilt werden:

dev-Umgebung:

apigee-synchronizer-myhybridorg-dev-ee52aca,apigee-runtime-myhybrid
org-dev-ee52aca

prod-Umgebung:

apigee-synchronizer-myhybridorg-prod-2d0221c,apigee-runtime-myhybri
dorg-prod-2d0221c

Erstellen Sie mit der Richtlinie eine Vault-Rolle, die die organisationsspezifischen Apigee-Dienstkonten bindet:

vault write auth/kubernetes/role/apigee-orgsakeys \
    bound_service_account_names=LIST_OF_ORG_SA_NAMES \
    bound_service_account_namespaces=apigee \
    policies=apigee-orgsakeys-auth \
    ttl=1m

Erstellen Sie für jede Umgebung eine Vault-Rolle für die Dienstkontoschlüssel:

vault write auth/kubernetes/role/apigee-envsakeys-ENV_NAME \
    bound_service_account_names=LIST_OF_ENV_NAME_SA_NAMES \
    bound_service_account_namespaces=apigee \
    policies=apigee-envsakeys-ENV_NAME-auth \ 
    ttl=1m

Wiederholen Sie diesen Schritt für jede Umgebung.

`SecretProviderClass`-Objekte erstellen

Die Ressource SecretProviderClass teilt dem CSI-Treiber mit, mit welchem Anbieter beim Anfordern von Secrets kommuniziert werden soll. Die Dienstkontoschlüssel müssen über dieses Objekt konfiguriert werden. Die folgende Tabelle zeigt die von Apigee Hybrid erwarteten Dateinamen (objectNames):

Dienstkonto	Erwartete Namen der Secret-Dateien
Cassandra-Sicherung	`cassandraBackup`
Cassandra-Wiederherstellung	`cassandraRestore`
Connect-Agent	`connectAgent`
Logger	`logger`
MART	`mart`
Messwerte	`metrics`
Monetarisierung (bei Verwendung der Monetarisierung für Apigee Hybrid)	`mint`
Laufzeit	`runtime`
Synchronizer	`synchronizer`
UDCA	`udca`
Watcher	`watcher`

Verwenden Sie die folgende SecretProviderClass-Vorlage, um diese Ressource für die organisationsspezifischen Secrets zu konfigurieren:

apiVersion: secrets-store.csi.x-k8s.io/v1
kind: SecretProviderClass
metadata:
    name: apigee-orgsakeys-spc
spec:
    provider: vault
    parameters:
        roleName: apigee-orgsakeys
        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: "cassandraBackup"
                secretPath: ""
                secretKey: ""
            - objectName: "cassandraRestore"
                secretPath: ""
                secretKey: ""
            - objectName: "connectAgent"
                secretPath: ""
                secretKey: ""
            - objectName: "logger"
                secretPath: ""
                secretKey: ""
            - objectName: "mart"
                secretPath: ""
                secretKey: ""
            - objectName: "metrics"
                secretPath: ""
                secretKey: ""
            - objectName: "mint"
                secretPath: ""
                secretKey: ""
            - objectName: "udca"
                secretPath: ""
                secretKey: ""
            - objectName: "watcher"
                secretPath: ""
                secretKey: ""

Hinweis: Entfernen Sie die objectName: "mint"-Zeilen, wenn Sie die Monetarisierung für Apigee Hybrid nicht verwenden.

VAULT_ADDRESS ist der Endpunkt, auf dem Ihr Vault-Server ausgeführt wird. Wenn Vault im selben Cluster wie Apigee ausgeführt wird, ist das Format in der Regel http://vault.$APIGEE_NAMESPACE.svc.cluster.local:VAULT_SERVICE_PORT.

Speichern Sie die Vorlage in einer Datei mit dem Namen spc-org.yaml.

Wenden Sie die organisationsspezifische SecretProviderClass auf Ihren Apigee-Namespace an:
```
kubectl -n $APIGEE_NAMESPACE apply -f spc-org.yaml
```

Verwenden Sie für jede Umgebung die folgende SecretProviderClass-Vorlage, um diese Ressource für die umgebungsspezifischen Secrets zu konfigurieren. Wiederholen Sie diesen Schritt für jede Umgebung.

apiVersion: secrets-store.csi.x-k8s.io/v1
kind: SecretProviderClass
metadata:
    name: apigee-envsakeys-ENV_NAME-spc
spec:
    provider: vault
    parameters:
        roleName: apigee-envsakeys-ENV_NAME
        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: "runtime"
                secretPath: ""
                secretKey: ""
            - objectName: "synchronizer"
                secretPath: ""
                secretKey: ""
            - objectName: "udca"
                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, ist das Format in der Regel http://vault.$APIGEE_NAMESPACE.svc.cluster.local:VAULT_SERVICE_PORT.

Speichern Sie die Vorlage in einer Datei mit dem Namen spc-env-ENV_NAME.yaml.

Wenden Sie für jede Umgebung die umgebungsspezifische SecretProviderClass auf Ihren Apigee-Namespace an:
```
kubectl -n $APIGEE_NAMESPACE apply -f spc-env-ENV_NAME.yaml
```
Wiederholen Sie diesen Schritt für jede Umgebung.
Optional:Sie können die JSON-Dateien für das Dienstkonto löschen, nachdem Sie die SecretProviderClass-Objekte erstellt haben.

WIF für GKE

Konfiguration von Workload Identity Federation for GKE vorbereiten

Prüfen Sie, ob die Identitätsföderation von Arbeitslasten für GKE in Ihrer Überschreibungsdatei aktiviert ist. Es sollte in der Überschreibungsdatei in den folgenden Attributen aktiviert sein.
- Das Feld „namespace“ darf nicht leer sein. Beispiel:
```
instanceID: "hybrid-instance-1"
namespace: "apigee"
```
- Wenn Sie ein einzelnes Dienstkonto (Non-Prod) für alle Komponenten verwenden, geben Sie es mit gcp.workloadIdentity.gsa an. Beispiel:
```
  gcp:
    workloadIdentity:
      enabled: true
      gsa: "apigee-non-prod@my-hybrid-project.iam.gserviceaccount.com"
  
```
- Wenn Sie für jede Komponente ein separates Dienstkonto verwenden (Produktionsinstallationen), geben Sie das Dienstkonto mit dem Attribut gsa der Komponente an. Beispiel:
```
  logger:
    gsa: "apigee-logger@my-hybrid-project.iam.gserviceaccount.com"
  
```
Siehe: gcp.workloadIdentity.enabled.
Prüfen Sie mit dem folgenden Befehl, ob die aktuelle gcloud-Konfiguration auf Ihre Google Cloud-Projekt-ID festgelegt ist:
```
gcloud config get project
```

Legen Sie gegebenenfalls die aktuelle gcloud-Konfiguration fest:

gcloud config set project $PROJECT_ID

Prüfen Sie, ob die Identitätsföderation von Arbeitslasten für GKE für Ihren GKE-Cluster aktiviert ist. Wenn Sie den Cluster in Schritt 1: Cluster erstellen erstellt haben, wurde in Schritt 6 die Identitätsföderation von Arbeitslasten für GKE aktiviert. Prüfen Sie mit dem folgenden Befehl, ob sie aktiviert ist:

Regionale Cluster

gcloud container clusters describe $CLUSTER_NAME \
  --region $CLUSTER_LOCATION \
  --project $PROJECT_ID \
  --flatten 'workloadIdentityConfig'

Zonale Cluster

gcloud container clusters describe $CLUSTER_NAME \
  --zone $CLUSTER_LOCATION \
  --project $PROJECT_ID \
  --flatten 'workloadIdentityConfig'

Ihre Ausgabe sollte so aussehen:

  ---
  workloadPool: $PROJECT_ID.svc.id.goog

Wenn stattdessen in den Ergebnissen null angezeigt wird, führen Sie den folgenden Befehl aus, um die Identitätsförderung von Arbeitslasten für GKE für Ihren Cluster zu aktivieren:

Regionale Cluster

gcloud container clusters update $CLUSTER_NAME \
  --workload-pool=$PROJECT_ID.svc.id.goog \
  --project $PROJECT_ID \
  --region $CLUSTER_LOCATION

Zonale Cluster

gcloud container clusters update  $CLUSTER_NAME \
  --workload-pool=$PROJECT_ID.svc.id.goog \
  --zone $CLUSTER_LOCATION \
  --project $PROJECT_ID

Aktivieren Sie Workload Identity Federation for GKE für jeden Knotenpool mit den folgenden Befehlen. Dieser Vorgang kann für jeden Knoten bis zu 30 Minuten dauern:
Regionale Cluster
```
gcloud container node-pools update NODE_POOL_NAME \
  --cluster=$CLUSTER_NAME \
  --region $CLUSTER_LOCATION \
  --project $PROJECT_ID \
  --workload-metadata=GKE_METADATA
```
Zonale Cluster
```
gcloud container node-pools update NODE_POOL_NAME \
  --cluster=$CLUSTER_NAME \
  --zone $CLUSTER_LOCATION \
  --project $PROJECT_ID \
  --workload-metadata=GKE_METADATA
```
Dabei ist NODE_POOL_NAME der Name jedes Knotenpools. In den meisten Apigee Hybrid-Installationen heißen die beiden Standardknotenpools apigee-data und apigee-runtime.

Prüfen Sie mit den folgenden Befehlen, ob die Identitätsföderation von Arbeitslasten für GKE auf Ihren Knotenpools aktiviert ist:

Regionale Cluster

gcloud container node-pools describe apigee-data \
  --cluster $CLUSTER_NAME \
  --region $CLUSTER_LOCATION \
  --project $PROJECT_ID \
  --flatten "config:"

gcloud container node-pools describe apigee-runtime \
  --cluster $CLUSTER_NAME \
  --region $CLUSTER_LOCATION \
  --project $PROJECT_ID \
  --flatten "config:"

Zonale Cluster

gcloud container node-pools describe apigee-data \
  --cluster $CLUSTER_NAME \
  --zone $CLUSTER_LOCATION \
  --project $PROJECT_ID \
  --flatten "config:"

gcloud container node-pools describe apigee-runtime \
  --cluster $CLUSTER_NAME \
  --zone $CLUSTER_LOCATION \
  --project $PROJECT_ID \
  --flatten "config:"

Die Ausgabe sollte in etwa so aussehen:

---
diskSizeGb: 100
diskType: pd-standard
...
workloadMetadataConfig:
  mode: GKE_METADATA

Tipp:Sie können die Ausgabe auf das Feld workloadMetadataConfig beschränken, indem Sie die Ausgabe mit dem Flag -A 1 über grep weiterleiten, um die folgende Zeile einzufügen:

gcloud container node-pools describe apigee-data \
  --cluster $CLUSTER_NAME \
  --region $CLUSTER_LOCATION \
  --project $PROJECT_ID \
  --flatten "config:" | grep "workloadMetadataConfig" -A 1

WIF auf anderen Plattformen

Wenn Sie die Workload Identity-Föderation auf anderen Plattformen als GKE verwenden, können Sie die SA-Authentifizierung mit den folgenden Methoden konfigurieren:

Kubernetes-Secrets
JSON-Dateien für Dienstkonten
Vault

Wählen Sie in der folgenden Anleitung den Tab für die von Ihnen verwendete Authentifizierungsmethode aus.

In diesem Verfahren werden die folgenden zwei Umgebungsvariablen verwendet, die in Schritt 2: Apigee Helm-Diagramme herunterladen definiert sind. Diese Variablen sind optional. Wenn Sie sie nicht definiert haben, ersetzen Sie für jede Variable in den Codebeispielen den entsprechenden Verzeichnispfad.

$APIGEE_HELM_CHARTS_HOME: Das Verzeichnis, in das Sie die Apigee-Helm-Diagramme heruntergeladen haben, die in Schritt 2: Apigee-Helm-Diagramme herunterladen definiert sind.
$PROJECT_ID: Ihre Google Cloud-Projekt-ID, die in Teil 1: Projekt- und Organisationseinrichtung – Schritt 1: APIs aktivieren definiert ist.

Bei Installationen auf AKS muss der OpenID Connect-Aussteller (OIDC) aktiviert sein. Sie müssen diese Funktion aktivieren, damit die Identitätsföderation von Arbeitslasten auf die OpenID Connect-Metadaten und das JSON Web Key Set (JWKS) für den Cluster zugreifen kann.

Cluster für die Verwendung der Identitätsföderation von Arbeitslasten konfigurieren

Prüfen Sie mit dem folgenden Befehl, ob die aktuelle gcloud-Konfiguration auf Ihre Google Cloud-Projekt-ID festgelegt ist:
```
gcloud config get project
```

Legen Sie gegebenenfalls die aktuelle gcloud-Konfiguration fest:

gcloud config set project $PROJECT_ID

Aktivieren Sie die Security Token Service API:
Prüfen Sie mit dem folgenden Befehl, ob die Security Token Service API aktiviert ist:
```
gcloud services list --enabled --project $PROJECT_ID | grep sts.googleapis.com
```
Falls die API nicht aktiviert ist:
Console

Enable the Security Token Service API.
Roles required to enable APIs
To enable APIs, you need the Service Usage Admin IAM role (roles/serviceusage.serviceUsageAdmin), which contains the serviceusage.services.enable permission. Learn how to grant roles.
Enable the API
Befehlszeile

Aktivieren Sie die API mit dem folgenden Befehl:
```
gcloud services enable sts.googleapis.com --project $PROJECT_ID
```
Erstellen Sie den Workload Identity-Pool und Provider.
Erforderliche Rollen
Bitten Sie Ihren Administrator, Ihnen die folgenden IAM-Rollen für das Projekt zuzuweisen, um die Berechtigungen zu erhalten, die Sie zum Konfigurieren der Identitätsföderation von Arbeitslasten benötigen:
- Workload Identity Pool Admin (roles/iam.workloadIdentityPoolAdmin)
- Service Account Admin (roles/iam.serviceAccountAdmin)
Weitere Informationen zum Zuweisen von Rollen finden Sie unter Zugriff auf Projekte, Ordner und Organisationen verwalten.

Sie können die erforderlichen Berechtigungen auch über benutzerdefinierte Rollen oder andere vordefinierte Rollen erhalten.

Alternativ enthält die einfache Rolle „IAM-Inhaber“ (roles/owner) auch Berechtigungen zum Konfigurieren der Identitätsföderation. In einer Produktionsumgebung sollten Sie keine einfachen Rollen zuweisen, in einer Entwicklungs- oder Testumgebung ist dies aber unproblematisch.
So erstellen Sie einen Workload Identity-Pool und Provider:
1. Bestimmen Sie die Aussteller-URL Ihres AKS-Clusters:
  AKS
  az aks show -n CLUSTER_NAME -g RESOURCE_GROUP --query "oidcIssuerProfile.issuerUrl" -otsv
  Ersetzen Sie Folgendes:
  - CLUSTER_NAME ist der Name des Clusters.
  - RESOURCE_GROUP ist die Ressourcengruppe des Clusters.
  Der Befehl gibt die Aussteller-URL aus. Sie benötigen diese in einem der folgenden Schritte.
  
  Wenn der Befehl keine Aussteller-URL zurückgibt, prüfen Sie, ob Sie das Feature OIDC-Aussteller aktiviert haben.
  EKS
  aws eks describe-cluster --name CLUSTER_NAME --query "cluster.identity.oidc.issuer" --output text
  Ersetzen Sie CLUSTER_NAME durch den Namen des Clusters.
  
  Der Befehl gibt die Aussteller-URL aus. Sie benötigen diese in einem der folgenden Schritte.
  Andere Kubernetes-Produkte
  
  Stellen Sie eine Verbindung zu Ihrem Kubernetes-Cluster her und finden Sie mit „kubectl“ die Aussteller-URL des Clusters heraus:
  kubectl get --raw /.well-known/openid-configuration | jq -r .issuer
  Sie benötigen diese in einem der folgenden Schritte.
2. Optional: Wenn der OIDC-Aussteller nicht öffentlich zugänglich ist, laden Sie das JSON Web Key Set (JWKS) des Clusters herunter:
  Hinweis: Für diesen Schritt ist kubectl-Zugriff auf Ihren Cluster erforderlich.
  
  Tipp: Bei Verwendung der JWKS-Datei müssen Sie jedes Mal eine neue JWKS-Datei hochladen, wenn Sie die Signaturschlüssel für den Cluster rotieren.
```
kubectl get --raw /openid/v1/jwks > cluster-jwks.json
```
  Um zu prüfen, ob Ihr OIDC-Anbieter öffentlich verfügbar ist, sollten Sie mit einem CURL-Befehl auf die Anbieter-URL zugreifen und eine 200-Antwort erhalten können.
3. Erstellen Sie einen neuen Workload Identity-Pool:
```
gcloud iam workload-identity-pools create POOL_ID \
    --location="global" \
    --description="DESCRIPTION" \
    --display-name="DISPLAY_NAME"
```
  Ersetzen Sie Folgendes:
  - POOL_ID ist die eindeutige ID des Pools.
  - DISPLAY_NAME (optional) ist der Name des Pools.
  - DESCRIPTION (optional) ist eine Beschreibung des von Ihnen gewählten Pools. Diese Beschreibung wird angezeigt, wenn Sie Zugriff auf Poolidentitäten gewähren.
  Beispiel:
```
gcloud iam workload-identity-pools create my-wi-pool --display-name="My workload pool" --description="My workload pool description"
```
4. Fügen Sie den Cluster als Workload Identity Provider hinzu. Wählen Sie den Befehl zum Erstellen des Providers abhängig davon aus, ob der OIDC-Aussteller öffentlich zugänglich oder nicht öffentlich zugänglich ist:
  Öffentlich zugänglich
  
  Wenn der OIDC-Aussteller öffentlich zugänglich ist, erstellen Sie den Provider mit dem folgenden Befehl:
  gcloud iam workload-identity-pools providers create-oidc WORKLOAD_PROVIDER_ID \ --location="global" \ --workload-identity-pool="POOL_ID" \ --issuer-uri="ISSUER" \ --attribute-mapping="google.subject=assertion.sub"
  Nicht öffentlich zugänglich
  
  Wenn der OIDC-Aussteller nicht öffentlich zugänglich ist, erstellen Sie den Provider mit dem folgenden Befehl:
  gcloud iam workload-identity-pools providers create-oidc WORKLOAD_PROVIDER_ID \ --location="global" \ --workload-identity-pool="POOL_ID" \ --issuer-uri="ISSUER" \ --jwks-file="cluster-jwks.json" \ --attribute-mapping="google.subject=assertion.sub"
  Hinweis:Wenn Sie Ihre Schlüssel rotieren, müssen Sie bei jeder Schlüsselrotation das neue JWKS hochladen.
  Durch den Befehl wird das JWKS des Clusters nicht validiert. Wenn es fehlerhaft oder abgelaufen ist, können nachfolgende Authentifizierungsversuche mit der Fehlermeldung Error connecting to the given credential's issuer fehlschlagen.
  Ersetzen Sie Folgendes:
  - WORKLOAD_PROVIDER_ID: eine eindeutige Anbieter-ID für Workload Identity-Pool Ihrer Wahl.
  - POOL_ID: Die ID des Workload Identity-Pools, den Sie zuvor erstellt haben.
  - ISSUER ist die Aussteller-URL, die Sie zuvor für den Aussteller-URI herausgefunden haben.
  attribute-mapping="google.subject=assertion.sub" ordnet das Kubernetes-Subjekt dem IAM-Subjekt zu.

Konfigurationsdateien mit Anmeldedaten erstellen

Wenn Sie eine Kubernetes-Arbeitslast bereitstellen möchten, die auf Ressourcen von Google Cloud zugreifen kann, müssen Sie zuerst für jedes IAM-Dienstkonto eine Konfigurationsdatei mit Anmeldedaten erstellen:

Listen Sie die IAM-Dienstkonten (auch als „Google-Dienstkonten“ bezeichnet) mit dem folgenden Befehl auf:
```
gcloud iam service-accounts list --project $PROJECT_ID
```
Hinweis:Sie haben die IAM-Dienstkonten (auch als „Google-Dienstkonten“ bezeichnet) wahrscheinlich bereits bei der Erstinstallation von Apigee Hybrid mit dem Tool create-service-account erstellt. Eine Liste der von Apigee Hybrid benötigten IAM-Dienstkonten finden Sie unter Informationen zu Dienstkonten. Eine Anleitung zum Erstellen der IAM-Dienstkonten finden Sie in der Installationsanleitung in Schritt 4: Dienstkonten erstellen.

Sie müssen Konfigurationsdateien mit Anmeldedaten für die folgenden IAM-Dienstkonten erstellen:
Produktion

Für Produktionsumgebungen:
```
DISPLAY NAME         EMAIL                                                      DISABLED
apigee-cassandra     apigee-cassandra@my_project_id.iam.gserviceaccount.com     False
apigee-mart          apigee-mart@my_project_id.iam.gserviceaccount.com          False
apigee-metrics       apigee-metrics@my_project_id.iam.gserviceaccount.com       False
apigee-runtime       apigee-runtime@my_project_id.iam.gserviceaccount.com       False
apigee-synchronizer  apigee-synchronizer@my_project_id.iam.gserviceaccount.com  False
apigee-udca          apigee-udca@my_project_id.iam.gserviceaccount.com          False
apigee-watcher       apigee-watcher@my_project_id.iam.gserviceaccount.com       False
```
Wenn Sie Monetization for Apigee Hybrid in v1.15.1 oder höher verwenden, müssen Sie auch die Konfigurationsdatei für Anmeldedaten für das apigee-mint-task-scheduler-Dienstkonto erstellen.
```
DISPLAY NAME                 EMAIL                                                              DISABLED
...
apigee-mint-task-scheduler   apigee-mint-task-scheduler@my_project_id.iam.gserviceaccount.com   False
...
```
Non-prod

Für Nicht-Produktionsumgebungen:
```
DISPLAY NAME         EMAIL                                                      DISABLED
apigee-non-prod      apigee-non-prod@my_project_id.iam.gserviceaccount.com      False
```
Tipp:Wenn Sie benutzerdefinierte Namen für Ihre Dienstkonten haben, die nicht einfach den Namen der Apigee-Komponenten entsprechen, können Sie die Rolle jedes Dienstkontos ermitteln, indem Sie die ihm zugewiesenen Rollen prüfen und mit den in Dienstkonten empfohlenen Rollen vergleichen.
Mit dem folgenden Befehl können Sie die einem Dienstkonto zugewiesenen Rollen prüfen:
```
gcloud projects get-iam-policy $PROJECT_ID  \
    --flatten="bindings[].members" \
    --format='table(bindings.role)' \
    --filter="SERVICE_ACCOUNT_NAME"
```
Notieren Sie sich für jedes IAM-Dienstkonto in der vorherigen Liste das entsprechende benutzerdefinierte Dienstkonto.

Erstellen Sie für jedes IAM-Dienstkonto in der vorherigen Liste eine Konfigurationsdatei mit Anmeldedaten.

WIF: Secrets

Bei diesem Ansatz werden Anmeldedatenkonfigurationen verwendet, die in Kubernetes-Secrets gespeichert sind. Wenn Sie die Überschreibungsdatei in Schritt 7: Überschreibungen erstellen erstellen, geben Sie den Namen des Secrets für jedes Dienstkonto mit dem Attribut serviceAccountRef oder envs.serviceAccountRefs an.

Konfigurationsdateien mit Anmeldedaten erstellen

Produktion

Sie müssen Konfigurationsdateien mit Anmeldedaten für die folgenden Dienstkonten erstellen:

apigee-cassandra
apigee-mart
apigee-metrics
apigee-mint-task-scheduler Wenn Sie Monetarisierung für Apigee Hybrid verwenden.
apigee-runtime
apigee-synchronizer
apigee-udca

Erstellen Sie ein Verzeichnis für die Konfigurationsdateien für Anmeldedaten. Das Verzeichnis kann einen beliebigen Namen haben. In diesem Verfahren heißt das Verzeichnis credential-configurations:
```
mkdir $APIGEE_HELM_CHARTS_HOME/credential-configurations
```

Erstellen Sie die Konfigurationsdatei für Anmeldedaten für apigee-cassandra:

gcloud iam workload-identity-pools create-cred-config \
  projects/PROJECT_NUMBER/locations/global/workloadIdentityPools/POOL_ID/providers/WORKLOAD_PROVIDER_ID \
  --service-account=apigee-cassandra@$PROJECT_ID.iam.gserviceaccount.com \
  --credential-source-file=/var/run/service-account/token \
  --credential-source-type=text \
  --output-file=$APIGEE_HELM_CHARTS_HOME/credential-configurations/apigee-cassandra-credential-configuration.json

Wobei:

PROJECT_NUMBER ist die Projektnummer des Projekts, das den Workload Identity-Pool enthält. Dies muss die Projektnummer und nicht die Projekt-ID sein.
POOL_ID ist die ID des Workload Identity-Pools.
WORKLOAD_PROVIDER_ID ist die ID des Workload Identity Providers.

Wichtig:credential-source-type muss auf text festgelegt sein.

Erstellen Sie die Konfigurationsdatei für Anmeldedaten für apigee-mart:

gcloud iam workload-identity-pools create-cred-config \
  projects/PROJECT_NUMBER/locations/global/workloadIdentityPools/POOL_ID/providers/WORKLOAD_PROVIDER_ID \
  --service-account=apigee-mart@$PROJECT_ID.iam.gserviceaccount.com \
  --credential-source-file=/var/run/service-account/token \
  --credential-source-type=text \
  --output-file=$APIGEE_HELM_CHARTS_HOME/credential-configurations/apigee-mart-credential-configuration.json

Erstellen Sie die Konfigurationsdatei für Anmeldedaten für apigee-metrics:

gcloud iam workload-identity-pools create-cred-config \
  projects/PROJECT_NUMBER/locations/global/workloadIdentityPools/POOL_ID/providers/WORKLOAD_PROVIDER_ID \
  --service-account=apigee-metrics@$PROJECT_ID.iam.gserviceaccount.com \
  --credential-source-file=/var/run/service-account/token \
  --credential-source-type=text \
  --output-file=$APIGEE_HELM_CHARTS_HOME/credential-configurations/apigee-metrics-credential-configuration.json

Erstellen Sie die Konfigurationsdatei für Anmeldedaten für apigee-runtime:

gcloud iam workload-identity-pools create-cred-config \
  projects/PROJECT_NUMBER/locations/global/workloadIdentityPools/POOL_ID/providers/WORKLOAD_PROVIDER_ID \
  --service-account=apigee-runtime@$PROJECT_ID.iam.gserviceaccount.com \
  --credential-source-file=/var/run/service-account/token \
  --credential-source-type=text \
  --output-file=$APIGEE_HELM_CHARTS_HOME/credential-configurations/apigee-runtime-credential-configuration.json

Erstellen Sie die Konfigurationsdatei für Anmeldedaten für apigee-synchronizer:

gcloud iam workload-identity-pools create-cred-config \
  projects/PROJECT_NUMBER/locations/global/workloadIdentityPools/POOL_ID/providers/WORKLOAD_PROVIDER_ID \
  --service-account=apigee-synchronizer@$PROJECT_ID.iam.gserviceaccount.com \
  --credential-source-file=/var/run/service-account/token \
  --credential-source-type=text \
  --output-file=$APIGEE_HELM_CHARTS_HOME/credential-configurations/apigee-synchronizer-credential-configuration.json

Erstellen Sie die Konfigurationsdatei für Anmeldedaten für apigee-udca:

gcloud iam workload-identity-pools create-cred-config \
  projects/PROJECT_NUMBER/locations/global/workloadIdentityPools/POOL_ID/providers/WORKLOAD_PROVIDER_ID \
  --service-account=apigee-udca@$PROJECT_ID.iam.gserviceaccount.com \
  --credential-source-file=/var/run/service-account/token \
  --credential-source-type=text \
  --output-file=$APIGEE_HELM_CHARTS_HOME/credential-configurations/apigee-udca-credential-configuration.json

Erstellen Sie die Konfigurationsdatei für Anmeldedaten für apigee-watcher:

gcloud iam workload-identity-pools create-cred-config \
  projects/PROJECT_NUMBER/locations/global/workloadIdentityPools/POOL_ID/providers/WORKLOAD_PROVIDER_ID \
  --service-account=apigee-watcher@$PROJECT_ID.iam.gserviceaccount.com \
  --credential-source-file=/var/run/service-account/token \
  --credential-source-type=text \
  --output-file=$APIGEE_HELM_CHARTS_HOME/credential-configurations/apigee-watcher-credential-configuration.json

Wenn Sie die Monetarisierung für Apigee Hybrid verwenden, müssen Sie auch die Konfigurationsdatei für Anmeldedaten für apigee-mint-task-scheduler erstellen:

gcloud iam workload-identity-pools create-cred-config \
  projects/PROJECT_NUMBER/locations/global/workloadIdentityPools/POOL_ID/providers/WORKLOAD_PROVIDER_ID \
  --service-account=apigee-mint-task-scheduler@$PROJECT_ID.iam.gserviceaccount.com \
  --credential-source-file=/var/run/service-account/token \
  --credential-source-type=text \
  --output-file=$APIGEE_HELM_CHARTS_HOME/credential-configurations/apigee-mint-task-scheduler-credential-configuration.json

Hinweis:Erstellen Sie keine Konfigurationsdatei mit Anmeldedaten für das Dienstkonto apigee-logger.

Non-prod

Erstellen Sie ein Verzeichnis für die Konfigurationsdatei für Anmeldedaten. Das Verzeichnis kann einen beliebigen Namen haben. In diesem Verfahren heißt das Verzeichnis credential-configurations:
```
mkdir $APIGEE_HELM_CHARTS_HOME/credential-configurations
```
Erstellen Sie die Konfigurationsdatei mit Anmeldedaten für das apigee-non-prod-Dienstkonto im Verzeichnis credential-configurations mit dem folgenden Befehl:
```
gcloud iam workload-identity-pools create-cred-config \
projects/PROJECT_NUMBER/locations/global/workloadIdentityPools/POOL_ID/providers/WORKLOAD_PROVIDER_ID \
  --service-account=apigee-non-prod@$PROJECT_ID.iam.gserviceaccount.com \
  --credential-source-file=/var/run/service-account/token \
  --credential-source-type=text \
  --output-file=$APIGEE_HELM_CHARTS_HOME/credential-configurations/apigee-non-prod-credential-configuration.json
```
Wobei:
- PROJECT_NUMBER ist die Projektnummer des Projekts, das den Workload Identity-Pool enthält. Dies muss die Projektnummer und nicht die Projekt-ID sein.
- POOL_ID ist die ID des Workload Identity-Pools.
- WORKLOAD_PROVIDER_ID ist die ID des Workload Identity Providers.
Wichtig:credential-source-type muss auf text festgelegt sein.

Kubernetes-Secrets erstellen

Erstellen Sie die Kubernetes-Secrets zum Speichern der Konfigurationsdateien mit Anmeldedaten für jedes Dienstkonto.

Der Befehl kubectl create secret in den folgenden Codebeispielen hat die Struktur:

kubectl create secret generic SECRET_NAME \
        --from-file="client_secret.json=PATH_TO_CREDENTIAL_CONFIGURATION_FILE" \
        -n APIGEE_NAMESPACE

Produktion

Erstellen Sie die Secret-Datei für apigee-cassandra:

kubectl create secret generic apigee-cassandra-svc-account \
  --from-file="client_secret.json=$APIGEE_HELM_CHARTS_HOME/credential-configurations/$PROJECT_ID-apigee-cassandra.json" \
  -n APIGEE_NAMESPACE

Erstellen Sie die Secret-Datei für apigee-mart:

kubectl create secret generic apigee-mart-svc-account \
  --from-file="client_secret.json=$APIGEE_HELM_CHARTS_HOME/credential-configurations/$PROJECT_ID-apigee-mart.json" \
  -n APIGEE_NAMESPACE

Erstellen Sie die Secret-Datei für apigee-metrics:

kubectl create secret generic apigee-metrics-svc-account \
  --from-file="client_secret.json=$APIGEE_HELM_CHARTS_HOME/credential-configurations/$PROJECT_ID-apigee-metrics.json" \
  -n APIGEE_NAMESPACE

Erstellen Sie die Secret-Datei für apigee-runtime:

kubectl create secret generic apigee-runtime-svc-account \
  --from-file="client_secret.json=$APIGEE_HELM_CHARTS_HOME/credential-configurations/$PROJECT_ID-apigee-runtime.json" \
  -n APIGEE_NAMESPACE

Erstellen Sie die Secret-Datei für apigee-synchronizer:

kubectl create secret generic apigee-synchronizer-svc-account \
  --from-file="client_secret.json=$APIGEE_HELM_CHARTS_HOME/credential-configurations/$PROJECT_ID-apigee-synchronizer.json" \
  -n APIGEE_NAMESPACE

Erstellen Sie die Secret-Datei für apigee-udca:

kubectl create secret generic apigee-udca-svc-account \
  --from-file="client_secret.json=$APIGEE_HELM_CHARTS_HOME/credential-configurations/$PROJECT_ID-apigee-udca.json" \
  -n APIGEE_NAMESPACE

Erstellen Sie die Secret-Datei für apigee-watcher:

kubectl create secret generic apigee-watcher-svc-account \
  --from-file="client_secret.json=$APIGEE_HELM_CHARTS_HOME/credential-configurations/$PROJECT_ID-apigee-watcher.json" \
  -n APIGEE_NAMESPACE

Wenn Sie Monetization für Apigee Hybrid verwenden, erstellen Sie die Secret-Datei für apigee-mint-task-scheduler:

kubectl create secret generic apigee-mint-task-scheduler-svc-account \
  --from-file="client_secret.json=$APIGEE_HELM_CHARTS_HOME/credential-configurations/$PROJECT_ID-apigee-mint-task-scheduler.json" \
  -n APIGEE_NAMESPACE

Erstellen Sie die Secret-Datei für apigee-non-prod:

Non-prod

kubectl create secret generic apigee-non-prod-svc-account \
        --from-file="client_secret.json=$APIGEE_HELM_CHARTS_HOME/credential-configurations/$PROJECT_ID-apigee-non-prod.json" \
        -n APIGEE_NAMESPACE

WIF: Dateien

Bei diesem Ansatz werden die Konfigurationsdateien für Anmeldedaten anstelle der Google-Dienstkontoschlüsseldateien verwendet. Wenn Sie die Überschreibungsdatei in Schritt 7: Überschreibungen erstellen erstellen, geben Sie den Pfad zur Konfigurationsdatei für Anmeldedaten für jede serviceAccountPath- oder envs.serviceAccountPaths-Eigenschaft an.

Produktion

Sie müssen die Konfigurationsdateien mit Anmeldedaten in den entsprechenden Diagrammverzeichnissen erstellen:

Dienstkonto	Apigee Helm-Diagrammverzeichnis
`apigee-cassandra`	`apigee-datastore/`
`apigee-mart`	`apigee-org/`
`apigee-metrics`	`apigee-telemetry/`
`apigee-mint-task-scheduler` (Bei Verwendung der Monetarisierung für Apigee Hybrid)	`apigee-org/`
`apigee-runtime`	`apigee-env/`
`apigee-synchronizer`	`apigee-env/`
`apigee-udca`	`apigee-org/` `apigee-env/`
`apigee-watcher`	`apigee-org/`

Erstellen Sie die Konfigurationsdateien mit Anmeldedaten mit den folgenden Befehlen:

apigee-cassandra:

gcloud iam workload-identity-pools create-cred-config \
  projects/PROJECT_NUMBER/locations/global/workloadIdentityPools/POOL_ID/providers/WORKLOAD_PROVIDER_ID \
  --service-account=apigee-cassandra@$PROJECT_ID.iam.gserviceaccount.com \
  --credential-source-file=/var/run/service-account/token \
  --credential-source-type=text \
  --output-file=$APIGEE_HELM_CHARTS_HOME/apigee-datastore/apigee-cassandra-credential-configuration.json

Wobei:

PROJECT_NUMBER ist die Projektnummer des Projekts, das den Workload Identity-Pool enthält. Dies muss die Projektnummer und nicht die Projekt-ID sein.
POOL_ID ist die ID des Workload Identity-Pools.
WORKLOAD_PROVIDER_ID ist die ID des Workload Identity Providers.

Wichtig:credential-source-type muss auf text festgelegt sein.

apigee-mart:

gcloud iam workload-identity-pools create-cred-config \
  projects/PROJECT_NUMBER/locations/global/workloadIdentityPools/POOL_ID/providers/WORKLOAD_PROVIDER_ID \
  --service-account=apigee-mart@$PROJECT_ID.iam.gserviceaccount.com \
  --credential-source-file=/var/run/service-account/token \
  --credential-source-type=text \
  --output-file=$APIGEE_HELM_CHARTS_HOME/apigee-org/apigee-mart-credential-configuration.json

apigee-metrics:

gcloud iam workload-identity-pools create-cred-config \
  projects/PROJECT_NUMBER/locations/global/workloadIdentityPools/POOL_ID/providers/WORKLOAD_PROVIDER_ID \
  --service-account=apigee-metrics@$PROJECT_ID.iam.gserviceaccount.com \
  --credential-source-file=/var/run/service-account/token \
  --credential-source-type=text \
  --output-file=$APIGEE_HELM_CHARTS_HOME/apigee-telemetry/apigee-metrics-credential-configuration.json

apigee-runtime:

gcloud iam workload-identity-pools create-cred-config \
  projects/PROJECT_NUMBER/locations/global/workloadIdentityPools/POOL_ID/providers/WORKLOAD_PROVIDER_ID \
  --service-account=apigee-runtime@$PROJECT_ID.iam.gserviceaccount.com \
  --credential-source-file=/var/run/service-account/token \
  --credential-source-type=text \
  --output-file=$APIGEE_HELM_CHARTS_HOME/apigee-env/apigee-runtime-credential-configuration.json

apigee-synchronizer:

gcloud iam workload-identity-pools create-cred-config \
  projects/PROJECT_NUMBER/locations/global/workloadIdentityPools/POOL_ID/providers/WORKLOAD_PROVIDER_ID \
  --service-account=apigee-synchronizer@$PROJECT_ID.iam.gserviceaccount.com \
  --credential-source-file=/var/run/service-account/token \
  --credential-source-type=text \
  --output-file=$APIGEE_HELM_CHARTS_HOME/apigee-env/apigee-synchronizer-credential-configuration.json

apigee-udca:

Das Dienstkonto apigee-udca wird sowohl von den Diagrammen apigee-org als auch apigee-env verwendet.

Erstellen Sie die Konfigurationsdatei mit den Anmeldedaten im Diagrammverzeichnis apigee-org.

gcloud iam workload-identity-pools create-cred-config \
  projects/PROJECT_NUMBER/locations/global/workloadIdentityPools/POOL_ID/providers/WORKLOAD_PROVIDER_ID \
  --service-account=apigee-udca@$PROJECT_ID.iam.gserviceaccount.com \
  --credential-source-file=/var/run/service-account/token \
  --credential-source-type=text \
  --output-file=$APIGEE_HELM_CHARTS_HOME/apigee-org/apigee-udca-credential-configuration.json

Kopieren Sie die Konfigurationsdatei für Anmeldedaten in das Diagrammverzeichnis apigee-env.

cp $APIGEE_HELM_CHARTS_HOME/apigee-org/apigee-udca-credential-configuration.json \
  $APIGEE_HELM_CHARTS_HOME/apigee-env/apigee-udca-credential-configuration.json

apigee-watcher:

gcloud iam workload-identity-pools create-cred-config \
  projects/PROJECT_NUMBER/locations/global/workloadIdentityPools/POOL_ID/providers/WORKLOAD_PROVIDER_ID \
  --service-account=apigee-watcher@$PROJECT_ID.iam.gserviceaccount.com \
  --credential-source-file=/var/run/service-account/token \
  --credential-source-type=text \
  --output-file=$APIGEE_HELM_CHARTS_HOME/apigee-org/apigee-watcher-credential-configuration.json

Wenn Sie href="monetization-for-hybrid">Monetization for Apigee Hybrid verwenden, müssen Sie auch die Konfigurationsdatei für Anmeldedaten für apigee-mint-task-scheduler erstellen:

gcloud iam workload-identity-pools create-cred-config \
  projects/PROJECT_NUMBER/locations/global/workloadIdentityPools/POOL_ID/providers/WORKLOAD_PROVIDER_ID \
  --service-account=apigee-mint-task-scheduler@$PROJECT_ID.iam.gserviceaccount.com \
  --credential-source-file=/var/run/service-account/token \
  --credential-source-type=text \
  --output-file=$APIGEE_HELM_CHARTS_HOME/apigee-org/apigee-mint-task-scheduler-credential-configuration.json

Hinweis:Erstellen Sie keine Konfigurationsdatei mit Anmeldedaten für das Dienstkonto apigee-logger.

Non-prod

Sie müssen die Konfigurationsdatei für die Anmeldedaten erstellen und in die entsprechenden Diagrammverzeichnisse kopieren:

Dienstkonto	Apigee Helm-Diagramm
`apigee-non-prod`	`apigee-datastore/` `apigee-telemetry/` `apigee-org/` `apigee-env/`

Erstellen Sie die Konfigurationsdatei für die Anmeldedaten im apigee-datastore-Diagrammverzeichnis mit dem folgenden Befehl:
```
gcloud iam workload-identity-pools create-cred-config \
projects/PROJECT_NUMBER/locations/global/workloadIdentityPools/POOL_ID/providers/WORKLOAD_PROVIDER_ID \
--service-account=apigee-non-prod@$PROJECT_ID.iam.gserviceaccount.com \
--credential-source-file=/var/run/service-account/token \
--credential-source-type=text \
--output-file=$APIGEE_HELM_CHARTS_HOME/apigee-datastore/apigee-non-prod-credential-configuration.json
```
Wobei:
- PROJECT_NUMBER ist die Projektnummer des Projekts, das den Workload Identity-Pool enthält. Dies muss die Projektnummer und nicht die Projekt-ID sein.
- POOL_ID ist die ID des Workload Identity-Pools.
- WORKLOAD_PROVIDER_ID ist die ID des Workload Identity Providers.
Wichtig:credential-source-type muss auf text festgelegt sein.

Kopieren Sie die Konfigurationsdatei für Anmeldedaten in die Diagrammverzeichnisse apigee-env, apigee-org/ und apigee-telemetry/.

cp $APIGEE_HELM_CHARTS_HOME/apigee-datastore/apigee-non-prod-credential-configuration.json \
  $APIGEE_HELM_CHARTS_HOME/apigee-env/apigee-non-prod-credential-configuration.json
cp $APIGEE_HELM_CHARTS_HOME/apigee-datastore/apigee-non-prod-credential-configuration.json \
  $APIGEE_HELM_CHARTS_HOME/apigee-org/apigee-non-prod-credential-configuration.json
cp $APIGEE_HELM_CHARTS_HOME/apigee-datastore/apigee-non-prod-credential-configuration.json \
  $APIGEE_HELM_CHARTS_HOME/apigee-telemetry/apigee-non-prod-credential-configuration.json

WIF: Vault

Bei diesem Ansatz werden Anmeldedatenkonfigurationen verwendet, die in einem externen Secret Manager, HashiCorp Vault, gespeichert sind. Wenn Sie die Überschreibungendatei in Schritt 7: Überschreibungen erstellen erstellen, geben Sie Vault-Secrets auf Organisations- und Umgebungsebene mit den Attributen serviceAccountSecretProviderClass oder envs.serviceAccountSecretProviderClass an.

Konfigurationsdateien mit Anmeldedaten erstellen

Produktion

Sie müssen Konfigurationsdateien mit Anmeldedaten für die folgenden Dienstkonten erstellen:

apigee-cassandra
apigee-mart
apigee-metrics
apigee-mint-task-scheduler (Wenn Sie die Monetarisierung für Apigee Hybrid verwenden)
apigee-runtime
apigee-synchronizer
apigee-udca

Erstellen Sie ein Verzeichnis für die Konfigurationsdateien für Anmeldedaten. Das Verzeichnis kann einen beliebigen Namen haben. In diesem Verfahren heißt das Verzeichnis credential-configurations:
```
mkdir $APIGEE_HELM_CHARTS_HOME/credential-configurations
```

Erstellen Sie die Konfigurationsdatei für Anmeldedaten für apigee-cassandra:

gcloud iam workload-identity-pools create-cred-config \
  projects/PROJECT_NUMBER/locations/global/workloadIdentityPools/POOL_ID/providers/WORKLOAD_PROVIDER_ID \
  --service-account=apigee-cassandra@$PROJECT_ID.iam.gserviceaccount.com \
  --credential-source-file=/var/run/service-account/token \
  --credential-source-type=text \
  --output-file=$APIGEE_HELM_CHARTS_HOME/credential-configurations/apigee-cassandra-credential-configuration.json

Wobei:

PROJECT_NUMBER ist die Projektnummer des Projekts, das den Workload Identity-Pool enthält. Dies muss die Projektnummer und nicht die Projekt-ID sein.
POOL_ID ist die ID des Workload Identity-Pools.
WORKLOAD_PROVIDER_ID ist die ID des Workload Identity Providers.

Wichtig:credential-source-type muss auf text festgelegt sein.

Erstellen Sie die Konfigurationsdatei für Anmeldedaten für apigee-mart:

gcloud iam workload-identity-pools create-cred-config \
  projects/PROJECT_NUMBER/locations/global/workloadIdentityPools/POOL_ID/providers/WORKLOAD_PROVIDER_ID \
  --service-account=apigee-mart@$PROJECT_ID.iam.gserviceaccount.com \
  --credential-source-file=/var/run/service-account/token \
  --credential-source-type=text \
  --output-file=$APIGEE_HELM_CHARTS_HOME/credential-configurations/apigee-mart-credential-configuration.json

Erstellen Sie die Konfigurationsdatei für Anmeldedaten für apigee-metrics:

gcloud iam workload-identity-pools create-cred-config \
  projects/PROJECT_NUMBER/locations/global/workloadIdentityPools/POOL_ID/providers/WORKLOAD_PROVIDER_ID \
  --service-account=apigee-metrics@$PROJECT_ID.iam.gserviceaccount.com \
  --credential-source-file=run/service-account/token \
  --credential-source-type=text \
  --output-file=$APIGEE_HELM_CHARTS_HOME/credential-configurations/apigee-metrics-credential-configuration.json

Erstellen Sie die Konfigurationsdatei für Anmeldedaten für apigee-runtime:

gcloud iam workload-identity-pools create-cred-config \
  projects/PROJECT_NUMBER/locations/global/workloadIdentityPools/POOL_ID/providers/WORKLOAD_PROVIDER_ID \
  --service-account=apigee-runtime@$PROJECT_ID.iam.gserviceaccount.com \
  --credential-source-file=/var/run/service-account/token \
  --credential-source-type=text \
  --output-file=$APIGEE_HELM_CHARTS_HOME/credential-configurations/apigee-runtime-credential-configuration.json

Erstellen Sie die Konfigurationsdatei für Anmeldedaten für apigee-synchronizer:

gcloud iam workload-identity-pools create-cred-config \
  projects/PROJECT_NUMBER/locations/global/workloadIdentityPools/POOL_ID/providers/WORKLOAD_PROVIDER_ID \
  --service-account=apigee-synchronizer@$PROJECT_ID.iam.gserviceaccount.com \
  --credential-source-file=/var/run/service-account/token \
  --credential-source-type=text \
  --output-file=$APIGEE_HELM_CHARTS_HOME/credential-configurations/apigee-synchronizer-credential-configuration.json

Erstellen Sie die Konfigurationsdatei für Anmeldedaten für apigee-udca:

gcloud iam workload-identity-pools create-cred-config \
  projects/PROJECT_NUMBER/locations/global/workloadIdentityPools/POOL_ID/providers/WORKLOAD_PROVIDER_ID \
  --service-account=apigee-udca@$PROJECT_ID.iam.gserviceaccount.com \
  --credential-source-file=/var/run/service-account/token \
  --credential-source-type=text \
  --output-file=$APIGEE_HELM_CHARTS_HOME/credential-configurations/apigee-udca-credential-configuration.json

Erstellen Sie die Konfigurationsdatei für Anmeldedaten für apigee-watcher:

gcloud iam workload-identity-pools create-cred-config \
  projects/PROJECT_NUMBER/locations/global/workloadIdentityPools/POOL_ID/providers/WORKLOAD_PROVIDER_ID \
  --service-account=apigee-watcher@$PROJECT_ID.iam.gserviceaccount.com \
  --credential-source-file=/var/run/service-account/token \
  --credential-source-type=text \
  --output-file=$APIGEE_HELM_CHARTS_HOME/credential-configurations/apigee-watcher-credential-configuration.json

Wenn Sie die Monetarisierung für Apigee Hybrid verwenden, müssen Sie auch die Konfigurationsdatei für Anmeldedaten für apigee-mint-task-scheduler erstellen:

gcloud iam workload-identity-pools create-cred-config \
  projects/PROJECT_NUMBER/locations/global/workloadIdentityPools/POOL_ID/providers/WORKLOAD_PROVIDER_ID \
  --service-account=apigee-mint-task-scheduler@$PROJECT_ID.iam.gserviceaccount.com \
  --credential-source-file=/var/run/service-account/token \
  --credential-source-type=text \
  --output-file=$APIGEE_HELM_CHARTS_HOME/credential-configurations/apigee-mint-task-scheduler-credential-configuration.json

Hinweis:Erstellen Sie keine Konfigurationsdatei mit Anmeldedaten für das Dienstkonto apigee-logger.

Non-prod

Erstellen Sie ein Verzeichnis für die Konfigurationsdatei für Anmeldedaten. Das Verzeichnis kann einen beliebigen Namen haben. In diesem Verfahren heißt das Verzeichnis credential-configurations:
```
mkdir $APIGEE_HELM_CHARTS_HOME/credential-configurations
```
Erstellen Sie die Konfigurationsdatei mit Anmeldedaten für das apigee-non-prod-Dienstkonto im Verzeichnis credential-configurations mit dem folgenden Befehl:
```
gcloud iam workload-identity-pools create-cred-config \
projects/PROJECT_NUMBER/locations/global/workloadIdentityPools/POOL_ID/providers/WORKLOAD_PROVIDER_ID \
  --service-account=apigee-non-prod@$PROJECT_ID.iam.gserviceaccount.com \
  --credential-source-file=/var/run/service-account/token \
  --credential-source-type=text \
  --output-file=$APIGEE_HELM_CHARTS_HOME/credential-configurations/apigee-non-prod-credential-configuration.json
```
Wobei:
- PROJECT_NUMBER ist die Projektnummer des Projekts, das den Workload Identity-Pool enthält. Dies muss die Projektnummer und nicht die Projekt-ID sein.
  Tipp:Sie können die Projektnummer mit dem folgenden Befehl ermitteln:
```
gcloud projects describe $PROJECT_ID --format="value(projectNumber)"
```
  "
- POOL_ID ist die ID des Workload Identity-Pools.
- WORKLOAD_PROVIDER_ID ist die ID des Workload Identity Providers.
Wichtig:credential-source-type muss auf text festgelegt sein.

CSI-Treiber und Vault-Anbieter installieren

Informationen zu den von Apigee Hybrid unterstützten Mindestversionen von CSI-Treibern finden Sie unter Von Apigee Hybrid unterstützte Plattformen und Versionen.

Vault-Secrets, -Richtlinien und -Rollen erstellen

Verwenden Sie die Vault-UI oder -APIs, um Secrets zu erstellen und den von Apigee Hybrid verwendeten Kubernetes-Dienstkonten die Berechtigung zum Lesen dieser Secrets zu erteilen.

Erstellen Sie die organisations- und umgebungsspezifischen Secrets im folgenden Format:

Geheimer Schlüssel Secret-Daten

Geheimer Schlüssel	Secret-Daten
secret/data/apigee/orgsakeys	{ "cassandraBackup": "*", "cassandraRestore": "", "connectAgent": "", "logger": "", "mart": "", "metrics": "", "mint": "", "udca": "", "watcher": "" } Hinweis:** `mint` ist nur erforderlich, wenn Sie Monetization for Apigee Hybrid (v1.15.1 und höher) verwenden.
secret/data/apigee/envsakeys-`ENV_NAME`	{ "runtime": "*", "synchronizer": "", "udca": "**". }

secret/data/apigee/orgsakeys

{
  "cassandraBackup": "***",
  "cassandraRestore": "***",
  "connectAgent": "***",
  "logger": "***",
  "mart": "***",
  "metrics": "***",
  "mint": "***",
  "udca": "***",
  "watcher": "***"
}

Hinweis: mint ist nur erforderlich, wenn Sie Monetization for Apigee Hybrid (v1.15.1 und höher) verwenden.

secret/data/apigee/envsakeys-ENV_NAME

{
  "runtime": "***",
  "synchronizer": "***",
  "udca": "***".
    }

Produktion

Ersetzen Sie "***" in jedem Paar durch den Inhalt der Anmeldedaten-Konfigurationsdatei für das Google-Dienstkonto, das der Apigee-Komponente entspricht. apigee-cassandra-backup und apigee-cassandra-restore verwenden beide das Dienstkonto apigee-cassandra. Beispiel:

{
  "cassandraBackup": "{
    "universe_domain": "googleapis.com",
    "type": "external_account:,"
    "audience": "//iam.googleapis.com/projects/123123123123/locations/global/workloadIdentityPools/my-wi-pool/providers/my-wi-provider",
    "subject_token_type": "urn:ietf:params:oauth: token-type:jwt",
    "token_url": "https://sts.googleapis.com/v1/token",
    "service
    "impersonation_url": "https://iamcredentials.googleapis.com/v1/projects/-/serviceAccounts/apigee-cassandra@my-project.iam.gserviceaccount.com:generateAccessToken",
    "credential_source": {
      "file": "/var/run/service-account/token",
      "format": {
        "type": "text"
      }
    }
  }",
  "cassandraRestore":...
...
}

Non-prod

Ersetzen Sie "***" in jedem Paar durch den Inhalt der Anmeldedaten-Konfigurationsdatei für das Dienstkonto apigee-non-prod. apigee-cassandra-backup und apigee-cassandra-restore verwenden beide das Dienstkonto apigee-cassandra. Beispiel:

{
  "cassandraBackup": "{
    "universe_domain": "googleapis.com",
    "type": "external_account:,"
    "audience": "//iam.googleapis.com/projects/123123123123/locations/global/workloadIdentityPools/my-wi-pool/providers/my-wi-provider",
    "subject_token_type": "urn:ietf:params:oauth: token-type:jwt",
    "token_url": "https://sts.googleapis.com/v1/token",
    "service
    "impersonation_url": "https://iamcredentials.googleapis.com/v1/projects/-/serviceAccounts/apigee-non-prod@my-project.iam.gserviceaccount.com:generateAccessToken",
    "credential_source": {
      "file": "/var/run/service-account/token",
      "format": {
        "type": "text"
      }
    }
  }",
  "cassandraRestore":...
...
}

Gewähren Sie Zugriff auf das Organisations-Secret. Erstellen Sie eine Textdatei mit dem Namen „orgsakeys-auth-policy.txt“ und folgendem Inhalt:
```
path "secret/data/apigee/orgsakeys" {
  capabilities = ["read"]
}
```
Erstellen Sie in Vault eine Richtlinie, die Zugriff auf das Organisations-Secret gewährt:
```
vault policy write apigee-orgsakeys-auth orgsakeys-auth-policy.txt
```
Erstellen Sie für jede Umgebung eine Textdatei mit dem Namen envsakeys-ENV_NAME-auth-policy.txt und folgendem Inhalt:
```
path "secret/data/apigee/envsakeys-ENV_NAME" {
  capabilities = ["read"]
}
```
Wiederholen Sie diesen Schritt für jede Umgebung.
Erstellen Sie in Vault eine Richtlinie, die Zugriff auf das Umgebung-Secret gewährt:
```
vault policy write apigee-envsakeys-ENV_NAME-auth envsakeys-ENV_NAME-auth-policy.txt
```
Wiederholen Sie diesen Schritt für jede Umgebung.

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-cassandra-default,apigee-cassandra-backup-sa,apigee-cassandra-restore-sa,apigee-cassandra-schema-setup-${ORG_ENCODE},apigee-cassandra-schema-val-${ORG_ENCODE},apigee-cassandra-user-setup-${ORG_ENCODE},apigee-mart-${ORG_ENCODE},apigee-mint-task-scheduler-${ORG_ENCODE},apigee-connect-agent-${ORG_ENCODE},apigee-watcher-${ORG_ENCODE},apigee-udca-${ORG_ENCODE},apigee-metrics-apigee-telemetry,apigee-open-telemetry-collector-apigee-telemetry,apigee-logger-apigee-telemetry

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

echo $NAMES

Hinweis: Entfernen Sie apigee-mint-task-scheduler-${ORG_ENCODE}, wenn Sie die Monetarisierung für Apigee Hybrid nicht verwenden.

Führen Sie das Skript aus, um die Liste der Dienstkontonamen zu generieren und die Richtlinie an folgende zu binden:

./generate-encoded-sas.sh

Die Ausgabe sollte eine durch Kommas getrennte Liste von Kubernetes-Dienstkontonamen sein, ähnlich dem folgenden Beispiel:

./generate-encoded-sas.sh
apigee-manager,apigee-cassandra-default,apigee-cassandra-backup-sa,
apigee-cassandra-restore-sa,apigee-cassandra-schema-setup-myhybrido
rg-5b044c1,apigee-cassandra-schema-val-myhybridorg-5b044c1,apigee-c
assandra-user-setup-myhybridorg-5b044c1,apigee-mart-myhybridorg-5b0
44c1,apigee-mint-task-scheduler-myhybridorg-5b044c1,apigee-connect-
agent-myhybridorg-5b044c1,apigee-watcher-myhybridorg-5b044c1,apigee
-udca-myhybridorg-5b044c1,apigee-metrics-apigee-telemetry,apigee-op
en-telemetry-collector-apigee-telemetry,apigee-logger-apigee-teleme
try,apigee-synchronizer-myhybridorg-dev-ee52aca,apigee-runtime-myhy
bridorg-dev-ee52aca,apigee-synchronizer-myhybridorg-prod-2d0221c,ap
igee-runtime-myhybridorg-prod-2d0221c

org-Dienstnamen aus dem vorherigen Beispiel:

apigee-manager,apigee-cassandra-default,apigee-cassandra-backup-sa,
apigee-cassandra-restore-sa,apigee-cassandra-schema-setup-myhybrido
rg-5b044c1,apigee-cassandra-schema-val-myhybridorg-5b044c1,apigee-c
assandra-user-setup-myhybridorg-5b044c1,apigee-mart-myhybridorg-5b0
44c1,apigee-mint-task-scheduler-myhybridorg-5b044c1,apigee-connect-
agent-myhybridorg-5b044c1,apigee-watcher-myhybridorg-5b044c1,apigee
-udca-myhybridorg-5b044c1,apigee-metrics-apigee-telemetry,apigee-op
en-telemetry-collector-apigee-telemetry,apigee-logger-apigee-teleme
try

dev-Umgebung:

apigee-synchronizer-myhybridorg-dev-ee52aca,apigee-runtime-myhybrid
org-dev-ee52aca

prod-Umgebung:

apigee-synchronizer-myhybridorg-prod-2d0221c,apigee-runtime-myhybri
dorg-prod-2d0221c

Erstellen Sie mit der Richtlinie eine Vault-Rolle, die die organisationsspezifischen Apigee-Dienstkonten bindet:

vault write auth/kubernetes/role/apigee-orgsakeys \
  bound_service_account_names=LIST_OF_ORG_SA_NAMES \
  bound_service_account_namespaces=apigee \
  policies=apigee-orgsakeys-auth \
  ttl=1m

Erstellen Sie für jede Umgebung eine Vault-Rolle für die Dienstkontoschlüssel:

vault write auth/kubernetes/role/apigee-envsakeys-ENV_NAME \
  bound_service_account_names=LIST_OF_ENV_NAME_SA_NAMES \
  bound_service_account_namespaces=apigee \
  policies=apigee-envsakeys-ENV_NAME-auth \ 
  ttl=1m

Wiederholen Sie diesen Schritt für jede Umgebung.

`SecretProviderClass`-Objekte erstellen

Dienstkonto	Erwartete Namen der Secret-Dateien
Cassandra-Sicherung	`cassandraBackup`
Cassandra-Wiederherstellung	`cassandraRestore`
Connect-Agent	`connectAgent`
MART	`mart`
Messwerte	`metrics`
Monetarisierung (bei Verwendung der Monetarisierung für Apigee Hybrid)	`mint`
Laufzeit	`runtime`
Synchronizer	`synchronizer`
UDCA	`udca`
Watcher	`watcher`

Verwenden Sie die folgende SecretProviderClass-Vorlage, um diese Ressource für die organisationsspezifischen Secrets zu konfigurieren:

apiVersion: secrets-store.csi.x-k8s.io/v1
kind: SecretProviderClass
metadata:
  name: apigee-orgsakeys-spc
spec:
  provider: vault
  parameters:
    roleName: apigee-orgsakeys
    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: "cassandraBackup"
        secretPath: ""
        secretKey: ""
      - objectName: "cassandraRestore"
        secretPath: ""
        secretKey: ""
      - objectName: "connectAgent"
        secretPath: ""
        secretKey: ""
      - objectName: "logger"
        secretPath: ""
        secretKey: ""
      - objectName: "mart"
        secretPath: ""
        secretKey: ""
      - objectName: "metrics"
        secretPath: ""
        secretKey: ""
      - objectName: "mint"
        secretPath: ""
        secretKey: ""
      - objectName: "udca"
        secretPath: ""
        secretKey: ""
      - objectName: "watcher"
        secretPath: ""
        secretKey: ""

Hinweis: Entfernen Sie die objectName: "mint"-Zeilen, wenn Sie die Monetarisierung für Apigee Hybrid nicht verwenden.

Speichern Sie die Vorlage in einer Datei mit dem Namen spc-org.yaml.

Wenden Sie die organisationsspezifische SecretProviderClass auf Ihren Apigee-Namespace an:
```
kubectl -n $APIGEE_NAMESPACE apply -f spc-org.yaml
```

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

Speichern Sie die Vorlage in einer Datei mit dem Namen spc-env-ENV_NAME.yaml.

Wenden Sie für jede Umgebung die umgebungsspezifische SecretProviderClass auf Ihren Apigee-Namespace an:
```
kubectl -n $APIGEE_NAMESPACE apply -f spc-env-ENV_NAME.yaml
```
Wiederholen Sie diesen Schritt für jede Umgebung.

Nächster Schritt

1 2 3 4 5 (WEITER) Schritt 6: TLS-Zertifikate erstellen 7 8 9 10 11

Schritt 5: Dienstkonto-Authentifizierung einrichten Mit Sammlungen den Überblick behalten Sie können Inhalte basierend auf Ihren Einstellungen speichern und kategorisieren.

Übersicht

Kubernetes-Secrets

Dienstkonten

Produktion

Non-prod

Kubernetes-Secrets erstellen

Produktion

Non-prod

JSON-Dateien

Vault

Zum Speichern von Dienstkonto-Secrets in Vault einrichten

CSI-Treiber und Vault-Anbieter installieren

Vault-Secrets, -Richtlinien und -Rollen erstellen

SecretProviderClass-Objekte erstellen

WIF für GKE

Konfiguration von Workload Identity Federation for GKE vorbereiten

Regionale Cluster

Zonale Cluster

Regionale Cluster

Zonale Cluster

Regionale Cluster

Zonale Cluster

Regionale Cluster

Zonale Cluster

WIF auf anderen Plattformen

Cluster für die Verwendung der Identitätsföderation von Arbeitslasten konfigurieren

Console

Befehlszeile

Erforderliche Rollen

AKS

EKS

Andere Kubernetes-Produkte

Öffentlich zugänglich

Nicht öffentlich zugänglich

Konfigurationsdateien mit Anmeldedaten erstellen

Produktion

Non-prod

WIF: Secrets

Konfigurationsdateien mit Anmeldedaten erstellen

Produktion

Non-prod

Kubernetes-Secrets erstellen

Produktion

Non-prod

WIF: Dateien

Produktion

Non-prod

WIF: Vault

Konfigurationsdateien mit Anmeldedaten erstellen

Produktion

Non-prod

CSI-Treiber und Vault-Anbieter installieren

Vault-Secrets, -Richtlinien und -Rollen erstellen

Produktion

Non-prod

SecretProviderClass-Objekte erstellen

Nächster Schritt

Schritt 5: Dienstkonto-Authentifizierung einrichten

`SecretProviderClass`-Objekte erstellen

`SecretProviderClass`-Objekte erstellen