Apigee APIM Operator für Kubernetes installieren

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

Apigee Edge-Dokumentation aufrufen

Auf dieser Seite werden die Schritte beschrieben, die zum Installieren und Konfigurieren des Apigee APIM-Operators für Kubernetes erforderlich sind. Weitere Informationen zu den Vorteilen der Verwendung des APIM-Operators finden Sie unter Apigee APIM Operator for Kubernetes – Übersicht.

Hinweise

Bevor Sie mit der Installation des APIM-Operators beginnen, müssen Sie sicherstellen, dass Sie die erforderlichen Rollen und Berechtigungen haben, um die Schritte auszuführen, und dass Sie die in APIM-Operator: Vorbereitung beschriebenen erforderlichen Aufgaben ausgeführt haben.

Erforderliche Rollen

Bitten Sie Ihren Administrator, Ihnen die folgenden IAM-Rollen für die Organisation zuzuweisen, um die Berechtigungen zu erhalten, die Sie zum Installieren des APIM-Operators 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.

APIM-Operator installieren und konfigurieren

In den folgenden Abschnitten werden die Schritte beschrieben, die zum Installieren und Konfigurieren des APIM-Operators erforderlich sind:

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

Umgebungsvariablen festlegen

Legen Sie im Google Cloud -Projekt, das Ihre Apigee-Instanz enthält, Umgebungsvariablen mit dem folgenden Befehl 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-Clusters.
• 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 APIM-Operator 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	Google 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 mit dem folgenden Befehl Clusteranmeldedaten ab:

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

   Diese Anmeldedaten werden für die Kommunikation mit dem GKE-Cluster verwendet, 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, um Diensterweiterungen zu erstellen und zu verwalten.

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

   • Rolle „Netzwerkadministrator“: 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 APIM-Operators im nächsten Schritt wird ein erforderliches Kubernetes-Dienstkonto (KSA) mit dem Namen apim-ksa im Namespace apim erstellt. Das KSA enthält die Annotation, die erforderlich ist, um es mit einer Workload Identity zu verknüpfen, die vom APIM-Operator 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.

Mit den folgenden Befehlen können Sie bestätigen, dass die Workload Identity erstellt wurde:

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

Benutzerdefinierte Ressourcendefinitionen (CRDs) und APIM-Operator installieren

Installieren Sie die benutzerdefinierten Ressourcendefinitionen (Custom Resource Definitions, CRDs) von Kubernetes und den APIM-Operator:

1. Erstellen Sie einen Namespace für den APIM-Operator:

   kubectl create ns apim

2. Installieren Sie die benutzerdefinierten Ressourcendefinitionen (CRDs) des APIM-Operators:

   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.0.0 \
     --atomic

3. Installieren Sie den APIM-Operator:

   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.0.0 \
     --set projectId=$PROJECT_ID \
     --set serviceAccount=apigee-apim-gsa@$PROJECT_ID.iam.gserviceaccount.com \
     --set apigeeOrg=$PROJECT_ID \
     --set generateEnv=TRUE \
     --atomic

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.0.0	1.0.0
   apigee-apim-operator	apim     	1       	2025-02-01 00:15:00.362829981 +0000 UTC	deployed	apigee-apim-operator-helm-1.0.0	1.0.0   

5. Prüfen Sie, ob der KSA mit der erforderlichen Anmerkung 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, finden Sie unter Fehlerbehebung beim APIM-Operator Informationen zur Fehlerbehebung bei der Installation.

Apigee-Umgebung erstellen

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

Wenn Sie den APIM Operator 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:

     curl -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 „Abo 2024“- und „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.
     • ENV_TYPE ist der Typ der Umgebung, die erstellt werden soll. Beispiel: INTERMEDIATE oder COMPREHENSIVE.
     Hinweis: Die in diesem Schritt oder vom APIM-Operator erstellte Umgebung ist entweder eine Zwischenumgebung oder eine Umfassende Umgebung, um die Verwendung von erweiterbaren Proxys zu unterstützen. Dieses Feature 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 APIM-Operators Probleme auftreten, finden Sie unter Fehlerbehebung beim APIM-Operator Lösungen für häufige Fehler.

Nächste Schritte

• Apigee-Richtlinien mit dem APIM-Operator verwenden
• Apigee-Richtlinien zum GKE Gateway hinzufügen