Diese Seite wurde von der Cloud Translation API übersetzt.

Apigee Operator für Kubernetes für Apigee Hybrid installieren

Diese Seite gilt für Apigee und Apigee Hybrid.

Apigee Edge-Dokumentation aufrufen

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

Wenn Sie Apigee Hybrid nicht verwenden, finden Sie unter Apigee Operator für Kubernetes installieren Informationen zum Installieren des Apigee Operators für Kubernetes für Apigee.

Hinweise

Voraussetzungen:

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-Operators für Kubernetes erforderlich sind:

Dienstkonten erstellen und verwalten: Dienstkontoadministrator (roles/iam.serviceAccountAdmin)
Apigee-Ressourcen erstellen und verwalten: Apigee-Administrator (roles/apigee.admin)

Weitere Informationen zum Zuweisen von Rollen finden Sie unter Zugriff auf Projekte, Ordner und Organisationen verwalten.

Möglicherweise können Sie die erforderlichen Berechtigungen auch über benutzerdefinierte Rollen oder andere vordefinierte Rollen erhalten.

Erforderliche Einrichtungsaufgaben

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

Installieren Sie Apigee Hybrid mit Version 1.15.0 oder höher. Eine Anleitung zur Installation von Apigee Hybrid finden Sie unter Allgemeiner Überblick.
Erstellen Sie einen Kubernetes-Cluster bei einem Cloud-Anbieter, der Istio Gateway unterstützt, z. B. Google Cloud, Azure oder Amazon.
Hinweis:Die Anleitungen in diesen Verfahren sind für Installationen bei jedem Anbieter vorgesehen, der Istio Gateway unterstützt. Die Schritte mit gcloud beziehen sich auf die Kommunikation mit dem Google Cloud -Projekt, das Ihre Apigee Hybrid-Instanz enthält.

Installieren Sie das Istio-Gateway in Ihrem K8s-Cluster:

Für Cluster in GKE:

kubectl apply -f https://github.com/kubernetes-sigs/gateway-api/releases/download/v1.1.0/standard-install.yaml
curl -L https://istio.io/downloadIstio | sh -
cd 1.6.11-asm.1
export PATH=$PWD/bin:$PATH
istioctl install --set profile=minimal --set values.global.platform=gke -y

Für Cluster bei anderen Anbietern:

kubectl apply -f https://github.com/kubernetes-sigs/gateway-api/releases/download/v1.1.0/standard-install.yaml
curl -L https://istio.io/downloadIstio | sh -
cd 1.6.11-asm.1
export PATH=$PWD/bin:$PATH
istioctl install --set profile=minimal -y

Stellen Sie das Istio-Gateway in Ihrem Kubernetes-Cluster bereit.
1. Erstellen Sie eine Datei mit dem Namen „gateway.yaml“ und folgendem Inhalt, um das Istio-Gateway bereitzustellen:
```
#gateway.yaml
apiVersion: gateway.networking.k8s.io/v1
kind: Gateway
metadata:
  name: istio-gateway
  namespace: default
  annotations:
    service.beta.kubernetes.io/port_80_health-probe_protocol: tcp
spec:
  gatewayClassName: istio
  listeners:
  - name: default
    hostname: "*.httpbin.com"
    port: 80
    protocol: HTTP
    allowedRoutes:
      namespaces:
        from: All
```
  Hinweis:Die Annotation in den Metadaten ist aufgrund des offenen Istio-Problems 46769 nur für Cluster in AKS erforderlich. Sie können die Metadaten für andere Kubernetes-Cluster weglassen.
2. Wenden Sie die Datei mit dem folgenden Befehl auf Ihren Cluster an:
```
kubectl apply -f gateway.yaml
```

Istio-Gateway-Einrichtung prüfen (optional)

Für diese Anleitung empfehlen wir, eine Beispielanwendung für httpbin im Standardnamespace bereitzustellen, um das bereitgestellte Gateway zu testen.

