Apigee Hybrid mit Helm-Diagrammen installieren und verwalten

Vorschau — Installing Apigee hybrid with Helm charts

Diese Funktion unterliegt den „Nutzungsbedingungen für Pre-GA-Angebote“ im Abschnitt „Allgemeine Nutzungsbedingungen“ der dienstspezifischen Nutzungsbedingungen. Pre-GA-Funktionen sind „wie besehen“ verfügbar und werden möglicherweise nur eingeschränkt unterstützt. Weitere Informationen finden Sie in den Beschreibungen der Startphase.

Hinweis: Dieses Vorschaudokument gilt für Apigee Hybrid v1.10.x.

In diesem Dokument wird beschrieben, wie Sie Apigee Hybrid v1.10 mit Helm-Diagrammen installieren.

Version

Apigee Hybrid-Helm-Diagramme sind für Apigee Hybrid v1.10.x vorgesehen. Eine Liste der Hybrid-Versionen finden Sie unter Apigee Hybrid-Releaseverlauf.

Vorbereitung

• Apigee Hybrid 1.10.4
• Helm v3.10 oder höher
• Zugriff auf das Apigee Hybrid-Helm-Diagramm-Repository unter:
  oci://us-docker.pkg.dev/apigee-release/apigee-hybrid-helm-charts
• gcloud-CLI
• Projekte erstellen und verwalten
• Kubernetes-Cluster für Ihre Apigee Hybrid-Installation. Siehe:
  • Unterstützte Kubernetes-Plattform und -Version
  • Minimale Clusterkonfigurationen

Geltungsbereich

• Dieser Release unterstützt nur die Apigee Hybrid-Version 1.10.4.
• Dieser Release unterstützt:
  • Neue Apigee Hybrid-Installationen.
  • Vorhandene Apigee Hybrid-Installationen wurden auf Version 1.10.4 aktualisiert und mit dem Apigee Hybrid-Helm-Migrationstool auf die Helm-Verwaltung migriert.
• Dieser Release unterstützt:
  • Grundlegende Installation von Apigee Hybrid
  • Cassandra-Back-up und -Wiederherstellung
  • Multiregionale Einrichtung

Hinweis: Zur Verwaltung vorhandener Apigee Hybrid-Cluster, die mit apigeectl eingeführt wurden, siehe Apigee Hybrid-Helm-Migrationstool.

Unterstützte Kubernetes-Plattformen und -Versionen

Plattform	Versionen
GKE	1.24, 1.25, 1.26
AKS	1.24, 1.25, 1.26
EKS	1.24, 1.25, 1.26
OpenShift	4.11, 4.12

Beschränkungen

• Helm-Diagramme unterstützen CRDs nicht vollständig. Daher verwenden wir den Befehl kubectl -k, um sie zu installieren und zu aktualisieren. Wir befolgen Community- und Google-Best-Practices für die Kubernetes-Verwaltung. CRD-Bereitstellungen über Helm haben noch keinen Community-Status erreicht, in dem wir umfassende Unterstützung oder Anfragen für ein solches Modell sehen. Daher sollte die Verwaltung von Apigee-CRDs mit kubectl erfolgen, wie in diesem Dokument erwähnt.
• In apigeectl haben wir Dateien innerhalb von overrides.yaml für Dienstkonten und Zertifikate verwendet. Helm unterstützt jedoch keine Referenzen auf Dateien außerhalb des Diagrammverzeichnisses. Wählen Sie eine der folgenden Optionen für Dienstkonto- und Zertifikatsdateien aus:
  • Platzieren Sie Kopien relevanter Dateien in jedem Diagrammverzeichnis.
  • Sie können in jedem Diagrammverzeichnis für jede Datei oder einen Ordner symbolische Links erstellen. Helm folgt symbolischen Links aus dem Diagrammverzeichnis, gibt aber eine Warnung wie die folgende aus:
    apigee-operator/gsa -> ../gsa
  • Verwenden Sie Kubernetes-Secrets. Zum Beispiel für Dienstkonten:

    kubectl create secret generic SECRET_NAME \
      --from-file="client_secret.json=CLOUD_IAM_FILE_NAME.json" \
      -n apigee
    

    Ersetzen Sie Folgendes:
    • SECRET_NAME durch den Namen des von Ihnen erstellten Kubernetes-Secrets.
    • CLOUD_IAM_FILE_NAME.json durch den Namen der heruntergeladenen JSON-Datei.

Unterstützte Kubernetes-Plattform und -Versionen

Eine Liste der unterstützten Plattformen finden Sie in der Spalte v1.10 in der Tabelle der von Apigee Hybrid unterstützten Plattformen.

Erforderliche Berechtigungen

In dieser Tabelle sind die Ressourcen und Berechtigungen aufgeführt, die für Kubernetes und Apigee erforderlich sind.

Zum Filtern dieser Tabelle haben Sie folgende Möglichkeiten: Wählen Sie eine Kategorie aus, geben Sie einen Suchbegriff ein oder klicken Sie auf eine Spaltenüberschrift, um zu sortieren.

Kategorie auswählen Datastore Umgebung Ingress-Manager Operator Organisationseinheit Redis Telemetrie Virtueller Host

