Apigee-Operator für Kubernetes installieren

Diese Seite gilt für Apigee, aber nicht für Apigee Hybrid.

Apigee Edge-Dokumentation aufrufen

Auf dieser Seite wird beschrieben, wie Sie den Apigee-Operator für Kubernetes installieren und konfigurieren. Weitere Informationen zu den Vorteilen der Verwendung des Apigee-Operators für Kubernetes finden Sie unter Apigee-Operator für Kubernetes – Übersicht.

Hinweis

Bevor Sie den Apigee-Operator für Kubernetes installieren, müssen Sie dafür sorgen, dass Sie die erforderlichen Rollen und Berechtigungen haben, um die Schritte auszuführen, und dass Sie die in Apigee-Operator für Kubernetes: Vorbereitung beschriebenen erforderlichen Aufgaben ausgeführt haben.

Erforderliche Rollen

Bitten Sie Ihren Administrator, Ihnen die folgenden IAM-Rollen für die Organisation zuzuweisen, damit Sie die Berechtigungen erhalten, die Sie zum Installieren des Apigee-Operators für Kubernetes benötigen:

• GKE-Cluster erstellen und verwalten: Container Admin (roles/container.admin)
• Dienstkonten erstellen und verwalten: Service Account Admin (roles/iam.serviceAccountAdmin)
• Diensterweiterungen erstellen und verwalten: Service Extensions Admin (roles/networkservices.serviceExtensionsAdmin)
• Netzwerk-Endpunktgruppen (NEGs) erstellen und verwalten: Compute-Instanzadministrator (roles/compute.instanceAdmin)
• Backend-Dienste erstellen und verwalten: Administrator für Compute-Load-Balancer (roles/compute.loadBalancerAdmin)
• Apigee-Ressourcen erstellen und verwalten: Apigee Admin (roles/apigee.admin)

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.

Apigee-Operator für Kubernetes installieren und konfigurieren

In den folgenden Abschnitten wird beschrieben, wie Sie den Apigee-Operator für Kubernetes installieren und konfigurieren:

1. Umgebungsvariablen festlegen
2. Aktivieren Sie die erforderlichen APIs.
3. Anmeldedaten abrufen und konfigurieren
4. Workload-Identität erstellen
5. Apigee Operator für Kubernetes installieren
6. Apigee-Umgebung erstellen
7. GKE Gateway-Einrichtung überprüfen

Umgebungsvariablen festlegen

Legen Sie im Google Cloud -Projekt, das Ihre Apigee-Instanz enthält, mit dem folgenden Befehl Umgebungsvariablen fest:

export PROJECT_ID=PROJECT_ID
export CLUSTER_NAME=CLUSTER_NAME
export REGION=REGION
export APIGEE_ORG=APIGEE_ORG

Wobei:

• PROJECT_ID ist die ID des Projekts mit Ihrer Apigee-Instanz.
• CLUSTER_NAME ist der Name Ihres GKE-Cluster.
• REGION ist die Region Ihres GKE-Cluster.
• APIGEE_ORG wird auf denselben Wert wie PROJECT_ID festgelegt.

Führen Sie den folgenden Befehl aus, um zu prüfen, ob die Umgebungsvariablen richtig festgelegt sind:

echo $PROJECT_ID $CLUSTER_NAME $REGION $APIGEE_ORG

Erforderliche APIs aktivieren

Der Apigee-Operator für Kubernetes benötigt Zugriff auf die folgenden APIs:

Name	Titel
apigee.googleapis.com	Apigee API
compute.googleapis.com	Compute Engine API
networkservices.googleapis.com	Network Services API
container.googleapis.com	Kubernetes Engine API

Prüfen Sie mit dem folgenden Befehl, ob die erforderlichen APIs aktiviert sind:

gcloud services list --project=$PROJECT_ID

Wenn die erforderlichen APIs nicht in der Befehlsausgabe aufgeführt sind, aktivieren Sie sie:

gcloud services enable apigee.googleapis.com --project=$PROJECT_ID
gcloud services enable compute.googleapis.com --project=$PROJECT_ID
gcloud services enable networkservices.googleapis.com --project=$PROJECT_ID
gcloud services enable container.googleapis.com --project=$PROJECT_ID