Stellen Sie eine Backend-Anwendung in Ihrem Kubernetes-Cluster bereit, um das Gateway zu testen.
1. Erstellen Sie eine neue Datei mit dem Namen target.yaml und fügen Sie den folgenden Inhalt in die neue Datei ein.
```
kubectl apply -f - <<EOF
apiVersion: v1
kind: ServiceAccount
metadata:
  name: httpbin
---
apiVersion: v1
kind: Service
metadata:
  name: httpbin
  labels:
    app: httpbin
    service: httpbin
spec:
  ports:
  - name: http
    port: 8000
    targetPort: 8080
  selector:
    app: httpbin
---
apiVersion: apps/v1
kind: Deployment
metadata:
  name: httpbin
spec:
  replicas: 1
  selector:
    matchLabels:
      app: httpbin
      version: v1
  template:
    metadata:
      labels:
        app: httpbin
        version: v1
    spec:
      serviceAccountName: httpbin
      containers:
      - image: docker.io/mccutchen/go-httpbin:v2.15.0
        imagePullPolicy: IfNotPresent
        name: httpbin
        ports:
        - containerPort: 8080
EOF
```
  Tipp:Sie können die Zeilen zwischen den Tags <<EOF und EOF auch als Datei mit dem Namen target.yaml speichern. Wenden Sie die Konfiguration dann mit dem folgenden Befehl auf Ihren Cluster an:
```
kubectl apply -f target.yaml
```
2. Stellen Sie die HTTPRoute-Ressource in Ihrem Cluster bereit, um Traffic vom Gateway Ihrem Backend-Dienst zuzuordnen.
  Für diese Anleitung empfehlen wir, ein externes Gateway und eine HTTPRoute bereitzustellen. Folgen Sie dazu der Anleitung unter HTTPRoute erstellen.
  
  Weitere Informationen zur HTTPRoute-Ressource finden Sie unter HTTPRoute bereitstellen (für interne Gateways) oder HTTPRoute erstellen (für externe Gateways).
  1. Erstellen Sie eine HTTPRoute gemäß der Anleitung unter HTTPRoute erstellen mit der folgenden YAML-Konfiguration:
```
apiVersion: gateway.networking.k8s.io/v1
kind: HTTPRoute
metadata:
  name: http-bin-route
  namespace: default
spec:
  parentRefs:
  - name: istio-gateway
    namespace: default
  hostnames: ["example.httpbin.com"]
  rules:
  - matches:
    - path:
        type: PathPrefix
        value: /get
    backendRefs:
    - name: httpbin
      port: 8000
```
  2. Wenden Sie die Datei auf Ihren Cluster an:
```
kubectl apply -f httproute.yaml
```
3. Prüfen Sie die GKE Gateway-Einrichtung, um zu bestätigen, dass sie wie erwartet funktioniert.
  Hinweis:Es kann bis zu fünf Minuten dauern, bis die vorgenommenen Ä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
istio-gateway   istio   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 istio-gateway
```
    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“ (Angehängte Routen) 1 ist. Das bedeutet, dass die Route angehängt ist.
  3. Anfrage an das Gateway senden
```
curl http://GATEWAY_IP_ADDRESS/get \
  -H "Host: example.httpbin.com"
```
    Dabei gilt: 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.value}"
```
    Beispiel:
```
curl http://34.54.193.72/get -H "Host: example.httpbin.com"
```
    Die Antwort sollte in etwa so aussehen:
```
{
    "args": {},
    "headers": {
      "Accept": "*/*",
      "Host": "http://example.httpbin.com",
      "User-Agent": "curl/8.7.1",
      "X-Cloud-Trace-Context": "2bb8a80e29e80662ff9cb89971c447d9/13083106619927322701"
    },
    "origin": "67.164.1.10,34.54.193.72",
    "url": "http://example.httpbin.com/get"
}
```
Apigee-Operator für Kubernetes installieren

In dieser Anleitung werden die Schritte beschrieben, die zum Installieren und Konfigurieren des Apigee-Operators für Kubernetes erforderlich sind.
Apigee-Operator für Kubernetes installieren und konfigurieren

In den folgenden Abschnitten werden die Schritte beschrieben, die zum Installieren und Konfigurieren des Apigee-Operators für Kubernetes erforderlich sind:
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 APIGEE_ORG=APIGEE_ORG
```
Wobei:
- PROJECT_ID ist die ID des Projekts mit Ihrer Apigee Hybrid-Instanz.
- APIGEE_ORG ist der Organisationsname Ihrer Apigee Hybrid-Instanz.
Prüfen Sie mit dem folgenden Befehl, ob die Umgebungsvariablen richtig festgelegt sind:
```
echo $PROJECT_ID $APIGEE_ORG
```
APIM-Dienstkonto erstellen und konfigurieren

Erstellen Sie ein Dienstkonto, um eine Verbindung zur Apigee Hybrid-Konfigurationsebene herzustellen.
1. Dienstkonto apigee-apim-gsa erstellen, um eine Verbindung zu Google Cloud -Diensten herzustellen
2. Weisen Sie dem Dienstkonto, das Sie erstellt haben, mit dem folgenden Befehl die Apigee-Administratorrolle zu. Diese Rolle ist zum Erstellen und Verwalten von Apigee-Ressourcen erforderlich.
```
gcloud projects add-iam-policy-binding $PROJECT_ID \
  --member "serviceAccount:apigee-apim-gsa@$PROJECT_ID.iam.gserviceaccount.com" \
  --role "roles/apigee.admin"