Kategorie	Ressource	Ressourcentyp	Kubernetes RBAC-Berechtigungen
Datastore	apigeedatastores.apigee.cloud.google.com	Apigee	create delete patch update
Datastore	certificates.cert-manager.io	Kubernetes	create delete patch update
Datastore	cronjobs.batch	Kubernetes	create delete patch update
Datastore	jobs.batch	Kubernetes	create delete patch update
Datastore	secrets	Kubernetes	create delete patch update
Umgebung	apigeeenvironments.apigee.cloud.google.com	Apigee	create delete patch update
Umgebung	secrets	Kubernetes	create delete patch update
Umgebung	serviceaccounts	Kubernetes	create delete patch update
Ingress-Manager	certificates.cert-manager.io	Kubernetes	create delete patch update
Ingress-Manager	configmaps	Kubernetes	create delete patch update
Ingress-Manager	deployments.apps	Kubernetes	create delete patch update
Ingress-Manager	horizontalpodautoscalers.autoscaling	Kubernetes	create delete patch update
Ingress-Manager	issuers.cert-manager.io	Kubernetes	create delete patch update
Ingress-Manager	serviceaccounts	Kubernetes	create delete patch update
Ingress-Manager	services	Kubernetes	create delete patch update
Operator	apigeedatastores.apigee.cloud.google.com	Apigee	create delete get list patch update watch
Operator	apigeedatastores.apigee.cloud.google.com/finalizers	Apigee	get patch update
Operator	apigeedatastores.apigee.cloud.google.com/status	Apigee	get patch update
Operator	apigeedeployments.apigee.cloud.google.com	Apigee	create delete get list patch update watch
Operator	apigeedeployments.apigee.cloud.google.com/finalizers	Apigee	get patch update
Operator	apigeedeployments.apigee.cloud.google.com/status	Apigee	get patch update
Operator	apigeeenvironments.apigee.cloud.google.com	Apigee	create delete get list patch update watch
Operator	apigeeenvironments.apigee.cloud.google.com/finalizers	Apigee	get patch update
Operator	apigeeenvironments.apigee.cloud.google.com/status	Apigee	get patch update
Operator	apigeeissues.apigee.cloud.google.com	Apigee	create delete get list watch
Operator	apigeeorganizations.apigee.cloud.google.com	Apigee	create delete get list patch update watch
Operator	apigeeorganizations.apigee.cloud.google.com/finalizers	Apigee	get patch update
Operator	apigeeorganizations.apigee.cloud.google.com/status	Apigee	get patch update
Operator	apigeeredis.apigee.cloud.google.com	Apigee	create delete get list patch update watch
Operator	apigeeredis.apigee.cloud.google.com/finalizers	Apigee	get patch update
Operator	apigeeredis.apigee.cloud.google.com/status	Apigee	get patch update
Operator	apigeerouteconfigs.apigee.cloud.google.com	Apigee	get list
Operator	apigeeroutes.apigee.cloud.google.com	Apigee	create delete get list patch update watch
Operator	apigeeroutes.apigee.cloud.google.com/finalizers	Apigee	get patch update
Operator	apigeeroutes.apigee.cloud.google.com/status	Apigee	get patch update
Operator	apigeetelemetries.apigee.cloud.google.com	Apigee	create delete get list patch update watch
Operator	apigeetelemetries.apigee.cloud.google.com/finalizers	Apigee	get patch update
Operator	apigeetelemetries.apigee.cloud.google.com/status	Apigee	get list patch update
Operator	cassandradatareplications.apigee.cloud.google.com	Apigee	get list patch update watch
Operator	cassandradatareplications.apigee.cloud.google.com/finalizers	Apigee	get patch update
Operator	cassandradatareplications.apigee.cloud.google.com/status	Apigee	get patch update
Operator	*.networking.x.k8s.io	Kubernetes	get list watch
Operator	apiservices.apiregistration.k8s.io	Kubernetes	create delete get list patch update watch
Operator	certificates.cert-manager.io	Kubernetes	create delete get list patch update watch
Operator	certificates.cert-manager.io/finalizers	Kubernetes	create delete get list patch update watch
Operator	certificatesigningrequests.certificates.k8s.io	Kubernetes	create delete get update watch
Operator	certificatesigningrequests.certificates.k8s.io/approval	Kubernetes	create delete get update watch
Operator	certificatesigningrequests.certificates.k8s.io/status	Kubernetes	create delete get update watch
Operator	clusterissuers.cert-manager.io	Kubernetes	create get watch
Operator	clusterrolebindings.rbac.authorization.k8s.io	Kubernetes	create delete get list patch update watch
Operator	clusterroles.rbac.authorization.k8s.io	Kubernetes	create delete get list patch update watch
Operator	configmaps	Kubernetes	create delete get list patch update watch
Operator	configmaps/status	Kubernetes	get patch update
Operator	cronjobs.batch	Kubernetes	create delete get list patch update watch
Operator	customresourcedefinitions.apiextensions.k8s.io	Kubernetes	get list watch
Operator	daemonsets.apps	Kubernetes	create delete get list patch update watch
Operator	deployments.apps	Kubernetes	get list watch
Operator	deployments.extensions	Kubernetes	get list watch
Operator	destinationrules.networking.istio.io	Kubernetes	create delete get list patch update watch
Operator	endpoints	Kubernetes	get list watch
Operator	endpointslices.discovery.k8s.io	Kubernetes	get list watch
Operator	events	Kubernetes	create delete get list patch update watch
Operator	gateways.networking.istio.io	Kubernetes	create delete get list patch update watch
Operator	horizontalpodautoscalers.autoscaling	Kubernetes	create delete get list patch update watch
Operator	ingressclasses.networking.k8s.io	Kubernetes	get list watch
Operator	ingresses.networking.k8s.io/status	Kubernetes	all verbs
Operator	issuers.cert-manager.io	Kubernetes	create delete get list patch update watch
Operator	jobs.batch	Kubernetes	create delete get list patch update watch
Operator	leases.coordination.k8s.io	Kubernetes	create get list update
Operator	namespaces	Kubernetes	get list watch
Operator	nodes	Kubernetes	get list watch
Operator	peerauthentications.security.istio.io	Kubernetes	create delete get list patch update watch
Operator	persistentvolumeclaims	Kubernetes	create delete get list patch update watch
Operator	persistentvolumes	Kubernetes	get list watch
Operator	poddisruptionbudgets.policy	Kubernetes	create delete get list patch update watch
Operator	pods	Kubernetes	create delete get list patch update watch
Operator	pods/exec	Kubernetes	create
Operator	replicasets.apps	Kubernetes	create delete get list patch update watch
Operator	replicasets.extensions	Kubernetes	get list watch
Operator	resourcequotas	Kubernetes	create delete get list patch update watch
Operator	rolebindings.rbac.authorization.k8s.io	Kubernetes	create delete get list patch update watch
Operator	roles.rbac.authorization.k8s.io	Kubernetes	create delete get list patch update watch
Operator	secrets	Kubernetes	batch create delete get list patch update watch
Operator	securitycontextconstraints.security.openshift.io	Kubernetes	create get list
Operator	serviceaccounts	Kubernetes	create delete get list patch update watch
Operator	services	Kubernetes	batch create delete get list patch update watch
Operator	signers.certificates.k8s.io	Kubernetes	approve
Operator	statefulsets.apps	Kubernetes	create delete get list patch update watch
Operator	subjectaccessreviews.authorization.k8s.io	Kubernetes	create get list
Operator	tokenreviews.authentication.k8s.io	Kubernetes	create
Operator	virtualservices.networking.istio.io	Kubernetes	create delete get list patch update watch
Organisationseinheit	apigeeorganizations.apigee.cloud.google.com	Apigee	create delete patch update
Organisationseinheit	secrets	Kubernetes	create delete patch update
Organisationseinheit	serviceaccounts	Kubernetes	create delete patch update
Redis	apigeeredis.apigee.cloud.google.com	Apigee	create delete patch update
Redis	secrets	Kubernetes	create delete patch update
Telemetrie	apigeetelemetry.apigee.cloud.google.com	Apigee	create delete patch update
Telemetrie	secrets	Kubernetes	create delete patch update
Telemetrie	serviceaccounts	Kubernetes	create delete patch update
Virtueller Host	apigeerouteconfigs.apigee.cloud.google.com	Apigee	create delete patch update
Virtueller Host	secrets	Kubernetes	create delete patch update

