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 installieren und konfigurieren können. Weitere Informationen zu den Vorteilen der Verwendung des APIM-Operators finden Sie unter Apigee APIM Operator for 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 zum Installieren und Verwenden des APIM-Operators erforderlich sind:

Google Kubernetes Engine-Cluster (GKE) 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.

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:

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

Sie können den APIM-Operator mit einer Abo- oder Pay-as-you-go-Apigee-Organisation verwenden. Weitere Informationen zum Bereitstellen von kostenpflichtigen 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 GKE-Version 1.27 oder höher mit aktivierter Identitätsföderation von Arbeitslasten für GKE und GKE Gateway.

Wenn Sie bereits einen Cluster haben, der diese Anforderungen erfüllt, können Sie diesen Schritt überspringen.

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.

Die erforderlichen Schritte 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 den Standardmodus zum Erstellen und Verwalten Ihrer Cluster verwenden, 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.
GKE Gateway in Ihrem Cluster bereitstellen
Sie können ein internes Gateway oder ein externes Gateway für die Verwendung mit dem APIM-Operator konfigurieren und bereitstellen. Wenn Sie ein internes Gateway bereitstellen möchten, sind ein Nur-Proxy-Subnetz und eine freigegebene VPC erforderlich. Zum Testen der Schritte in diesem Leitfaden empfehlen wir, ein externes Gateway bereitzustellen. Weitere Informationen finden Sie unter Anforderungen an den 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 kein externes Gateway in derselben Region bereitstellen. In den Beispielkonfigurationen in diesem Leitfaden wird ein externes Gateway verwendet.

Folgen Sie der Anleitung unter Externes Gateway bereitstellen, um das GKE-Gateway bereitzustellen. Wenn Sie das Gateway erstellen, verwenden Sie 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
```

Backend-Anwendung in Ihrem Cluster bereitstellen

So stellen Sie die Backend-Anwendung bereit, die vom global-ext-lb1-Gateway verfügbar gemacht wird, das Sie erstellt und bereitgestellt haben:

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 Backend-Anwendungen in GKE-Clustern finden Sie unter Demoanwendungen bereitstellen.

Stellen Sie die HTTPRoute-Ressource in Ihrem Cluster bereit, um Traffic vom Gateway zu Ihrem Backend-Dienst zuzuordnen.
Weitere Informationen zur HTTPRoute-Ressource finden Sie unter HTTPRoute bereitstellen (für interne Gateways) oder HTTPRoute erstellen (für externe Gateways).

Für diese Anleitung empfehlen wir, ein externes Gateway und eine HTTPRoute bereitzustellen. Folgen Sie dazu der Anleitung unter HTTPRoute erstellen. Wenn Sie die HTTPRoute erstellen, verwenden Sie die folgende yaml-Konfiguration und ersetzen Sie HOST_NAME durch den Hostnamen, den Sie verwenden möchten:
```
# 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:
    - HOST_NAME
  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
```
GKE Gateway-Einrichtung prüfen, um zu bestätigen, dass sie wie erwartet funktioniert
Hinweis:Es kann bis zu fünf Minuten dauern, bis die angewendeten Änderungen wirksam werden. Wenn Sie die erwartete Ausgabe für die Schritte in diesem Abschnitt nicht sehen, warten Sie einige Minuten und versuchen Sie es noch einmal.
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 der Wert von PROGRAMMED True ist.
2. Beschreiben Sie das Gateway, um zu bestätigen, dass die Route angehängt 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. Das 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"
  }
```

Nächste Schritte

APIM-Operator installieren