```
3. Laden Sie die entsprechende JSON-Schlüsseldatei für das Dienstkonto herunter.
  1. Erstellen und laden Sie die $PROJECT_ID-apigee-apim-gsa.json-Schlüsseldatei mit dem folgenden Befehl herunter:
```
gcloud iam service-accounts keys create $PROJECT_ID-apigee-apim-gsa.json \
  --iam-account=apigee-apim-gsa@$PROJECT_ID.iam.gserviceaccount.com
  --project=$PROJECT_ID
        
```
  2. Prüfen Sie, ob die Datei korrekt heruntergeladen wurde:
```
ls $PROJECT_ID-apigee-apim-gsa.json
        
```
Apigee-Operator für Kubernetes installieren

Installieren Sie die benutzerdefinierten Ressourcendefinitionen (CRDs) von Kubernetes und den Apigee Operator für Kubernetes:
1. Namespace für den Apigee Operator für Kubernetes erstellen
```
kubectl create namespace apim
```
2. Installieren Sie die benutzerdefinierten Ressourcendefinitionen (CRDs) des Apigee Operators 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.0 \
  --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.0 \
  --set serviceAccount=apigee-apim-gsa@$PROJECT_ID.iam.gserviceaccount.com \
  --set apigeeOrg=$APIGEE_ORG \
  --set apigeeEnv=ENV_NAME \
  --set-file serviceAccountKeyFileContent=$PROJECT_ID-apigee-apim-gsa-key.json \
  --atomic
```
  Dabei ist ENV_NAME der Name der Apigee Hybrid-Umgebung, in der Sie den Apigee Operator für Kubernetes installieren möchten.
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-09-01 00:17:03.399810627 +0000 UTC  deployed  apigee-apim-operator-crds-1.1.0  1.1.0
apigee-apim-operator  apim  1  2025-09-01 00:15:00.362829981 +0000 UTC  deployed  apigee-apim-operator-helm-1.1.0  1.1.0
```
5. Prüfen Sie, ob das Kubernetes-Dienstkonto (Kubernetes service account, 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: apigee-apim-gsa@my-project-id.iam.gserviceaccount.com
```
6. Prüfen Sie, ob der Apigee-Operator für Kubernetes 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 der STATUS nicht „Running“ ist oder READY nicht „1/1“ anzeigt, finden Sie unter „Fehlerbehebung beim Apigee Operator für Kubernetes“ Informationen zur Fehlerbehebung bei der Installation.
Apigee Hybrid-Umgebung erstellen

Wenn Sie den Apigee Operator für Kubernetes in Apigee Hybrid verwenden möchten, müssen Sie eine Umgebung mit einem speziellen Flag für die Dienst-Erweiterung erstellen.
1. Rufen Sie ein Token ab, um sich bei der Apigee API zu authentifizieren.
  Rufen Sie in der Befehlszeile Ihre gcloud-Authentifizierungsdaten ab, wie im folgenden Beispiel gezeigt:
```
TOKEN=$(gcloud auth print-access-token)
```
  Um zu prüfen, ob Ihr Token ausgefüllt wurde, verwenden Sie echo wie im folgenden Beispiel:
```
echo $TOKEN
```
  Das Token sollte als codierter String angezeigt werden.
  
  Weitere Informationen finden sich in der Übersicht über das gcloud-Befehlszeilentool.
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_DISPLAY_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" : "ENV_TYPE",
  "properties": {
    "property": [
      {
        "name": "apigee-service-extension-enabled",
        "value": "true"
      }
    ]
  }
}'
```
    Wobei:
    - ENV_NAME ist der Name der Umgebung, die Sie erstellen möchten.
    - ENV_TYPE ist der Typ der Umgebung, die Sie erstellen möchten. Beispiel: INTERMEDIATEoder COMPREHENSIVE
  Prüfen Sie, ob die Umgebung erfolgreich erstellt wurde:
```
curl -i -H "Authorization: Bearer $TOKEN" \
  "https://apigee.googleapis.com/v1/organizations/$APIGEE_ORG/environments"
