Installer et gérer Apigee hybrid avec des charts Helm

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

Définition du champ d'application

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
      

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.

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 :

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.

Séquence d'installation : gestionnaire de certificats, CRD, puis opérateur Apigee, puis composants empilés : redis et datastore, gestionnaire de télémétrie et d'entrées, puis organisation et composants empilés : environnement et hôte virtuel

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 :

  3. Avant l'installation, consultez le fichier overrides.yaml pour vérifier les paramètres :
    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 :

    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

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

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

    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
    

    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
    

    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
    

    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
    

    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
    

    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
    

    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
    

    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"
    2. Exécutez la mise à niveau de Helm sur le chart apigee-datastore :

      helm upgrade datastore apigee-datastore/ \
        --namespace apigee \
        --atomic \
        -f overrides.yaml
      
  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
      

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) :

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

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

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