Installer et gérer Apigee hybrid avec des charts Helm

Preview — Installing Apigee hybrid with Helm charts

Cette fonctionnalité est soumise aux "Conditions des offres de pré-DG" dans la section "Conditions d'utilisation générales" des Conditions spécifiques au service. Les fonctionnalités pré-DG sont disponibles "en l'état" et peuvent avoir une assistance limitée. Pour en savoir plus, consultez les descriptions des étapes de lancement.

Remarque : Ce document de présentation s'applique à Apigee hybrid v1.10.x.

Ce document vous guide tout au long du processus détaillé d'installation d'Apigee hybrid v1.10 à l'aide de charts Helm.

Version

Les charts Helm Apigee hybrid sont destinés à être utilisés avec Apigee hybrid v1.10.x. Consultez la page Historique des versions Apigee hybrid pour obtenir la liste des versions d'Apigee hybrid.

Prérequis

• Apigee hybrid 1.10.4
• Helm v3.10+
• Accès au dépôt de charts Helm Apigee hybrid sur :
  oci://us-docker.pkg.dev/apigee-release/apigee-hybrid-helm-charts
• gcloud CLI
• Créer et gérer des projets
• Un cluster Kubernetes pour votre installation Apigee hybrid. Voir :
  • Plate-forme Kubernetes et version compatible
  • Configurations de base du cluster

Définition du champ d'application

• Cette version n'est compatible qu'avec Apigee hybrid version 1.10.4.
• Cette version est compatible avec les protocoles suivants :
  • Nouvelles installations Apigee hybrid.
  • Installations Apigee hybrid existantes mises à niveau vers la version 1.10.4 et migrées vers la gestion Helm à l'aide de l'outil de migration Helm Apigee hybrid.
• Cette version est compatible avec les protocoles suivants :
  • Installation de base d'Apigee hybrid
  • Sauvegarde et restauration de bases de données Cassandra
  • Configuration multirégionale

Remarque : Pour la gestion des clusters Apigee hybrid existants qui ont été lancés avec apigeectl, consultez la documentation sur l'outil de migration Helm Apigee hybrid.

Plates-formes et versions Kubernetes compatibles

Plate-forme	Versions
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

Limites

• Les charts Helm ne sont pas entièrement compatibles avec les CRD. Nous allons donc utiliser la commande kubectl -k pour les installer et les mettre à niveau. Notre objectif est de suivre les bonnes pratiques de la communauté et de Google en matière de gestion Kubernetes. Les déploiements CRD via Helm n'ont pas encore atteint un état communautaire, où nous constatons une assistance étendue ou des demandes pour un tel modèle. Par conséquent, la gestion des objets CRD Apigee doit être effectuée à l'aide de kubectl, comme indiqué dans ce document.
• Dans apigeectl, nous avons utilisé des fichiers dans overrides.yaml pour les comptes de service et les certificats. Cependant, Helm ne permet pas de référencer des fichiers en dehors du répertoire de charts. Choisissez l'une des options suivantes pour les fichiers de compte de service et de certificat :
  • Placez des copies des fichiers pertinents dans chaque répertoire de charts.
  • Créez des liens symboliques dans chaque répertoire de charts pour chaque fichier ou un dossier. Helm suit des liens symboliques hors du répertoire de charts, mais génère un avertissement semblable au suivant :
    apigee-operator/gsa -> ../gsa
  • Utilisez les secrets Kubernetes. Par exemple, pour les comptes de service :

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

    Remplacez les éléments suivants :
    • SECRET_NAME par le nom du secret Kubernetes que vous avez créé.
    • CLOUD_IAM_FILE_NAME.json avec le nom du fichier JSON téléchargé.

Plate-forme et versions compatibles de Kubernetes

Pour obtenir la liste des plates-formes compatibles, consultez la colonne v1.10 du tableau des plates-formes compatibles avec Apigee hybrid.

Autorisations requises

Ce tableau répertorie les ressources et les autorisations requises pour Kubernetes et Apigee.

Pour filtrer ce tableau, effectuez une ou plusieurs des opérations suivantes : sélectionnez une catégorie, saisissez un terme de recherche ou cliquez sur un en-tête de colonne pour trier les résultats.

Sélectionner une catégorie Datastore, Env. Gestionnaire d'entrées Opérateur Org. Redis Télémétrie Hôte virtuel