```
  Weitere Informationen finden Sie in der Installationsanleitung für Apigee Hybrid unter Umgebung erstellen.
3. Erstellen Sie mit dem folgenden Befehl eine Umgebungsgruppe:
```
curl -i -X POST -H "Authorization: Bearer $TOKEN"  "https://apigee.googleapis.com/v1/organizations/$APIGEE_ORG/envgroups" -H "Content-Type:application/json" -d '{
     "name": "'"$ENV_GROUP"'",
     "hostnames":["'"$DOMAIN"'"]
   }'
```
  Wobei:
  - ENV_GROUP (erforderlich) Der Umgebungsname kann Kleinbuchstaben, Bindestriche und Ziffern enthalten und muss mit einem Kleinbuchstaben beginnen. Dieser Name wird als Kennung verwendet und kann nach dem Erstellen nicht mehr geändert werden.
  - DOMAIN (erforderlich) Dies ist der Hostname, den alle in Umgebungen innerhalb dieser Gruppe bereitgestellten Proxys verwenden. Dies sollte eine von Ihnen verwaltete Domain sein. Die Adresse kann die Domain selbst sein, z. B. beispiel.de, oder eine Subdomain wie meine-proxys.beispiel.de enthalten. Wenn Sie keine verwaltete Domain haben, können Sie vorerst einen Platzhalter eingeben. Sie können die Domainadresse später ändern.
  Weitere Informationen finden Sie in der Installationsanleitung für Apigee Hybrid unter Umgebungsgruppe erstellen.
4. Hängen Sie die Umgebung mit dem folgenden Befehl an die soeben erstellte Umgebungsgruppe an:
```
curl -i -X POST -H "Authorization: Bearer $TOKEN"  "https://apigee.googleapis.com/v1/organizations/$APIGEE_ORG/envgroups/$ENV_GROUP/attachments" -H "Content-Type:application/json" -d '{
     "environment": "'"$ENV_NAME"'",
   }'
```
Apigee Hybrid-Umgebung mit Helm installieren

Die Vorgehensweise zum Installieren der neuen Umgebung im Apigee Hybrid-Cluster ähnelt der Installation anderer Umgebungen in Ihrem Cluster. Dies ist erforderlich, um unserem Kubernetes-Cluster, in dem Apigee Hybrid installiert wurde, neue Details zu Umgebung und Umgebungsgruppe hinzuzufügen.
1. Generieren Sie das TLS-Zertifikat für die Domain der Umgebungsgruppe mit dem folgenden Befehl:
```
openssl req -nodes -new -x509 -keyout $APIGEE_HELM_CHARTS_HOME/apigee-virtualhost/certs/keystore_$ENV_GROUP.key -out $APIGEE_HELM_CHARTS_HOME/apigee-virtualhost/certs/keystore_$ENV_GROUP.pem -subj "/CN=$DOMAIN" -addext "subjectAltName = DNS:$DOMAIN" -days 3650
```
  Wobei:
  - APIGEE_HELM_CHARTS_HOME (erforderlich): Das Verzeichnis, in das Sie die Apigee-Helm-Diagramme während der Apigee Hybrid-Installation heruntergeladen haben.
2. Base64-codieren Sie das öffentliche TLS-Zertifikat mit dem folgenden Befehl:
```
cat $APIGEE_HELM_CHARTS_HOME/apigee-virtualhost/certs/keystore_$ENV_GROUP.pem | base64 -w0 > $APIGEE_HELM_CHARTS_HOME/apigee-virtualhost/certs/keystore_$ENV_GROUP.pem.base64
```
3. Aktualisieren Sie die Datei overrides.yaml mit dem folgenden Eintrag unter „envs“:
```
- name: ENV_NAME
  serviceAccountPaths:
    # Provide the path relative to the apigee-env chart directory.
    synchronizer: SYNCHRONIZER_SERVICE_ACCOUNT_FILEPATH
    # For example: "PROJECT_ID-apigee-synchronizer.json"
    runtime: RUNTIME_SERVICE_ACCOUNT_FILEPATH
    # For example: "PROJECT_ID-apigee-runtime.json"
    udca: UDCA_SERVICE_ACCOUNT_FILEPATH
    # For example: "PROJECT_ID-apigee-udca.json"
