Google verwendet KI-Technologie, um Inhalte in Ihre bevorzugte Sprache zu übersetzen. KI-Übersetzungen können Fehler enthalten.

Apigee-Operator für Kubernetes: Vorbereitung

Diese Seite gilt für Apigee und Apigee Hybrid.

Apigee Edge-Dokumentation aufrufen

Auf dieser Seite werden die Schritte beschrieben, die Sie ausführen müssen, bevor Sie den Apigee Operator für Kubernetes installieren und konfigurieren. Weitere Informationen zu den Vorteilen der Verwendung des Apigee Operator für Kubernetes finden Sie unter Übersicht über den Apigee Operator für Kubernetes.

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 Apigee Operator für Kubernetes 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 Instance Admin (roles/compute.instanceAdmin)
Backend-Dienste erstellen und verwalten: Compute Load Balancer Admin (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 Einrichtungsschritte

Bevor Sie den Apigee Operator für Kubernetes installieren, führen Sie die folgenden Schritte aus, 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 die Instanzversionen in der Instanzdetails Seite der Apigee-UI in Google Cloud Console 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 Apigee Operator für Kubernetes mit einer Apigee-Organisation mit Abo oder Pay-as-you-go verwenden. Weitere Informationen zum Bereitstellen kostenpflichtiger Apigee-Instanzen, finden Sie unter Hinweis.
Installieren Sie die Google Cloud CLI.

Führen Sie nach der Installation der Google Cloud CLI den gcloud components update Befehl 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, wobei Workload Identity Federation for GKE und das GKE-Gateway aktiviert sind.

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

Workload Identity Federation for GKE ist standardmäßig aktiviert, wenn Sie den Autopilot-Modus verwenden, um Ihre Cluster zu erstellen und zu verwalten. Weitere Informationen finden Sie unter Autopilot-Übersicht.

Die Schritte zum Erstellen eines neuen Clusters mit Workload Identity Federation for GKE und aktiviertem GKE-Gateway im Autopilot-Modus finden Sie unter Gateways bereitstellen.

Hinweis: Wenn Sie den Standardmodus verwenden, um Ihre Cluster zu erstellen und zu verwalten, müssen Sie Workload Identity Federation for GKE und das 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 konfigurieren und bereitstellen, das mit dem Apigee Operator für Kubernetes verwendet werden soll. Wenn Sie ein internes Gateway bereitstellen, sind ein Nur-Proxy-Subnetz und eine freigegebene VPC erforderlich. Für das 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 Bereitstellen eines externen Gateways, um das GKE-Gateway bereitzustellen. 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 vom erstellten und bereitgestellten Gateway global-ext-lb1 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 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 die Zwecke dieses Leitfadens empfehlen wir, ein externes Gateway und eine HTTPRoute bereitzustellen. Folgen Sie dazu der Anleitung unter HTTPRoute erstellen. Verwenden Sie beim Erstellen der HTTPRoute 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
```
Prüfen Sie die GKE-Gateway-Einrichtung, um zu bestätigen, dass sie 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 ob 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 die IP-Adresse des Gateways ist. Sie können die IP-Adresse des Gateways 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 der Hostname ist, der in der HTTPRoute des Gateways definiert ist. Sie können 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

Apigee Operator für Kubernetes installieren