Catégorie	Ressource	Type de ressource	Autorisations Kubernetes RBAC
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
Env.	apigeeenvironments.apigee.cloud.google.com	Apigee	create delete patch update
Env.	secrets	Kubernetes	create delete patch update
Env.	serviceaccounts	Kubernetes	create delete patch update
Gestionnaire d'entrées	certificates.cert-manager.io	Kubernetes	create delete patch update
Gestionnaire d'entrées	configmaps	Kubernetes	create delete patch update
Gestionnaire d'entrées	deployments.apps	Kubernetes	create delete patch update
Gestionnaire d'entrées	horizontalpodautoscalers.autoscaling	Kubernetes	create delete patch update
Gestionnaire d'entrées	issuers.cert-manager.io	Kubernetes	create delete patch update
Gestionnaire d'entrées	serviceaccounts	Kubernetes	create delete patch update
Gestionnaire d'entrées	services	Kubernetes	create delete patch update
Opérateur	apigeedatastores.apigee.cloud.google.com	Apigee	create delete get list patch update watch
Opérateur	apigeedatastores.apigee.cloud.google.com/finalizers	Apigee	get patch update
Opérateur	apigeedatastores.apigee.cloud.google.com/status	Apigee	get patch update
Opérateur	apigeedeployments.apigee.cloud.google.com	Apigee	create delete get list patch update watch
Opérateur	apigeedeployments.apigee.cloud.google.com/finalizers	Apigee	get patch update
Opérateur	apigeedeployments.apigee.cloud.google.com/status	Apigee	get patch update
Opérateur	apigeeenvironments.apigee.cloud.google.com	Apigee	create delete get list patch update watch
Opérateur	apigeeenvironments.apigee.cloud.google.com/finalizers	Apigee	get patch update
Opérateur	apigeeenvironments.apigee.cloud.google.com/status	Apigee	get patch update
Opérateur	apigeeissues.apigee.cloud.google.com	Apigee	create delete get list watch
Opérateur	apigeeorganizations.apigee.cloud.google.com	Apigee	create delete get list patch update watch
Opérateur	apigeeorganizations.apigee.cloud.google.com/finalizers	Apigee	get patch update
Opérateur	apigeeorganizations.apigee.cloud.google.com/status	Apigee	get patch update
Opérateur	apigeeredis.apigee.cloud.google.com	Apigee	create delete get list patch update watch
Opérateur	apigeeredis.apigee.cloud.google.com/finalizers	Apigee	get patch update
Opérateur	apigeeredis.apigee.cloud.google.com/status	Apigee	get patch update
Opérateur	apigeerouteconfigs.apigee.cloud.google.com	Apigee	get list
Opérateur	apigeeroutes.apigee.cloud.google.com	Apigee	create delete get list patch update watch
Opérateur	apigeeroutes.apigee.cloud.google.com/finalizers	Apigee	get patch update
Opérateur	apigeeroutes.apigee.cloud.google.com/status	Apigee	get patch update
Opérateur	apigeetelemetries.apigee.cloud.google.com	Apigee	create delete get list patch update watch
Opérateur	apigeetelemetries.apigee.cloud.google.com/finalizers	Apigee	get patch update
Opérateur	apigeetelemetries.apigee.cloud.google.com/status	Apigee	get list patch update
Opérateur	cassandradatareplications.apigee.cloud.google.com	Apigee	get list patch update watch
Opérateur	cassandradatareplications.apigee.cloud.google.com/finalizers	Apigee	get patch update
Opérateur	cassandradatareplications.apigee.cloud.google.com/status	Apigee	get patch update
Opérateur	*.networking.x.k8s.io	Kubernetes	get list watch
Opérateur	apiservices.apiregistration.k8s.io	Kubernetes	create delete get list patch update watch
Opérateur	certificates.cert-manager.io	Kubernetes	create delete get list patch update watch
Opérateur	certificates.cert-manager.io/finalizers	Kubernetes	create delete get list patch update watch
Opérateur	certificatesigningrequests.certificates.k8s.io	Kubernetes	create delete get update watch
Opérateur	certificatesigningrequests.certificates.k8s.io/approval	Kubernetes	create delete get update watch
Opérateur	certificatesigningrequests.certificates.k8s.io/status	Kubernetes	create delete get update watch
Opérateur	clusterissuers.cert-manager.io	Kubernetes	create get watch
Opérateur	clusterrolebindings.rbac.authorization.k8s.io	Kubernetes	create delete get list patch update watch
Opérateur	clusterroles.rbac.authorization.k8s.io	Kubernetes	create delete get list patch update watch
Opérateur	configmaps	Kubernetes	create delete get list patch update watch
Opérateur	configmaps/status	Kubernetes	get patch update
Opérateur	cronjobs.batch	Kubernetes	create delete get list patch update watch
Opérateur	customresourcedefinitions.apiextensions.k8s.io	Kubernetes	get list watch
Opérateur	daemonsets.apps	Kubernetes	create delete get list patch update watch
Opérateur	deployments.apps	Kubernetes	get list watch
Opérateur	deployments.extensions	Kubernetes	get list watch
Opérateur	destinationrules.networking.istio.io	Kubernetes	create delete get list patch update watch
Opérateur	endpoints	Kubernetes	get list watch
Opérateur	endpointslices.discovery.k8s.io	Kubernetes	get list watch
Opérateur	events	Kubernetes	create delete get list patch update watch
Opérateur	gateways.networking.istio.io	Kubernetes	create delete get list patch update watch
Opérateur	horizontalpodautoscalers.autoscaling	Kubernetes	create delete get list patch update watch
Opérateur	ingressclasses.networking.k8s.io	Kubernetes	get list watch
Opérateur	ingresses.networking.k8s.io/status	Kubernetes	all verbs
Opérateur	issuers.cert-manager.io	Kubernetes	create delete get list patch update watch
Opérateur	jobs.batch	Kubernetes	create delete get list patch update watch
Opérateur	leases.coordination.k8s.io	Kubernetes	create get list update
Opérateur	namespaces	Kubernetes	get list watch
Opérateur	nodes	Kubernetes	get list watch
Opérateur	peerauthentications.security.istio.io	Kubernetes	create delete get list patch update watch
Opérateur	persistentvolumeclaims	Kubernetes	create delete get list patch update watch
Opérateur	persistentvolumes	Kubernetes	get list watch
Opérateur	poddisruptionbudgets.policy	Kubernetes	create delete get list patch update watch
Opérateur	pods	Kubernetes	create delete get list patch update watch
Opérateur	pods/exec	Kubernetes	create
Opérateur	replicasets.apps	Kubernetes	create delete get list patch update watch
Opérateur	replicasets.extensions	Kubernetes	get list watch
Opérateur	resourcequotas	Kubernetes	create delete get list patch update watch
Opérateur	rolebindings.rbac.authorization.k8s.io	Kubernetes	create delete get list patch update watch
Opérateur	roles.rbac.authorization.k8s.io	Kubernetes	create delete get list patch update watch
Opérateur	secrets	Kubernetes	batch create delete get list patch update watch
Opérateur	securitycontextconstraints.security.openshift.io	Kubernetes	create get list
Opérateur	serviceaccounts	Kubernetes	create delete get list patch update watch
Opérateur	services	Kubernetes	batch create delete get list patch update watch
Opérateur	signers.certificates.k8s.io	Kubernetes	approve
Opérateur	statefulsets.apps	Kubernetes	create delete get list patch update watch
Opérateur	subjectaccessreviews.authorization.k8s.io	Kubernetes	create get list
Opérateur	tokenreviews.authentication.k8s.io	Kubernetes	create
Opérateur	virtualservices.networking.istio.io	Kubernetes	create delete get list patch update watch
Org.	apigeeorganizations.apigee.cloud.google.com	Apigee	create delete patch update
Org.	secrets	Kubernetes	create delete patch update
Org.	serviceaccounts	Kubernetes	create delete patch update
Redis	apigeeredis.apigee.cloud.google.com	Apigee	create delete patch update
Redis	secrets	Kubernetes	create delete patch update
Télémétrie	apigeetelemetry.apigee.cloud.google.com	Apigee	create delete patch update
Télémétrie	secrets	Kubernetes	create delete patch update
Télémétrie	serviceaccounts	Kubernetes	create delete patch update
Hôte virtuel	apigeerouteconfigs.apigee.cloud.google.com	Apigee	create delete patch update
Hôte virtuel	secrets	Kubernetes	create delete patch update