Anmeldedaten abrufen und konfigurieren

Rufen Sie die Anmeldedaten für Ihren Cluster ab und erstellen Sie ein Dienstkonto, um eine Verbindung zu Google Cloud -Diensten herzustellen:

1. Rufen Sie Clusteranmeldedaten mit dem folgenden Befehl ab:

   gcloud container clusters get-credentials $CLUSTER_NAME --location=$REGION --project=$PROJECT_ID

   Mit diesen Anmeldedaten wird mit dem GKE-Cluster kommuniziert, der in den Voraussetzungen erstellt wurde.

2. Richten Sie Dienstkonto-Anmeldedaten ein, um eine Verbindung zu Google Cloud -Diensten herzustellen:

   gcloud iam service-accounts create apigee-apim-gsa

3. Weisen Sie dem Dienstkonto, das Sie erstellt haben, mit den folgenden Befehlen die erforderlichen Rollen und Berechtigungen zu:
   • Apigee-Administratorrolle: Erforderlich zum Erstellen und Verwalten von Apigee-Ressourcen.

     gcloud projects add-iam-policy-binding $PROJECT_ID \
         --member "serviceAccount:apigee-apim-gsa@$PROJECT_ID.iam.gserviceaccount.com" \
         --role "roles/apigee.admin"

   • Administratorrolle für Diensterweiterungen: Erforderlich zum Erstellen und Verwalten von Diensterweiterungen.

     gcloud projects add-iam-policy-binding $PROJECT_ID \
         --member "serviceAccount:apigee-apim-gsa@$PROJECT_ID.iam.gserviceaccount.com" \
         --role "roles/networkservices.serviceExtensionsAdmin"

   • Administratorrolle für das Netzwerk: Erforderlich, um den Zugriff auf Apigee über Dienst-Extensions zu verwalten.

     gcloud projects add-iam-policy-binding $PROJECT_ID \
         --member "serviceAccount:apigee-apim-gsa@$PROJECT_ID.iam.gserviceaccount.com" \
         --role "roles/compute.networkAdmin"

   • Rolle „Load Balancer-Administrator“: Erforderlich, um den Zugriff zwischen Netzwerk-Endpunktgruppen (NEGs) und Backend-Diensten zu verwalten.

     gcloud projects add-iam-policy-binding $PROJECT_ID \
         --member "serviceAccount:apigee-apim-gsa@$PROJECT_ID.iam.gserviceaccount.com" \
         --role "roles/compute.loadBalancerAdmin"

     gcloud projects add-iam-policy-binding $PROJECT_ID \
         --member "serviceAccount:apigee-apim-gsa@$PROJECT_ID.iam.gserviceaccount.com" \
         --role "roles/iam.workloadIdentityUser"

Workload Identity erstellen

Bei der helm Installation des Apigee-Operators für Kubernetes im nächsten Schritt wird ein erforderliches Kubernetes-Dienstkonto (KSA) mit dem Namen apim-ksa im Namespace apim erstellt. Wenn das KSA erstellt wird, enthält es die Annotation, die erforderlich ist, um es mit einer Workload Identity zu verknüpfen, die vom Apigee Operator für Kubernetes verwendet wird, um auf erforderliche Apigee- und Service Networking-Ressourcen zuzugreifen.

Verwenden Sie den folgenden Befehl, um die Workload Identity zu erstellen:

gcloud iam service-accounts add-iam-policy-binding apigee-apim-gsa@$PROJECT_ID.iam.gserviceaccount.com --role roles/iam.workloadIdentityUser --member "serviceAccount:$PROJECT_ID.svc.id.goog[apim/apim-ksa]"

Mit diesem Befehl wird das KSA an das Dienstkonto Google gebunden, das Sie in Anmeldedaten abrufen und konfigurieren erstellt haben, und die Rolle workloadIdentityUser wird zugewiesen.

Es kann einige Minuten, möglicherweise 7 Minuten oder länger, dauern, bis die Änderungen an der Workload Identity im System wirksam werden. Sie bestätigen diese Identität in einem späteren Schritt, nachdem der Operator installiert wurde.