Weitere Informationen

• RBAC-Autorisierung verwenden
• Anfrageverb ermitteln

Vorbereitung der Installation

Apigee Hybrid-Diagramme werden in Google Artifact Registry gehostet:

oci://us-docker.pkg.dev/apigee-release/apigee-hybrid-helm-charts

Apigee Helm-Diagramme abrufen

Kopieren Sie mit dem Befehl pull alle Apigee Hybrid-Helm-Diagramme in Ihren lokalen Speicher:

export CHART_REPO=oci://us-docker.pkg.dev/apigee-release/apigee-hybrid-helm-charts
export CHART_VERSION=1.10.4
helm pull $CHART_REPO/apigee-operator --version $CHART_VERSION --untar
helm pull $CHART_REPO/apigee-datastore --version $CHART_VERSION --untar
helm pull $CHART_REPO/apigee-env --version $CHART_VERSION --untar
helm pull $CHART_REPO/apigee-ingress-manager --version $CHART_VERSION --untar
helm pull $CHART_REPO/apigee-org --version $CHART_VERSION --untar
helm pull $CHART_REPO/apigee-redis --version $CHART_VERSION --untar
helm pull $CHART_REPO/apigee-telemetry --version $CHART_VERSION --untar
helm pull $CHART_REPO/apigee-virtualhost --version $CHART_VERSION --untar

Apigee Hybrid installieren

Übersicht über Installationssequenzen

Die Installation der Komponenten erfolgt von links nach rechts, wie in der folgenden Abbildung dargestellt. Komponenten, die in der Abbildung vertikal gestapelt sind, können zusammen und in beliebiger Reihenfolge installiert werden. Nachdem Sie eine Komponente installiert haben, können Sie diese Komponente jederzeit einzeln aktualisieren, zum Beispiel Replikat, Arbeitsspeicher, CPU usw.

Installation von Apigee Hybrid mit Helm-Diagrammen vorbereiten

1. Erstellen Sie den Namespace, der für apigee-Ressourcen verwendet wird. Dieser sollte mit dem Namespace-Feld in der Datei overrides.yaml übereinstimmen. Wenn dieses in overrides.yaml nicht vorhanden ist, ist die Standardeinstellung apigee.

   1. Prüfen Sie, ob der Namespace bereits vorhanden ist:

      kubectl get namespace apigee

      Wenn der Namespace vorhanden ist, enthält Ihre Ausgabe Folgendes:

        NAME     STATUS   AGE
        apigee   Active   1d

   2. Wenn der Namespace noch nicht vorhanden ist, erstellen Sie ihn:

      kubectl create namespace apigee

2. Erstellen Sie die Dienstkonten und weisen Sie ihnen die entsprechenden IAM-Rollen zu. Apigee Hybrid verwendet die folgenden Dienstkonten:

   Dienstkonto	IAM-Rollen
   apigee-cassandra	Storage-Objekt-Administrator
   apigee-logger	Log-Autor
   apigee-mart	Apigee Connect Agent
   apigee-metrics	Monitoring-Messwert-Autor
   apigee-runtime	Keine Rolle erforderlich
   apigee-synchronizer	Apigee Synchronizer Manager
   apigee-udca	Apigee Analytics-Agent
   apigee-watcher	Apigee-Laufzeit-Agent

   Apigee stellt das Tool create-service-account im Verzeichnis apigee-operator/etc/tools bereit:

   APIGEE_HELM_CHARTS_HOME/
   └── apigee-operator/
       └── etc/
           └── tools/
               └── create-service-account
   

   Dieses Tool erstellt die Dienstkonten, weist jedem Konto die IAM-Rollen zu und lädt die Zertifikatsdateien im JSON-Format für jedes Konto herunter.

   1. Erstellen Sie das Verzeichnis, in das Sie die Zertifikatsdateien des Dienstkontos herunterladen möchten. Dies wird im folgenden Befehl anstelle von SERVICE_ACCOUNTS_PATH angegeben.
   2. Sie können alle Dienstkonten mit einem einzigen Befehl mit den folgenden Optionen erstellen:

      APIGEE_HELM_CHARTS_HOME/apigee-operator/etc/tools/create-service-account --env prod --dir SERVICE_ACCOUNTS_PATH
      

   3. Listen Sie die Namen Ihrer Dienstkonten für die Überschreibungsdatei auf:

      ls service-accounts
      

      my_project-apigee-cassandra.json    my_project-apigee-runtime.json
      my_project-apigee-logger.json       my_project-apigee-synchronizer.json
      my_project-apigee-mart.json         my_project-apigee-udca.json
      my_project-apigee-metrics.json      my_project-apigee-watcher.json

      Weitere Informationen erhalten Sie hier:

      • Schritt 4: Dienstkonten erstellen
      • Informationen zu Dienstkonten