Voir également :

• Utiliser l'autorisation RBAC
• Déterminer le verbe de requête

Préparer l'installation

Les charts Apigee hybrid sont hébergés dans Google Artifact Registry :

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

Extraire des charts Helm Apigee

À l'aide de la commande pull, copiez tous les charts Helm Apigee hybrid sur votre espace de stockage local à l'aide de la commande suivante :

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

Installer Apigee hybrid

Présentation de la séquence d'installation

L'installation des composants s'effectue de gauche à droite comme indiqué ci-dessous. Les composants empilés verticalement dans la figure peuvent être installés ensemble et dans n'importe quel ordre. Une fois que vous avez installé un composant, vous pouvez le mettre à jour individuellement et à tout moment. Par exemple, une instance dupliquée, une mémoire, un processeur, etc.

Préparer l'installation d'Apigee hybrid avec des charts Helm

1. Créez l'espace de noms qui sera utilisé pour les ressources apigee. Il doit correspondre au champ de l'espace de noms du fichier overrides.yaml. S'il n'est pas présent dans overrides.yaml, la valeur par défaut est apigee.

   1. Vérifiez si l'espace de noms existe déjà :

      kubectl get namespace apigee

      Si l'espace de noms existe, le résultat inclut les éléments suivants :

        NAME     STATUS   AGE
        apigee   Active   1d

   2. Si l'espace de noms n'existe pas déjà, créez-le :

      kubectl create namespace apigee