Benutzerdefinierte Ressourcendefinitionen (CRDs) und Apigee Operator für Kubernetes installieren

Installieren Sie die benutzerdefinierten Ressourcendefinitionen (Custom Resource Definitions, CRDs) von Kubernetes und den Apigee Operator für Kubernetes:

1. Erstellen Sie einen Namespace für den Apigee Operator für Kubernetes:

   kubectl create ns apim

2. Installieren Sie die Apigee-Operator-CRDs für Kubernetes:

   helm install apigee-apim-crds -n apim \
     oci://us-docker.pkg.dev/apigee-release/apigee-k8s-tooling-helm-charts/apigee-apim-operator-crds \
     --version 1.1.1 \
     --atomic

3. Installieren Sie den Apigee-Operator für Kubernetes:

   helm install apigee-apim-operator -n apim \
     oci://us-docker.pkg.dev/apigee-release/apigee-k8s-tooling-helm-charts/apigee-apim-operator-helm \
     --version 1.1.1 \
     --set projectId=$PROJECT_ID \
     --set serviceAccount=apigee-apim-gsa@$PROJECT_ID.iam.gserviceaccount.com \
     --set apigeeOrg=$PROJECT_ID \
     --set generateEnv=ENV_GENERATION_MODE \
     --atomic

   Ersetzen Sie ENV_GENERATION_MODE durch TRUE, wenn der Operator beim Installieren des Apigee Operators for Kubernetes eine neue Apigee-Umgebung erstellen soll. Legen Sie ENV_GENERATION_MODE auf FALSE fest, wenn Sie die Umgebung nach der Installation des Operators manuell erstellen möchten. Weitere Informationen finden Sie unter Apigee-Umgebung erstellen.

4. Prüfen Sie, ob die Installation erfolgreich abgeschlossen wurde:

   helm list -n apim

   Die Ausgabe sollte in etwa so aussehen:

   NAME                  NAMESPACE REVISION  UPDATED                                 STATUS    CHART                           APP VERSION
   apigee-apim-crds      apim      1         2025-02-01 00:17:03.399810627 +0000 UTC deployed  apigee-apim-operator-crds-1.1.1 1.1.1
   apigee-apim-operator  apim      1         2025-02-01 00:15:00.362829981 +0000 UTC deployed  apigee-apim-operator-helm-1.1.1 1.1.1   

5. Prüfen Sie, ob das KSA mit der erforderlichen Annotation erstellt wurde:

   kubectl describe serviceaccounts apim-ksa -n apim

   Die Ausgabe sollte in etwa so aussehen:

   Name:                apim-ksa
   Namespace:           apim
   ...
   Annotations:         iam.gke.io/gcp-service-account: [e-mail]

6. Prüfen Sie, ob der APIM-Operator in den Pods des Clusters ausgeführt wird:

   kubectl get pods -n apim

   Die Ausgabe sollte in etwa so aussehen:

   NAME                                    READY   STATUS    RESTARTS     AGE
   apigee-apim-operator-8559d4994b-h55fl   1/1     Running   0            8m34s
   

   Wenn STATUS nicht Running ist oder READY nicht 1/1 anzeigt, lesen Sie den Abschnitt Fehlerbehebung beim Apigee-Operator für Kubernetes, um die Installation zu beheben.

7. Verwenden Sie die folgenden Befehle, um zu prüfen, ob die Workload-Identität richtig konfiguriert ist:

   gcloud config set project $PROJECT_ID

   kubectl run --rm -it --image google/cloud-sdk:slim \
     --namespace apim workload-identity-test \
     --overrides='{ "spec": { "serviceAccountName": "apim-ksa" } }'  \
     -- gcloud auth list

   Die Ausgabe sollte in etwa so aussehen:

   Credentialed Accounts
     ACTIVE  ACCOUNT
     *       GSA@$PROJECT_ID.iam.gserviceaccount.com

Apigee-Umgebung erstellen