3. Sehen Sie sich vor der Installation die Datei overrides.yaml an, um die Einstellungen zu prüfen:
   Wichtig: Apigee Hybrid v1.10.4 wurde mit einem kritischen Hotfix-Release aktualisiert. Wenn Sie möchten, können Sie die erforderlichen Konfigurationseinstellungen für den Hotfix direkt über die in diesem Schritt beschriebene Datei zur Konfigurationsüberschreibung anwenden. Wenn Sie die Upgradekonfigurationen jetzt hinzufügen, müssen Sie später keine weiteren Hotfix-Upgrades durchführen. Die Konfigurationseinstellungen für den Hotfix (Version 1.10.4-hotfix.1) finden Sie im Upgrade-Leitfaden. Weitere Informationen finden Sie auch im Versionshinweis zum Hotfix-Release:

   • hybrid v1.10.4-hotfix.1

   instanceID: UNIQUE_ID_TO_IDENTIFY_THIS_CLUSTER
   namespace: apigee # required for Helm charts installation
   
   # By default, logger and metrics are enabled and requires below details
   # Google Cloud project and cluster
   gcp:
     projectID: PROJECT_ID
     region: REGION
   
   k8sCluster:
     name: CLUSTER_NAME
     region: REGION
   
   org: ORG_NAME
   
   envs:
   - name: "ENV_NAME"
     serviceAccountPaths:
       runtime: "PATH_TO_RUNTIME_SVC_ACCOUNT"
       synchronizer: "PATH_TO_SYNCHRONIZER_SVC_ACCOUNT"
       udca: "PATH_TO_UDCA_SVC_ACCOUNT"
   
   ingressGateways:
   - name: GATEWAY_NAME # maximum 17 characters, eg: "ingress-1". See Known issue 243167389.
     replicaCountMin: 1
     replicaCountMax: 2
     svcType: LoadBalancer
   
   virtualhosts:
   - name: ENV_GROUP_NAME
     selector:
       app: apigee-ingressgateway
       ingress_name: GATEWAY_NAME
     sslSecret: SECRET_NAME
   
   mart:
     serviceAccountPath: "PATH_TO_MART_SVC_ACCOUNT"
   
   logger:
     enabled: TRUE_FALSE # lowercase without quotes, eg: true
     serviceAccountPath: "PATH_TO_LOGGER_SVC_ACCOUNT"
   
   metrics:
     enabled: TRUE_FALSE # lowercase without quotes, eg: true
     serviceAccountPath: "PATH_TO_METRICS_SVC_ACCOUNT"
   
   udca:
     serviceAccountPath: "PATH_TO_UDCA_SVC_ACCOUNT"
   
   connectAgent:
     serviceAccountPath: "PATH_TO_MART_SVC_ACCOUNT"
   
   watcher:
     serviceAccountPath: "PATH_TO_WATCHER_SVC_ACCOUNT"

   Dies ist dieselbe Überschreibungskonfiguration, die Sie für diese Helm-Installation verwenden werden. Weitere Einstellungen finden Sie in der Referenz zu Konfigurationsattributen.

   Weitere Beispiele für Überschreibungsdateien finden Sie unter Schritt 6: Hybrid-Laufzeit konfigurieren.

4. Aktivieren Sie den Synchronizer-Zugriff. Dies ist eine Voraussetzung für die Installation von Apigee Hybrid.

   1. Prüfen Sie mit den folgenden Befehlen, ob der Synchronizer-Zugriff bereits aktiviert ist:

      export TOKEN=$(gcloud auth print-access-token)
      

      curl -X POST -H "Authorization: Bearer $TOKEN" \
        -H "Content-Type:application/json" \
        "https://apigee.googleapis.com/v1/organizations/ORG_NAME:getSyncAuthorization" \
        -d ''
      

      Ihre Ausgabe sollte in etwa so aussehen:

      {
        "identities":[
           "serviceAccount:SYNCHRONIZER_SERVICE_ACCOUNT_ID"
        ],
        "etag":"BwWJgyS8I4w="
      }

   2. Wenn die Ausgabe nicht die Dienstkonto-ID enthält, aktivieren Sie den Synchronizer-Zugriff. Ihr Konto muss die IAM-Rolle "Apigee Organization Admin" (roles/apigee.admin) haben, um diese Aufgabe ausführen zu können.

      curl -X POST -H "Authorization: Bearer $TOKEN" \
        -H "Content-Type:application/json" \
        "https://apigee.googleapis.com/v1/organizations/ORG_NAME:setSyncAuthorization" \
        -d '{"identities":["'"serviceAccount:SYNCHRONIZER_SERVICE_ACCOUNT_ID"'"]}'
      

      Weitere Informationen finden Sie in Schritt 7: Synchronizer-Zugriff aktivieren in der Apigee Hybrid-Installationsdokumentation.

5. Installieren Sie den Zertifikatmanager mit dem folgenden Befehl:

   kubectl apply -f https://github.com/cert-manager/cert-manager/releases/download/v1.11.1/cert-manager.yaml
   