2. Créez les comptes de service et attribuez-leur les rôles IAM appropriés. Apigee hybrid utilise les comptes de service suivants :

   Compte de service	Rôles IAM
   apigee-cassandra	Administrateur des objets de l'espace de stockage
   apigee-logger	Rédacteur de journaux
   apigee-mart	Agent Apigee Connect
   apigee-metrics	Rédacteur de métriques Monitoring
   apigee-runtime	Aucun rôle requis
   apigee-synchronizer	Gestionnaire de synchronisateur Apigee
   apigee-udca	Agent d'analyses Apigee
   apigee-watcher	Agent d'exécution Apigee

   Apigee fournit un outil, create-service-account, dans le répertoire apigee-operator/etc/tools :

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

   Cet outil crée les comptes de service, attribue les rôles IAM à chaque compte et télécharge les fichiers de certificat au format JSON pour chaque compte.

   1. Créez le répertoire dans lequel vous souhaitez télécharger les fichiers de certificat du compte de service. Vous le spécifierez dans la commande suivante à la place de SERVICE_ACCOUNTS_PATH.
   2. Vous pouvez créer tous les comptes de service à l'aide d'une seule commande avec les options suivantes :

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

   3. Répertoriez les noms de vos comptes de service pour votre fichier de remplacement :

      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

      Pour en savoir plus, consultez la page suivante :

      • Étape 4 : Créer des comptes de service
      • À propos des comptes de service
3. Avant l'installation, consultez le fichier overrides.yaml pour vérifier les paramètres :
   Important : Apigee hybrid v1.10.4 a été mis à jour avec une version de correctif critique. Si vous le souhaitez, vous pouvez appliquer les paramètres de configuration requis pour les correctifs directement dans le fichier de remplacement de configuration décrit à cette étape. Si vous ajoutez les configurations de mise à niveau maintenant, vous n'aurez pas besoin d'effectuer par la suite d'autres mises à niveau correctives. Les paramètres de configuration du correctif (v1.10.4-hotfix.1) sont répertoriés dans le guide de mise à niveau. Consultez également la note de version dédiée aux correctifs :

   • 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"

   Il s'agit de la même configuration de remplacement que celle que vous utiliserez pour cette installation Helm. Pour en savoir plus sur ces paramètres, consultez la documentation de référence sur les propriétés de configuration.

   Pour obtenir plus d'exemples de fichiers de remplacement, consultez la section Étape 6 : Configurer l'environnement d'exécution hybride.