```
  Dabei ist *_SERVICE_ACCOUNT_FILEPATH (Erforderlich) die JSON-Schlüsseldatei des Dienstkontos, das Sie während der Apigee Hybrid-Installation verwendet haben. Weitere Informationen finden Sie in der Installationsanleitung für Apigee Hybrid unter Überschreibungen erstellen.
4. Fügen Sie der Datei „overrides.yaml“ unter „virtualhosts“ den folgenden Eintrag hinzu:
```
- name: 
  selector:
    app: apigee-ingressgateway
    ingress_name: INGRESS_NAME
  sslCertPath: certs/keystore_$ENV_GROUP.pem
  sslKeyPath: certs/keystore_$ENV_GROUP.key
```
  Dabei ist INGRESS_NAME (erforderlich) der Name des Apigee Ingress-Gateways für Ihre Bereitstellung. Weitere Informationen finden Sie hier.
5. Umgebung und Umgebungsgruppe installieren
  1. Installieren Sie die Umgebung:
    
    Sie dürfen jeweils nur eine Umgebung installieren. Geben Sie die Umgebung mit --set env=ENV_NAME an: Wenn Sie die Umgebungsvariable $ENV_NAME in Ihrer Shell festgelegt haben, können Sie sie in den folgenden Befehlen verwenden:
    
    Probelauf:
```
helm upgrade ENV_RELEASE_NAME apigee-env/ \
  --install \
  --namespace APIGEE_NAMESPACE \
  --atomic \
  --set env=$ENV_NAME \
  -f overrides.yaml \
  --dry-run=server
```
    Installation des Diagramms:
```
helm upgrade ENV_RELEASE_NAME apigee-env/ \
  --install \
  --namespace APIGEE_NAMESPACE \
  --atomic \
  --set env=$ENV_NAME \
  -f overrides.yaml
```
    Prüfen Sie, ob sie aktiv ist, indem Sie den Status der entsprechenden Umgebung prüfen:
```
kubectl -n APIGEE_NAMESPACE get apigeeenv
```
```
NAME                    STATE       AGE   GATEWAYTYPE
apigee-org1-dev-1       running     2d
```
  2. Installieren Sie die Umgebungsgruppen (virtualhosts).
    1. Sie dürfen jeweils nur eine Umgebungsgruppe (virtualhost) installieren. Geben Sie die Umgebungsgruppe mit --set envgroup=ENV_GROUP an: Wenn Sie die Umgebungsvariable $ENV_GROUP in Ihrer Shell festgelegt haben, können Sie sie in den folgenden Befehlen verwenden. Wiederholen Sie folgende Befehle für alle Umgebungsgruppen, die in der Datei overrides.yaml erwähnt werden:
      Probelauf:
      helm upgrade ENV_GROUP_RELEASE_NAME apigee-virtualhost/ \ --install \ --namespace APIGEE_NAMESPACE \ --atomic \ --set envgroup=$ENV_GROUP \ -f overrides.yaml \ --dry-run=server
      Installation des Diagramms:
      helm upgrade $ENV_GROUP_RELEASE_NAME apigee-virtualhost/ \ --install \ --namespace APIGEE_NAMESPACE \ --atomic \ --set envgroup=$ENV_GROUP \ -f overrides.yaml
      Hinweis: ENV_GROUP darf im Namespace apigee nur einmal vorkommen. Wenn Sie beispielsweise eine prod-Umgebung und -Umgebungsgruppe haben, sollten Sie diesen Namen auf prod-envgroup setzen. Der spätere Umgebungsgruppenname sollte weiterhin prod sein.
  Ihre Apigee Hybrid-Organisation ist jetzt mit der neuen Umgebung zum Testen der Dienst-Erweiterung bereit.
  
  Fahren Sie mit der Anleitung unter APIMExtensionPolicy erstellen fort, um eine Erweiterungsrichtlinie zu erstellen.

Apigee Operator für Kubernetes für Apigee Hybrid installieren Mit Sammlungen den Überblick behalten Sie können Inhalte basierend auf Ihren Einstellungen speichern und kategorisieren.

Hinweise

Erforderliche Rollen

Erforderliche Einrichtungsaufgaben

Istio-Gateway-Einrichtung prüfen (optional)

Apigee-Operator für Kubernetes installieren

Apigee-Operator für Kubernetes installieren und konfigurieren

Umgebungsvariablen festlegen

APIM-Dienstkonto erstellen und konfigurieren

Apigee-Operator für Kubernetes installieren

Apigee Hybrid-Umgebung erstellen

Apigee Hybrid-Umgebung mit Helm installieren

Apigee Operator für Kubernetes für Apigee Hybrid installieren