6. Installieren Sie die Apigee-CRDs:

   Hinweis: Ab diesem Schritt sollten alle Befehle im Stammverzeichnis des Diagramm-Repositorys ausgeführt werden.
   Hinweis: Dies ist die einzige unterstützte Methode zum Installieren von Apigee-CRDs. Verwenden Sie kubectl apply nicht ohne -k und lassen Sie --server-side nicht weg.
   Hinweis: Für diesen Schritt sind erhöhte Clusterberechtigungen erforderlich.

   1. Verwenden Sie das Probelauf-Feature kubectl, indem Sie den folgenden Befehl ausführen:

      kubectl apply -k  apigee-operator/etc/crds/default/ --server-side --force-conflicts --validate=false --dry-run=server
      

   2. Führen Sie nach der Validierung mit dem Probelaufbefehl den folgenden Befehl aus:

      kubectl apply -k  apigee-operator/etc/crds/default/ --server-side --force-conflicts --validate=false
      

   3. Prüfen Sie die Installation mit dem kubectl get crds-Befehl:

      kubectl get crds | grep apigee

      Ihre Ausgabe sollte in etwa so aussehen:

      apigeedatastores.apigee.cloud.google.com                    2023-10-09T14:48:30Z
      apigeedeployments.apigee.cloud.google.com                   2023-10-09T14:48:30Z
      apigeeenvironments.apigee.cloud.google.com                  2023-10-09T14:48:31Z
      apigeeissues.apigee.cloud.google.com                        2023-10-09T14:48:31Z
      apigeeorganizations.apigee.cloud.google.com                 2023-10-09T14:48:32Z
      apigeeredis.apigee.cloud.google.com                         2023-10-09T14:48:33Z
      apigeerouteconfigs.apigee.cloud.google.com                  2023-10-09T14:48:33Z
      apigeeroutes.apigee.cloud.google.com                        2023-10-09T14:48:33Z
      apigeetelemetries.apigee.cloud.google.com                   2023-10-09T14:48:34Z
      cassandradatareplications.apigee.cloud.google.com           2023-10-09T14:48:35Z
      

7. Prüfen Sie die vorhandenen Labels auf den Clusterknoten. Standardmäßig plant Apigee Daten-Pods auf Knoten mit dem Label cloud.google.com/gke-nodepool=apigee-data und Laufzeit-Pods auf Knoten mit dem Label cloud.google.com/gke-nodepool=apigee-runtime. Sie können die Knotenpoollabels in der Datei overrides.yaml anpassen.

   Weitere Informationen finden Sie unter Dedizierte Knotenpools konfigurieren.

Apigee Hybrid-Helm-Diagramme installieren

Hinweis: Verwenden Sie vor dem Ausführen eines der Helm-Upgrade-/-Installationsbefehle das Helm-Probelauf-Feature, indem Sie --dry-run am Ende des Befehl hinzufügen. Mit helm -h können Sie unterstützte Befehle, Optionen und die Nutzung auflisten.

Wichtiges Migrationstool: Wenn Sie Ihren Cluster mit dem Apigee Hybrid-Helm-Migrationstool zur Helm-Verwaltung migriert haben, befinden sich in Ihrem migrierten Cluster bereits Ressourcen. Um zu vermeiden, dass Ressourcen versehentlich gelöscht werden, falls der helm upgrade-Befehl fehlschlägt, vermeiden Sie die Verwendung des ‑‑atomic-Flags.

Im ersten Schritt lautet der Befehl beispielsweise:

helm upgrade operator apigee-operator/ \
  --install \
  --create-namespace \
  --namespace apigee-system \
  -f overrides.yaml

1. Installieren Sie den Apigee-Operator/-Controller:

   Hinweis: Für diesen Schritt sind erhöhte Clusterberechtigungen erforderlich. Führen Sie helm -h oder helm install -h aus, um Details zu erfahren.

   helm upgrade operator apigee-operator/ \
     --install \
     --create-namespace \
     --namespace apigee-system \
     --atomic \
     -f overrides.yaml
   

   Wichtig: Lassen Sie das ‑‑atomic-Flag für migrierte Cluster weg.

   Prüfen Sie die Installation des Apigee-Operators:

   helm ls -n apigee-system
   

   NAME           NAMESPACE       REVISION        UPDATED                                 STATUS          CHART                   APP VERSION
   operator    apigee-system   3               2023-06-26 00:42:44.492009 -0800 PST    deployed        apigee-operator-1.10.4   1.10.4

   Prüfen Sie, ob er aktiv ist, indem Sie die Verfügbarkeit prüfen:

   kubectl -n apigee-system get deploy apigee-controller-manager
   

   NAME                        READY   UP-TO-DATE   AVAILABLE   AGE
   apigee-controller-manager   1/1     1            1           7d20h

2. Installieren Sie den Apigee-Datenspeicher:

   helm upgrade datastore apigee-datastore/ \
     --install \
     --namespace apigee \
     --atomic \
     -f overrides.yaml
   

   Wichtig: Lassen Sie das ‑‑atomic-Flag für migrierte Cluster weg.

   Prüfen Sie dessen Status, um sicherzustellen, dassapigeedatastore aktiv ist.

   kubectl -n apigee get apigeedatastore default
   

   NAME      STATE       AGE
   default   running    2d

3. Installieren Sie die Apigee-Telemetrie:

   helm upgrade telemetry apigee-telemetry/ \
     --install \
     --namespace apigee \
     --atomic \
     -f overrides.yaml
   

   Wichtig: Lassen Sie das ‑‑atomic-Flag für migrierte Cluster weg.

   Prüfen Sie den Status, um sicherzustellen, dass dieses Element aktiv ist:

   kubectl -n apigee get apigeetelemetry apigee-telemetry
   

   NAME               STATE     AGE
   apigee-telemetry   running   2d

4. Installieren Sie Apigee Redis:

   helm upgrade redis apigee-redis/ \
     --install \
     --namespace apigee \
     --atomic \
     -f overrides.yaml
   

   Wichtig: Lassen Sie das ‑‑atomic-Flag für migrierte Cluster weg.

   Prüfen Sie den Status, um sicherzustellen, dass dieses Element aktiv ist:

   kubectl -n apigee get apigeeredis default
   

   NAME      STATE     AGE
   default   running   2d

5. Installieren Sie den Apigee-Ingress-Manager:

   helm upgrade ingress-manager apigee-ingress-manager/ \
     --install \
     --namespace apigee \
     --atomic \
     -f overrides.yaml
   

   Wichtig: Lassen Sie das ‑‑atomic-Flag für migrierte Cluster weg.

   Prüfen Sie, ob er aktiv ist, indem Sie die Verfügbarkeit prüfen:

   kubectl -n apigee get deployment apigee-ingressgateway-manager
   

   NAME                            READY   UP-TO-DATE   AVAILABLE   AGE
   apigee-ingressgateway-manager   2/2     2            2           2d

