Diese Seite wurde von der Cloud Translation API übersetzt.

APIM-Betreiber: Bevor Sie beginnen

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

Apigee Edge-Dokumentation aufrufen

Auf dieser Seite werden die Schritte beschrieben, die Sie ausführen müssen, bevor Sie den Apigee APIM-Operator für Kubernetes (Vorabversion) installieren und konfigurieren können. Weitere Informationen zu den Vorteilen des APIM-Operators finden Sie unter Apigee APIM Operator for Kubernetes overview (Apigee APIM Operator für Kubernetes – Übersicht).

Erforderliche Rollen

Bitten Sie Ihren Administrator, Ihnen die folgenden IAM-Rollen für die Organisation zuzuweisen, um die Berechtigungen zu erhalten, die Sie zum Einrichten der Ressourcen benötigen, die für die Installation und Verwendung des APIM-Betreibers erforderlich sind:

Google Kubernetes Engine (GKE)-Cluster erstellen und verwalten: Container-Administrator (roles/container.admin)
Dienstkonten erstellen und verwalten: Service Account Admin (roles/iam.serviceAccountAdmin)
Diensterweiterungen erstellen und verwalten: Service Extensions Administrator (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.

Erforderliche Einrichtungsaufgaben

Bevor Sie den APIM-Operator installieren, müssen Sie die folgenden Aufgaben ausführen, um die Ressourcen einzurichten, die Sie für die Verwendung der Funktion benötigen:

Bereitstellen Sie eine Apigee-Instanz mit Version 1-14-0-apigee-4 oder höher.
Sie können Instanzversionen auf der Seite Instanzdetails der Apigee-Benutzeroberfläche in der Google Cloud Console aufrufen.Rufen Sie in der Google Cloud Console die Seite Instanzen auf, um eine Instanz auszuwählen und ihre Details aufzurufen:
Zur Seite „VM-Instanzen“

Sie können APIM Operator mit einer Abo- oder Pay-as-you-go-Apigee-Organisation verwenden. Weitere Informationen zur Bereitstellung kostenpflichtiger Apigee-Instanzen finden Sie unter Vorbereitung.
Installieren Sie die Google Cloud CLI.

Führen Sie nach der Installation der Google Cloud CLI den Befehl gcloud components update aus, um die neuesten gcloud-Komponenten abzurufen.
Installieren und konfigurieren Sie das kubectl-Befehlszeilentool.
Installieren Sie Helm (Version 3.14.3 oder höher).
Erstellen Sie einen GKE-Cluster mit aktivierter Identitätsföderation von Arbeitslasten für GKE und dem GKE-Gateway.

Die Workload Identity-Föderation für GKE ist standardmäßig aktiviert, wenn Sie den Autopilot-Modus zum Erstellen und Verwalten Ihrer Cluster verwenden. Weitere Informationen finden Sie unter Autopilot-Übersicht.

Eine Anleitung zum Erstellen eines neuen Clusters mit aktivierter Workload Identity Federation for GKE und GKE-Gateway mit Autopilot finden Sie unter Gateways bereitstellen.

Hinweis:Wenn Sie Ihre Cluster im Standardmodus erstellen und verwalten, müssen Sie die Identitätsföderation von Arbeitslasten für GKE und GKE Gateway manuell aktivieren. Weitere Informationen finden Sie unter Workload Identity und Gateways bereitstellen.
Stellen Sie ein GKE-Gateway in Ihrem Cluster bereit.
Sie können ein internes Gateway oder ein externes Gateway für die Verwendung mit APIM Operator konfigurieren und bereitstellen. Wenn Sie ein internes Gateway bereitstellen, sind ein Nur-Proxy-Subnetz und eine freigegebene VPC erforderlich. Für diesen Leitfaden empfehlen wir die Bereitstellung eines externen Gateways. Weitere Informationen finden Sie unter Anforderungen an GKE-Gateway-Controller.
Hinweis:Wenn Sie mehr als ein GKE-Gateway in derselben Region bereitstellen möchten, müssen beide Gateways vom selben Typ sein (intern oder extern). Sie können kein internes und externes Gateway in derselben Region bereitstellen. In den Beispielkonfigurationen in diesem Leitfaden wird ein externes Gateway verwendet.

Folgen Sie zum Bereitstellen des GKE-Gateways der Anleitung unter Externes Gateway bereitstellen. Verwenden Sie beim Erstellen des Gateways die folgende yaml-Konfiguration:
```
# gateway.yaml
kind: Gateway
apiVersion: gateway.networking.k8s.io/v1beta1
metadata:
  name: global-ext-lb1
  namespace: default
spec:
  gatewayClassName: gke-l7-global-external-managed
  listeners:
    - name: http
      protocol: HTTP
      allowedRoutes:
        kinds:
          - kind: HTTPRoute
        namespaces:
          from: All
      port: 80
```
Wenden Sie die Datei auf Ihren Cluster an:
```
kubectl apply -f gateway.yaml
```

Stellen Sie eine Backend-Anwendung in Ihrem Cluster bereit.

So stellen Sie die Backend-Anwendung bereit, die über das von Ihnen erstellte und bereitgestellte global-ext-lb1-Gateway verfügbar gemacht wird:

Erstellen Sie eine neue Datei mit dem Namen target.yaml.

Kopieren Sie den folgenden Inhalt in die neue Datei:

# target.yaml
apiVersion: v1
kind: Namespace
metadata:
  name: http
---
apiVersion: v1
kind: ServiceAccount
metadata:
  name: httpbin
  namespace: http
---
apiVersion: v1
kind: Service
metadata:
  name: httpbin
  namespace: http
  labels:
    app: httpbin
    service: httpbin
spec:
  type: LoadBalancer
  ports:
    - name: https
      port: 80
      targetPort: 80
  selector:
    app: httpbin
---
apiVersion: apps/v1
kind: Deployment
metadata:
  name: httpbin
  namespace: http
spec:
  replicas: 1
  selector:
    matchLabels:
      app: httpbin
      version: v1
  template:
    metadata:
      labels:
        app: httpbin
        version: v1
    spec:
      serviceAccountName: httpbin
      containers:
        - image: docker.io/kennethreitz/httpbin
          imagePullPolicy: IfNotPresent
          name: httpbin
          ports:
            - containerPort: 80
          resources:
            requests:
              cpu: 1
              memory: 1024Mi
            limits:
              cpu: 1
              memory: 1024Mi

Wenden Sie die Konfiguration auf Ihren Cluster an:
```
kubectl apply -f target.yaml
```

Weitere Informationen zum Bereitstellen von Back-End-Anwendungen in GKE-Clustern finden Sie unter Demoanwendungen bereitstellen.

Bereitstellen Sie die HTTPRoute-Ressource in Ihrem Cluster, um Traffic vom Gateway Ihrem Backenddienst zuzuordnen.

Weitere Informationen zur HTTPRoute-Ressource finden Sie unter HTTPRoute bereitstellen (für interne Gateways) oder HTTPRoute erstellen (für externe Gateways).

Für diesen Leitfaden empfehlen wir, ein externes Gateway und eine externe HTTPRoute bereitzustellen. Folgen Sie dazu der Anleitung unter HTTPRoute erstellen. Verwenden Sie beim Erstellen der HTTPRoute die folgende yaml-Konfiguration:

# httproute.yaml
kind: HTTPRoute
apiVersion: gateway.networking.k8s.io/v1beta1
metadata:
  name: http-bin-route
  namespace: http
spec:
  parentRefs:
    - kind: Gateway
      name: global-ext-lb1
      namespace: default
  hostnames:
    - apigee-apim-operator-test.apigee.net
  rules:
    - matches:
        - path:
            value: /
      backendRefs:
        - name: httpbin
          kind: Service
          port: 80
          namespace: http

Wenden Sie die Datei auf Ihren Cluster an:

kubectl apply -f httproute.yaml

Prüfen Sie die GKE-Gateway-Einrichtung, um sicherzustellen, dass sie wie erwartet funktioniert.
1. Rufen Sie die Gateway-Details mit dem folgenden Befehl ab:
```
kubectl get gateway global-ext-lb1
```
  Die Ausgabe sollte in etwa so aussehen:
```
NAME             CLASS                            ADDRESS        PROGRAMMED   AGE
global-ext-lb1   gke-l7-global-external-managed   34.54.193.72   True         11d
```
  Prüfen Sie, ob dem Gateway eine IP-Adresse zugewiesen ist und ob der Wert von PROGRAMMED True ist.
2. Beschreiben Sie das Gateway, um zu bestätigen, dass die Route verbunden ist:
```
kubectl describe gateway global-ext-lb1
```
  Die Ausgabe sollte in etwa so aussehen:
```
...
  Listeners:
    Attached Routes:  1
    Conditions:
      Last Transition Time:  2024-10-03T03:10:17Z
...
```
  Prüfen Sie, ob der Wert von Attached Routes 1 ist, was bedeutet, dass die Route angehängt ist.
3. Senden Sie eine Anfrage an das Gateway:
```
curl http://GATEWAY_IP_ADDRESS/get \
    -H "Host: HOST_NAME"
```
  Wobei:
  - GATEWAY_IP_ADDRESS ist die IP-Adresse des Gateways. Sie können die Gateway-IP-Adresse mit dem folgenden Befehl abrufen, wobei GATEWAY_NAME der Name des Gateways ist:
```
kubectl get gateways.gateway.networking.k8s.io GATEWAY_NAME -o=jsonpath="{.status.addresses[0].value}"
```
  - HOST_NAME ist der Hostname, der im HTTPRoute des Gateways definiert ist. Sie können die HOST_NAME mit dem folgenden Befehl abrufen:
```
kubectl get HTTPRoute HTTPROUTE_NAME -n NAMESPACE
```
  For example:
```
curl http://34.54.193.72/get \
-H "Host: apigee-apim-operator-test.apigee.net"
```
  Die Antwort sollte in etwa so aussehen:
```
  {
    "args": {},
    "headers": {
      "Accept": "*/*",
      "Host": "apigee-apim-operator-test.apigee.net",
      "User-Agent": "curl/8.7.1",
      "X-Cloud-Trace-Context": "2bb8a80e29e80662ff9cb89971c447d9/13083106619927322701"
    },
    "origin": "67.164.1.10,34.54.193.72",
    "url": "http://apigee-apim-operator-test.apigee.net/get"
  }
```
  Hinweis:Es kann bis zu fünf Minuten dauern, bis die angewendeten Änderungen übernommen werden. Wenn Sie die erwartete Ausgabe nicht sehen, warten Sie einige Minuten und versuchen Sie es noch einmal.

Nächste Schritte

Weitere Informationen zum Installieren des APIM-Operators