4. Activez l'accès au synchronisateur. Il s'agit d'une condition préalable à l'installation d'Apigee hybrid.

   1. Vérifiez si l'accès au synchronisateur est déjà activé à l'aide des commandes suivantes :

      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 ''
      

      Le résultat doit se présenter sous la forme suivante :

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

   2. Si le résultat n'inclut pas l'ID du compte de service, activez l'accès au synchronisateur. Votre compte doit disposer du rôle IAM d'administrateur de l'organisation Apigee (roles/apigee.admin) pour effectuer cette tâche.

      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"'"]}'
      

      Pour en savoir plus, consultez la section Étape 7 : Activer l'accès au synchronisateur dans la documentation d'installation Apigee hybrid.

5. Installez Cert Manager avec la commande suivante :

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

6. Installez les CRD Apigee :

   Remarque : À partir de cette étape, toutes les commandes doivent être exécutées sous la racine du dépôt de charts.
   Remarque : Il s'agit de la seule méthode compatible pour installer des CRD Apigee. N'utilisez pas kubectl apply sans -k. N'omettez pas --server-side.
   Remarque : Cette étape nécessite des autorisations de cluster élevées.

   1. Utilisez la fonctionnalité de simulation kubectl en exécutant la commande suivante :

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

   2. Après avoir validé la commande avec la simulation, exécutez la commande suivante :

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

   3. Validez l'installation à l'aide de la commande kubectl get crds :

      kubectl get crds | grep apigee

      Le résultat doit se présenter sous la forme suivante :

      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. Vérifiez les libellés existants sur les nœuds de cluster. Par défaut, Apigee planifie les pods de données sur les nœuds portant le libellé cloud.google.com/gke-nodepool=apigee-data et les pods d'exécution sont programmés sur les nœuds portant le libellé cloud.google.com/gke-nodepool=apigee-runtime. Vous pouvez personnaliser les libellés de votre pool de nœuds dans le fichier overrides.yaml.

   Pour en savoir plus, consultez la page Configurer des pools de nœuds dédiés.

Installer les charts Helm Apigee hybrid

Remarque : Avant d'exécuter des commandes de mise à niveau ou d'installation Helm, utilisez la fonctionnalité de simulation de Helm en ajoutant --dry-run à la fin de la commande. Consultez helm -h pour répertorier les commandes, les options et l'utilisation compatibles.

Important : Outil de migration : Si vous avez migré votre cluster vers la gestion Helm avec l'outil de migration Helm hybrid, vous disposez de ressources existantes dans votre cluster migré. Pour éviter de supprimer des ressources par inadvertance si la commande helm upgrade échoue, n'utilisez pas l'option ‑‑atomic.

Par exemple, dans la première étape, la commande est la suivante :

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

1. Installez l'opérateur/le contrôleur Apigee :

   Remarque : Cette étape nécessite des autorisations de cluster élevées. Exécutez helm -h ou helm install -h pour en savoir plus

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

   Important : Omettez l'option ‑‑atomic pour les clusters migrés.

   Vérifiez l'installation de l'opérateur Apigee :

   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

   Vérifiez qu'il est opérationnel en vérifiant sa disponibilité :

   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. Installez le datastore Apigee :

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

   Important : Omettez l'option ‑‑atomic pour les clusters migrés.

   Vérifiez que apigeedatastore est opérationnel en vérifiant son état :

   kubectl -n apigee get apigeedatastore default
   

   NAME      STATE       AGE
   default   running    2d

3. Installez la télémétrie Apigee :

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

   Important : Omettez l'option ‑‑atomic pour les clusters migrés.

   Vérifiez qu'il est opérationnel en vérifiant son état :

   kubectl -n apigee get apigeetelemetry apigee-telemetry
   

   NAME               STATE     AGE
   apigee-telemetry   running   2d

4. Installez Apigee Redis :

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

   Important : Omettez l'option ‑‑atomic pour les clusters migrés.

   Vérifiez qu'il est opérationnel en vérifiant son état :

   kubectl -n apigee get apigeeredis default
   

   NAME      STATE     AGE
   default   running   2d

5. Installez le gestionnaire d'entrée Apigee :

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

   Important : Omettez l'option ‑‑atomic pour les clusters migrés.

   Vérifiez qu'il est opérationnel en vérifiant sa disponibilité :

   kubectl -n apigee get deployment apigee-ingressgateway-manager
   

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

6. Installez l'organisation Apigee :

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

   Important : Omettez l'option ‑‑atomic pour les clusters migrés.

   Vérifiez qu'elle est opérationnelle en vérifiant l'état de l'organisation correspondante :

   kubectl -n apigee get apigeeorg
   

   NAME                      STATE     AGE
   apigee-org1-xxxxx          running   2d