6. Installieren Sie die Apigee-Organisation:

   helm upgrade ORG_NAME apigee-org/ \
     --install \
     --namespace apigee \
     --atomic \
     -f overrides.yaml
   

   Wichtig: Lassen Sie das ‑‑atomic-Flag für migrierte Cluster weg.

   Prüfen Sie den Status der entsprechenden Organisation, um sicherzustellen, dass sie aktiv ist:

   kubectl -n apigee get apigeeorg
   

   NAME                      STATE     AGE
   apigee-org1-xxxxx          running   2d

7. Installieren Sie die Umgebung:

   Sie dürfen jeweils nur eine Umgebung installieren. Geben Sie die Umgebung mit --set env=ENV_NAME an:

   helm upgrade apigee-env-ENV_NAME apigee-env/ \
     --install \
     --namespace apigee \
     --atomic \
     --set env=ENV_NAME \
     -f overrides.yaml
   

   Wichtig: Lassen Sie das ‑‑atomic-Flag für migrierte Cluster weg.

   Prüfen Sie, ob sie aktiv ist, indem Sie den Status der entsprechenden Umgebung prüfen:

   kubectl -n apigee get apigeeenv
   

   NAME                          STATE       AGE   GATEWAYTYPE
   apigee-org1-dev-xxx            running     2d

8. Erstellen Sie die TLS-Zertifikate. Sie müssen TLS-Zertifikate für das Laufzeit-Ingress-Gateway in Ihrer Apigee Hybrid-Konfiguration bereitstellen.

   1. Erstellen Sie die Zertifikate. In einer Produktionsumgebung müssen Sie signierte Zertifikate verwenden. Sie können entweder ein Zertifikat und ein Schlüsselpaar oder ein Kubernetes-Secret verwenden.

      Zu Demonstrationszwecken und zum Testen der Installation kann das Laufzeit-Gateway selbst signierte Anmeldedaten akzeptieren. Im folgenden Beispiel wird openssl verwendet, um die selbst signierten Anmeldedaten zu generieren:

      openssl req -nodes -new -x509 \
        -keyout PATH_TO_CERTS_DIRECTORY/keystore_ENV_GROUP_NAME.key \
        -out PATH_TO_CERTS_DIRECTORY/keystore_ENV_GROUP_NAME.pem \
        -subj '/CN='YOUR_DOMAIN'' -days 3650
      

      Weitere Informationen finden Sie unter Schritt 5: TLS-Zertifikate erstellen.

   2. Erstellen Sie das Kubernetes-Secret, um auf die Zertifikate zu verweisen:

      kubectl create secret generic NAME \
        --from-file="cert=PATH_TO_CRT_FILE" \
        --from-file="key=PATH_TO_KEY_FILE" \
        -n apigee
      

9. Installieren Sie den virtuellen Host.

   Sie dürfen jeweils nur eine Umgebungsgruppe (virtualhost) installieren. Geben Sie die Umgebungsgruppe mit --set envgroup=ENV_GROUP_NAME an:

   # repeat the following command for each env group mentioned in the overrides.yaml file
   helm upgrade apigee-virtualhost-ENV_GROUP_NAME apigee-virtualhost/ \
     --install \
     --namespace apigee \
     --atomic \
     --set envgroup=ENV_GROUP_NAME \
     -f overrides.yaml
   

   Wichtig: Lassen Sie das ‑‑atomic-Flag für migrierte Cluster weg.
   Hinweis: ENV_GROUP_NAME muss im Namespace apigee eindeutig sein. Wenn Sie beispielsweise die Umgebung und Umgebungsgruppe prod haben, sollten Sie diesen Namen auf prod-envgroup setzen. Der spätere Umgebungsgruppenname sollte weiterhin prod sein.

   Dadurch wird ApigeeRouteConfig (ARC) erstellt, das intern ApigeeRoute (ARC) erstellt, sobald der Apigee-Watcher die Umgebungsgruppendetails aus der Steuerungsebene abruft. Prüfen Sie daher, ob die entsprechende AR ausgeführt wird:

   kubectl -n apigee get arc
   

   NAME                                STATE   AGE
   apigee-org1-dev-egroup                       2d

   kubectl -n apigee get ar
   

   NAME                                        STATE     AGE
   apigee-org1-dev-egroup-xxxxxx                running   2d

Zusätzliche Anwendungsfälle für Helm-Diagramme mit Apigee Hybrid

Cassandra-Back-up und -Wiederherstellung

1. So aktivieren Sie die Sicherung:

   1. Aktualisieren Sie die Cassandra-Sicherungsdetails in der Datei overrides.yaml:

      cassandra:
        backup:
          enabled: true
          serviceAccountPath: PATH_TO_GSA_FILE
          dbStorageBucket: BUCKET_LINK
          schedule: "45 23 * * 6"

      Hinweis: Bei Verwendung eines Cloud Storage-Buckets muss ein Google Cloud-Dienstkonto apigee-cassandra-back erstellt werden und über die entsprechenden Rollen und/oder Berechtigungen verfügen, um in den in dbStorageBucket angegebenen Bucket zu schreiben.

   2. Führen Sie das Helm-Upgrade für das Diagramm apigee-datastore aus:

      helm upgrade datastore apigee-datastore/ \
        --namespace apigee \
        --atomic \
        -f overrides.yaml
      

      Wichtig: Lassen Sie das ‑‑atomic-Flag für migrierte Cluster weg.