Wenn Sie den Apigee Operator für Kubernetes im vorherigen Schritt mit generateEnv=TRUE installiert haben, erstellt der Operator eine neue Apigee-Umgebung, wenn die APIM Extension-Richtlinie erstellt und angewendet wird. Der Name der neuen Umgebung hat das Präfix apim-enabled-dep-env.

Wenn Sie den Apigee Operator für Kubernetes mit generateEnv=FALSE installiert haben, müssen Sie eine neue Apigee-Umgebung erstellen:

1. Legen Sie die für den Befehl curl erforderliche TOKEN fest:

   export TOKEN=$(gcloud auth print-access-token)

2. Erstellen Sie die Umgebung mit einem der folgenden Befehle:
   • Für Organisationen mit einem Abo von 2021 und 2024:

     curl -i -X POST "https://apigee.googleapis.com/v1/organizations/$APIGEE_ORG/environments" -H \
       "Authorization: Bearer $TOKEN" -H "Content-Type:application/json" \
         -d '{
           "name": "ENV_NAME",
           "displayName": "ENV_NAME",
           "state": "ACTIVE",
           "deploymentType": "PROXY",
           "apiProxyType": "PROGRAMMABLE",
           "properties": {
             "property": [
               {
                 "name": "apigee-service-extension-enabled",
                 "value": "true"
               }
             ]
           }
       }'

     Dabei ist ENV_NAME der Name der Umgebung, die Sie erstellen möchten.

   • Für „Pay as you go“-Organisationen:

     curl -i -X POST -H "Authorization: Bearer $TOKEN"  "https://apigee.googleapis.com/v1/organizations/$APIGEE_ORG/environments" -H "Content-Type:application/json" -d '{
       "name": "ENV_NAME",
       "displayName": "ENV_NAME",
       "state": "ACTIVE",
       "deploymentType": "PROXY",
       "apiProxyType": "PROGRAMMABLE",
       "type" : "COMPREHENSIVE",
       "properties": {
         "property": [
           {
             "name": "apigee-service-extension-enabled",
             "value": "true"
           }
         ]
       }
     }'

     Wobei:

     • ENV_NAME ist der Name der zu erstellenden Umgebung.
     Hinweis: Die in diesem Schritt oder vom Apigee Operator für Kubernetes erstellte Umgebung ist entweder eine Intermediate - oder eine Comprehensive-Umgebung, um die Verwendung von erweiterbaren Proxys zu unterstützen. Diese Funktion kann nicht mit Basisumgebungen verwendet werden.

   So prüfen Sie, ob die Umgebung erfolgreich erstellt wurde:

   curl -i -H "Authorization: Bearer $TOKEN" \
     "https://apigee.googleapis.com/v1/organizations/$APIGEE_ORG/environments"

3. Hängen Sie die Umgebung an Ihre Apigee-Instanz an:

   curl -i -X POST -H "Authorization: Bearer $TOKEN" \
     "https://apigee.googleapis.com/v1/organizations/$APIGEE_ORG/instances/INSTANCE_NAME/attachments" \
     -H "Content-Type:application/json" -d '{"environment": "ENV_NAME"}'

   Wobei:

   • INSTANCE_NAME ist der Name Ihrer Apigee-Instanz.
   • ENV_NAME ist der Name der Umgebung, die Sie im vorherigen Schritt erstellt haben.

   So prüfen Sie den Status des Vorgangs zum Anhängen der Umgebung:

   curl -X GET -H "Authorization: Bearer $TOKEN" \
     "https://apigee.googleapis.com/v1/organizations/$APIGEE_ORG/operations/OPERATION_ID"

   Dabei ist OPERATION_ID die ID des Vorgangs zum Anhängen der Umgebung.

Fehlerbehebung

Wenn bei der Installation des Apigee Operator für Kubernetes Probleme auftreten, finden Sie unter Fehlerbehebung beim Apigee Operator für Kubernetes Lösungen für häufige Fehler.

Nächste Schritte

Erstellen Sie eine Traffic-Diensterweiterung mit der APIMExtensionPolicy oder der ApigeeBackendService:

• APIMExtensionPolicy erstellen
• ApigeeBackendService erstellen