7. Installez l'environnement.

   Vous devez installer un environnement à la fois. Spécifiez l'environnement avec --set env=ENV_NAME :

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

   Important : Omettez l'option ‑‑atomic pour les clusters migrés.

   Vérifiez qu'il est opérationnel en vérifiant l'état de l'environnement correspondant :

   kubectl -n apigee get apigeeenv
   

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

8. Créez les certificats TLS. Vous devez fournir des certificats TLS pour la passerelle d'entrée d'exécution dans votre configuration Apigee hybrid.

   1. Créez les certificats. Dans un environnement de production, vous devrez utiliser des certificats signés. Vous pouvez utiliser un certificat et une paire de clés ou un secret Kubernetes.

      Pour l'installation de démonstration et de test, la passerelle d'exécution peut accepter les identifiants autosignés. Dans l'exemple suivant, openssl est utilisé pour générer les identifiants autosignés :

      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
      

      Pour en savoir plus, consultez la section Étape 5 : Créer des certificats TLS.

   2. Créez le secret Kubernetes pour référencer les certificats :

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

9. Installez l'hôte virtuel.

   Vous devez installer un groupe d'environnements (hôte virtuel) à la fois. Spécifiez le groupe d'environnement avec --set envgroup=ENV_GROUP_NAME :

   # 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
   

   Important : Omettez l'option ‑‑atomic pour les clusters migrés.
   Remarque : ENV_GROUP_NAME doit être unique dans l'espace de noms apigee. Par exemple, si vous disposez d'un environnement et d'un groupe d'environnements prod, vous devez définir ce nom sur prod-envgroup. Le nom du groupe d'environnements ultérieur doit toujours être prod.

   Cela crée ApigeeRouteConfig (ARC) qui crée en interne ApigeeRoute une fois que l'observateur Apigee extrait les détails liés au groupe d'environnement du plan de contrôle. Par conséquent, vérifiez que l'état d'AR est en cours d'exécution :

   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

Cas d'utilisation supplémentaires des charts Helm avec Apigee hybrid

Sauvegarde et restauration de bases de données Cassandra

1. Pour activer la sauvegarde, procédez comme suit :

   1. Mettez à jour les détails de la sauvegarde Cassandra dans le fichier overrides.yaml :

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

      Remarque : Lorsque vous utilisez un bucket Cloud Storage, un compte de service Google Cloud apigee-cassandra-back doit être créé et disposer des rôles et/ou des autorisations appropriés pour écrire dans le bucket spécifié dans dbStorageBucket.

   2. Exécutez la mise à niveau de Helm sur le chart apigee-datastore :

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

      Important : Omettez l'option ‑‑atomic pour les clusters migrés.
2. De même, pour activer la restauration :

   1. Mettez à jour les détails de restauration Cassandra dans le fichier overrides.yaml :

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

   2. Exécutez la mise à niveau de Helm sur le chart apigee-datastore :

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

      Important : Omettez l'option ‑‑atomic pour les clusters migrés.

Pour en savoir plus sur la sauvegarde et la restauration Cassandra, consultez la page Présentation de la sauvegarde Cassandra.

Expansion multirégionale

La configuration multirégionale avec des charts Helm nécessite les mêmes conditions préalables que les procédures apigeectl actuelles. Pour plus d'informations, consultez la section Prérequis pour les déploiements multirégionaux.

La procédure de configuration d'Apigee hybrid pour une zone multirégionale est identique à la procédure existante via la configuration de l'hôte source multirégional, ainsi que la configuration du cluster Kubernetes et du contexte.

Configurer la première région

Procédez comme suit pour configurer la première région et vous préparer à configurer la deuxième région :

1. Suivez les étapes de la page Configurer Apigee hybrid pour une zone multirégionale afin de configurer l'hôte source multirégional sur votre plate-forme.

2. Pour la première région créée, récupérez les pods dans l'espace de noms Apigee :

   kubectl get pods -o wide -n apigee
   

3. Identifiez l'adresse hôte source multirégionale de Cassandra dans cette région, par exemple 10.0.0.11.