2. Aktivieren Sie die Wiederherstellung:

   1. Aktualisieren Sie die Cassandra-Wiederherstellungsdetails in der Datei overrides.yaml:

      cassandra:
        restore:
          enabled: true
          snapshotTimestamp: TIMESTAMP
          serviceAccountPath: PATH_TO_GSA_FILE
          cloudProvider: "CSI"

   2. Führen Sie das Helm-Upgrade für das Diagramm apigee-datastore aus:

      helm upgrade datastore apigee-datastore/ \
        --namespace apigee \
        --atomic \
        -f overrides.yaml
      

      Wichtig: Lassen Sie das ‑‑atomic-Flag für migrierte Cluster weg.

Weitere Informationen zur Cassandra-Sicherung und -Wiederherstellung finden Sie unter Cassandra-Sicherungsübersicht.

Multiregionale Erweiterung

Die multiregionale Einrichtung mit Helm-Diagrammen hat dieselben Voraussetzungen wie die aktuellen apigeectl-Verfahren. Weitere Informationen finden Sie unter Vorbereitung für multiregionale Bereitstellungen.

Das Verfahren zur Konfiguration von Hybrid für mehrere Regionen entspricht dem vorhandenen Verfahren bis zur Konfiguration des Seed-Hosts für mehrere Regionen und Einrichtung des Kubernetes-Clusters und -Kontexts.

Erste Region konfigurieren

Führen Sie die folgenden Schritte aus, um die erste Region zu konfigurieren und die Konfiguration der zweiten Region vorzubereiten:

1. Führen Sie die Schritte unter Apigee Hybrid für mehrere Regionen konfigurieren aus, um den Seed-Host für mehrere Regionen auf Ihrer Plattform zu konfigurieren.

2. Rufen Sie für die erste erstellte Region die Pods im Apigee-Namespace ab:

   kubectl get pods -o wide -n apigee
   

3. Identifizieren Sie die multiregionale Seed-Hostadresse für Cassandra in dieser Region, z. B. 10.0.0.11.

4. Bereiten Sie die Datei overrides.yaml für die zweite Region vor und fügen Sie die IP-Adresse des Seed-Hosts so hinzu:

   cassandra:
     multiRegionSeedHost: "SEED_HOST_IP_ADDRESS"
     datacenter: "DATACENTER_NAME"
     rack: "RACK_NAME"
     clusterName: CLUSTER_NAME
     hostNetwork: false

   Ersetzen Sie Folgendes:

   • SEED_HOST_IP_ADDRESS durch die IP-Adresse des Seed-Hosts, z. B. 10.0.0.11.
   • DATACENTER_NAME durch den Namen des Rechenzentrums, z. B. dc-2.
   • RACK_NAME durch den Rack-Namen, z. B. ra-1.
   • CLUSTER_NAME durch den Namen Ihres Apigee-Clusters. Der Standardwert ist apigeecluster. Wenn Sie einen anderen Clusternamen verwenden, müssen Sie einen Wert für cassandra.clusterName angeben. Dieser Wert muss in allen Regionen gleich sein.

Zweite Region konfigurieren

So richten Sie die neue Region ein:

1. Installieren Sie cert-manager in Region 2:

   kubectl apply -f https://github.com/cert-manager/cert-manager/releases/download/v1.11.1/cert-manager.yaml
   

2. Erstellen Sie ein Kubernetes-Secret für Ihr Dienstkonto.
3. Erstellen Sie ein Kubernetes-Secret für Ihr Ingress-Zertifikat.
4. Kopieren Sie das Zertifikat aus dem vorhandenen in den neuen Cluster. Der neue CA-Stamm wird von Cassandra und anderen Hybrid-Komponenten für mTLS verwendet. Daher ist es wichtig, dass im Cluster konsistente Zertifikate vorhanden sind.

   1. Legen Sie für den Kontext den ursprünglichen Namespace fest:

      kubectl config use-context ORIGINAL_CLUSTER_NAME
      

   2. Exportieren Sie die aktuelle Namespace-Konfiguration in eine Datei:

      kubectl get namespace apigee -o yaml > apigee-namespace.yaml
      

   3. Exportieren Sie das apigee-ca-Secret in eine Datei:

      kubectl -n cert-manager get secret apigee-ca -o yaml > apigee-ca.yaml
      

   4. Legen Sie für den Kontext den Clusternamen der neuen Region fest:

      kubectl config use-context NEW_CLUSTER_NAME
      

   5. Importieren Sie die Namespace-Konfiguration in den neuen Cluster. Achten Sie darauf, den Namespace in der Datei zu aktualisieren, wenn Sie in der neuen Region einen anderen Namespace verwenden:

      kubectl apply -f apigee-namespace.yaml
      

   6. Importieren Sie das Secret in den neuen Cluster:

      kubectl -n cert-manager apply -f apigee-ca.yaml
      

5. Verwenden Sie jetzt Helm-Diagramme, um Apigee Hybrid in der neuen Region mit den folgenden Helm-Diagrammbefehlen zu installieren (wie in Region 1):

   Hinweis: Sie können für die Konsistenz dieselben CRDs verwenden. Verwenden Sie dazu denselben Ordner, in den Sie die Diagramme heruntergeladen haben. Sie können auch die Überschreibungsdatei zwischen Region 1 und 2 individuell halten, indem Sie für die Überschreibungen einen eindeutigen Namen wie overrides2.yaml festlegen.

   helm upgrade operator apigee-operator \
     --install \
     --create-namespace \
     --namespace apigee-system \
     --atomic
     -f overrides-DATACENTER_NAME.yaml
   helm upgrade datastore apigee-datastore \
     --install \
     --namespace apigee \
     --atomic \
     -f overrides-DATACENTER_NAME.yaml
   helm upgrade telemetry apigee-telemetry \
     --install \
     --namespace apigee \
     --atomic \
     -f overrides-DATACENTER_NAME.yaml
   helm upgrade redis apigee-redis \
     --install \
     --namespace apigee \
     --atomic \
     -f overrides-DATACENTER_NAME.yaml
   helm upgrade ingress-manager apigee-ingress-manager \
     --install \
     --namespace apigee \
     --atomic \
     -f overrides-DATACENTER_NAME.yaml
   helm upgrade ORG_NAME apigee-org \
     --install \
     --namespace apigee \
     --atomic \
     -f overrides-DATACENTER_NAME.yaml
   # repeat the below command for each env mentioned on the overrides
   helm upgrade apigee-env-ENV_NAME apigee-env/ \
     --install \
     --namespace apigee \
     --atomic \
     --set env=ENV_NAME \
     -f overrides-DATACENTER_NAME.yaml
   # repeat the below command for each env group mentioned on the overrides
   helm upgrade apigee-virtualhost-ENV_GROUP_NAME apigee-virtualhost/ \
     --install \
     --namespace apigee \
     --atomic \
     --set envgroup=ENV_GROUP_NAME \
     -f overrides-DATACENTER_NAME.yaml
   

   Wichtig: Lassen Sie das ‑‑atomic-Flag für migrierte Cluster weg.