4. Préparez le fichier overrides.yaml pour la deuxième région et ajoutez l'adresse IP de l'hôte source comme suit :

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

   Remplacez les éléments suivants :

   • SEED_HOST_IP_ADDRESS par l'adresse IP de l'hôte source, par exemple 10.0.0.11.
   • DATACENTER_NAME par le nom du centre de données, par exemple dc-2.
   • RACK_NAME par le nom du rack, par exemple ra-1.
   • CLUSTER_NAME par le nom de votre cluster Apigee. La valeur par défaut est apigeecluster. Si vous utilisez un autre nom de cluster, vous devez spécifier une valeur pour cassandra.clusterName. Cette valeur doit être identique dans toutes les régions.

Configurer la deuxième région

Pour configurer la nouvelle région, procédez comme suit :

1. Installez cert-manager dans la région 2 :

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

2. Créez un secret Kubernetes pour votre compte de service.
3. Créez un secret Kubernetes pour votre certificat d'entrée.
4. Copiez votre certificat à partir du cluster existant vers le nouveau cluster. Le nouveau certificat racine CA est utilisé par Cassandra et d'autres composants hybrides pour mTLS. Par conséquent, il est essentiel de disposer de certificats cohérents dans l'ensemble du cluster.

   1. Définissez le contexte sur l'espace de noms d'origine :

      kubectl config use-context ORIGINAL_CLUSTER_NAME
      

   2. Exportez la configuration actuelle de l'espace de noms dans un fichier :

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

   3. Exportez le secret apigee-ca vers un fichier :

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

   4. Définissez le contexte sur le nom du cluster de la nouvelle région :

      kubectl config use-context NEW_CLUSTER_NAME
      

   5. Importez la configuration de l'espace de noms dans le nouveau cluster. Veillez à mettre à jour l'espace de noms dans le fichier si vous utilisez un autre espace de noms dans la nouvelle région :

      kubectl apply -f apigee-namespace.yaml
      

   6. Importez le secret dans le nouveau cluster :

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

5. Utilisez les charts Helm pour installer Apigee hybrid dans la nouvelle région à l'aide des commandes des charts Helm suivantes (comme illustré dans la région 1) :

   Remarque : Vous pouvez utiliser les mêmes CRD pour la cohérence en utilisant le même dossier que celui où vous avez téléchargé les charts. Vous pouvez également garder votre fichier de remplacement unique entre les régions 1 et 2 en renommant vos remplacements de manière unique, telle que overrides2.yaml, etc.

   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
   

   Important : Omettez l'option ‑‑atomic pour les clusters migrés.
6. Une fois que tous les composants sont installés, configurez Cassandra sur tous les pods des nouveaux centres de données. Pour obtenir des instructions, consultez la page Configurer Apigee hybrid pour une zone multirégionale, sélectionnez votre plate-forme, faites défiler la page jusqu'à Configurer la nouvelle région, puis recherchez l'étape 5.
7. Une fois la réplication de données terminée et validée, mettez à jour les hôtes sources :
   1. Supprimez multiRegionSeedHost: 10.0.0.11 de overrides-DATACENTER_NAME.yaml.

   2. Appliquez à nouveau la modification pour mettre à jour le RS de datastore apigee :

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

      Important : Omettez l'option ‑‑atomic pour les clusters migrés.

Héberger des images en mode privé

Au lieu de s'appuyer sur le dépôt Google Cloud public, vous pouvez éventuellement héberger les images en mode privé. Au lieu de remplacer chaque composant, vous pouvez ajouter des informations détaillées sur les remplacements :

hub: PRIVATE_REPO

Par exemple, si le hub suivant est fourni, le chemin d'accès de l'image sera automatiquement résolu :

hub: private-docker-host.com

comme :

## 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

Cliquer pour développer la liste des images Apigee

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

Pour afficher la liste des images Apigee hébergées dans le dépôt Google Cloud sur la ligne de commande :

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

Tolérances

Pour utiliser la fonctionnalité Rejets et tolérances de Kubernetes, vous devez définir la propriété de remplacement tolerations pour chaque composant Apigee hybrid. Les composants suivants acceptent la définition des tolérances :

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

Pour en savoir plus sur ces composants, consultez la documentation de référence sur les propriétés de configuration.

Par exemple, pour appliquer les tolérances au déploiement de l'opérateur Apigee :

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

Pour appliquer les tolérances au StatefulSet Cassandra :

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