6. Nachdem Sie alle Komponenten installiert haben, richten Sie Cassandra auf allen Pods in den neuen Rechenzentren ein. Eine Anleitung finden Sie unter Apigee Hybrid für mehrere Regionen konfigurieren. Wählen Sie Ihre Plattform aus, scrollen Sie zu Neue Region einrichten und suchen Sie nach Schritt 5.
7. Sobald die Datenreplikation abgeschlossen und überprüft wurde, aktualisieren Sie die Seed-Hosts:
   1. Entfernen Sie multiRegionSeedHost: 10.0.0.11 aus overrides-DATACENTER_NAME.yaml.

   2. Wenden Sie die Änderung noch einmal an, um die Apigee-Datenspeicher-CR zu aktualisieren:

      helm upgrade datastore apigee-datastore/ \
        --install \
        --namespace apigee \
        --atomic \
        -f overrides-DATACENTER_NAME.yaml
      

      Wichtig: Lassen Sie das ‑‑atomic-Flag für migrierte Cluster weg.

Images privat hosten

Anstatt sich auf das öffentliche Google Cloud-Repository zu verlassen, können Sie die Images optional privat hosten. Anstatt jede Komponente zu überschreiben, können Sie Hub-Details für die Überschreibungen hinzufügen:

hub: PRIVATE_REPO

Wenn beispielsweise der folgende Hub bereitgestellt wird, wird der Image-Pfad:

hub: private-docker-host.com

automatisch so aufgelöst:

## an example of internal component vs 3rd party
containers:
- name: apigee-udca
  image: private-docker-host.com/apigee-udca:1.10.4
  imagePullPolicy: IfNotPresent

containers:
- name: apigee-ingressgateway
  image: private-docker-host.com/apigee-asm-ingress:1.17.2-asm.8-distroless
  imagePullPolicy: IfNotPresent

Klicken, um eine Liste der Apigee-Images zu maximieren

apigee:
  gcr.io/apigee-release/hybrid/apigee-mart-server:1.10.3
  gcr.io/apigee-release/hybrid/apigee-synchronizer:1.10.3
  gcr.io/apigee-release/hybrid/apigee-runtime:1.10.3
  gcr.io/apigee-release/hybrid/apigee-hybrid-cassandra-client:1.10.3
  gcr.io/apigee-release/hybrid/apigee-hybrid-cassandra:1.10.3
  gcr.io/apigee-release/hybrid/apigee-cassandra-backup-utility:1.10.3
  gcr.io/apigee-release/hybrid/apigee-udca:1.10.3
  gcr.io/apigee-release/hybrid/apigee-connect-agent:1.10.3
  gcr.io/apigee-release/hybrid/apigee-watcher:1.10.3
  gcr.io/apigee-release/hybrid/apigee-operators:1.10.3
  gcr.io/apigee-release/hybrid/apigee-redis:1.10.3
  gcr.io/apigee-release/hybrid/apigee-mint-task-scheduler:1.10.3

third party:
  gcr.io/apigee-release/hybrid/apigee-stackdriver-logging-agent:1.9.12-2
  gcr.io/apigee-release/hybrid/apigee-prom-prometheus:v2.45.0
  gcr.io/apigee-release/hybrid/apigee-stackdriver-prometheus-sidecar:0.9.0
  gcr.io/apigee-release/hybrid/apigee-kube-rbac-proxy:v0.14.2
  gcr.io/apigee-release/hybrid/apigee-envoy:v1.27.0
  gcr.io/apigee-release/hybrid/apigee-prometheus-adapter:v0.11.0
  gcr.io/apigee-release/hybrid/apigee-asm-ingress:1.17.2-asm.8-distroless
  gcr.io/apigee-release/hybrid/apigee-asm-istiod:1.17.2-asm.8-distroless
  gcr.io/apigee-release/hybrid/apigee-fluent-bit:2.1.8

So zeigen Sie eine Liste der Apigee-Images, die im Google Cloud-Repository gehostet werden, in der Befehlszeile an:

./apigee-operator/etc/tools/apigee-pull-push.sh --list

Toleranzen

Wenn Sie das Markierungs- und Toleranzfeature von Kubernetes verwenden möchten, müssen Sie das Überschreibungsattribut tolerations für jede Apigee Hybrid-Komponente definieren. Die folgenden Komponenten unterstützen die Definition von Toleranzen:

• ao
• apigeeIngressGateway
• cassandra
• cassandraSchemaSetup
• cassandraSchemaValidation
• cassandraUserSetup
• connectAgent
• istiod
• logger
• mart
• metrics
• mintTaskScheduler
• redis
• runtime
• synchronizer
• udca
• Watcher

Weitere Informationen zu diesen Komponenten finden Sie in der Referenz zu Konfigurationsattributen.

So wenden Sie beispielsweise die Toleranzen auf die Apigee-Operator-Bereitstellung an:

ao:
  tolerations:
  - key: "key1"
    operator: "Equal"
    value: "value1"
    effect: "NoExecute"
    tolerationSeconds: 3600

So wenden Sie die Toleranzen auf das Cassandra-StatefulSet an:

cassandra:
  tolerations:
  - key: "key1"
    operator: "Equal"
    value: "value1"
    effect: "NoExecute"
    tolerationSeconds: 3600