Installazione e gestione di Apigee hybrid con i grafici Helm

Anteprima - Installing Apigee hybrid with Helm charts

Questa funzionalità è soggetta ai "Termini delle Offerte pre-GA" nella sezione Termini generali del servizio dei Termini specifici dei servizi. Le funzionalità pre-GA sono disponibili "così come sono" e potrebbero avere un supporto limitato. Per saperne di più, consulta le descrizioni della fase di lancio.

Questo documento descrive la procedura dettagliata per installare Apigee hybrid v1.10 utilizzando i grafici Helm.

Versione

I grafici Helm di Apigee hybrid sono destinati all'utilizzo con Apigee hybrid v1.10.x. Consulta la cronologia delle release di Apigee hybrid per l'elenco delle release ibride.

Prerequisiti

• Apigee hybrid 1.10.5
• Helm v3.10 e versioni successive
• Accedi al repository dei grafici Helm di Apigee hybrid all'indirizzo:
  oci://us-docker.pkg.dev/apigee-release/apigee-hybrid-helm-charts
• Interfaccia a riga di comando gcloud
• Un progetto Google Cloud per l'installazione ibrida di Apigee. Consulta Creazione e gestione dei progetti
• Un cluster Kubernetes per l'installazione di Apigee hybrid. Consulta:
  • Piattaforma e versione Kubernetes supportate
  • Configurazioni minime del cluster

Ambito

• Questa release supporta solo la versione 1.10.5 di Apigee hybrid.
• Questa release supporta:
  • Nuove installazioni di Apigee hybrid.
  • È stato eseguito l'upgrade delle installazioni esistenti di Apigee hybrid alla versione 1.10.5 e la migrazione alla gestione di Helm utilizzando lo strumento di migrazione di Helm di Apigee hybrid.
• Questa release supporta:
  • Installazione di base di Apigee hybrid
  • Backup e ripristino di Cassandra
  • Configurazione per più regioni

Nota: per la gestione dei cluster Apigee hybrid esistenti avviati con apigeectl, consulta Strumento di migrazione Helm di Apigee hybrid.

Piattaforme e versioni di Kubernetes supportate

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

Limitazioni

• I grafici Helm non supportano completamente i CRD, pertanto utilizzeremo il comando kubectl -k per installarli e aggiornarli. Il nostro obiettivo è seguire le best practice della community e di Google per la gestione di Kubernetes. I deployment dei CRD tramite Helm non hanno ancora raggiunto uno stato della community in cui riscontriamo un ampio supporto o richieste per un modello di questo tipo. Pertanto, la gestione dei CRD di Apigee deve essere eseguita utilizzando kubectl come indicato in questo documento.
• In apigeectl, abbiamo utilizzato file in tutto overrides.yaml per gli account di servizio e i certificati. Tuttavia, Helm non supporta i riferimenti ai file esterni alla directory del grafico. Scegli una delle seguenti opzioni per i file dell'account di servizio e dei certificati:
  • Inserisci copie dei file pertinenti in ogni directory del grafico
  • Creare link simbolici all'interno di ogni directory del grafico per ogni file o per una cartella. Helm seguirà i link simbolici al di fuori della directory del grafico, ma verrà visualizzato un avviso come il seguente:
    apigee-operator/gsa -> ../gsa
  • Utilizza i secret di Kubernetes. Ad esempio, per gli account di servizio:

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

    Sostituisci quanto segue:
    • SECRET_NAME con il nome del secret di Kubernetes che hai creato.
    • CLOUD_IAM_FILE_NAME.json con il nome del file JSON scaricato.

Piattaforma e versioni Kubernetes supportate

Per un elenco delle piattaforme supportate, consulta la colonna v1.10 nella tabella delle piattaforme supportate di Apigee Hybrid.

Autorizzazioni obbligatorie

Questa tabella elenca le risorse e le autorizzazioni richieste per Kubernetes e Apigee.

Per filtrare questa tabella, esegui una o più delle seguenti operazioni: seleziona una categoria, digita un termine di ricerca o fai clic sull'intestazione di una colonna per ordinare.

Attributi Swrve Datastore Env Gestore Ingress Operatore Organizzazione Redis Telemetria Host virtuale

Categoria	Risorsa	Tipo di risorsa	Autorizzazioni RBAC di Kubernetes
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
Gestore Ingress	certificates.cert-manager.io	Kubernetes	create delete patch update
Gestore Ingress	configmaps	Kubernetes	create delete patch update
Gestore Ingress	deployments.apps	Kubernetes	create get delete patch update
Gestore Ingress	horizontalpodautoscalers.autoscaling	Kubernetes	create delete patch update
Gestore Ingress	issuers.cert-manager.io	Kubernetes	create delete patch update
Gestore Ingress	serviceaccounts	Kubernetes	create delete patch update
Gestore Ingress	services	Kubernetes	create delete patch update
Operatore	apigeedatastores.apigee.cloud.google.com	Apigee	create delete get list patch update watch
Operatore	apigeedatastores.apigee.cloud.google.com/finalizers	Apigee	get patch update
Operatore	apigeedatastores.apigee.cloud.google.com/status	Apigee	get patch update
Operatore	apigeedeployments.apigee.cloud.google.com	Apigee	create delete get list patch update watch
Operatore	apigeedeployments.apigee.cloud.google.com/finalizers	Apigee	get patch update
Operatore	apigeedeployments.apigee.cloud.google.com/status	Apigee	get patch update
Operatore	apigeeenvironments.apigee.cloud.google.com	Apigee	create delete get list patch update watch
Operatore	apigeeenvironments.apigee.cloud.google.com/finalizers	Apigee	get patch update
Operatore	apigeeenvironments.apigee.cloud.google.com/status	Apigee	get patch update
Operatore	apigeeissues.apigee.cloud.google.com	Apigee	create delete get list watch
Operatore	apigeeorganizations.apigee.cloud.google.com	Apigee	create delete get list patch update watch
Operatore	apigeeorganizations.apigee.cloud.google.com/finalizers	Apigee	get patch update
Operatore	apigeeorganizations.apigee.cloud.google.com/status	Apigee	get patch update
Operatore	apigeeredis.apigee.cloud.google.com	Apigee	create delete get list patch update watch
Operatore	apigeeredis.apigee.cloud.google.com/finalizers	Apigee	get patch update
Operatore	apigeeredis.apigee.cloud.google.com/status	Apigee	get patch update
Operatore	apigeerouteconfigs.apigee.cloud.google.com	Apigee	get list
Operatore	apigeeroutes.apigee.cloud.google.com	Apigee	create delete get list patch update watch
Operatore	apigeeroutes.apigee.cloud.google.com/finalizers	Apigee	get patch update
Operatore	apigeeroutes.apigee.cloud.google.com/status	Apigee	get patch update
Operatore	apigeetelemetries.apigee.cloud.google.com	Apigee	create delete get list patch update watch
Operatore	apigeetelemetries.apigee.cloud.google.com/finalizers	Apigee	get patch update
Operatore	apigeetelemetries.apigee.cloud.google.com/status	Apigee	get list patch update
Operatore	cassandradatareplications.apigee.cloud.google.com	Apigee	get list patch update watch
Operatore	cassandradatareplications.apigee.cloud.google.com/finalizers	Apigee	get patch update
Operatore	cassandradatareplications.apigee.cloud.google.com/status	Apigee	get patch update
Operatore	*.networking.x.k8s.io	Kubernetes	get list watch
Operatore	apiservices.apiregistration.k8s.io	Kubernetes	create delete get list patch update watch
Operatore	certificates.cert-manager.io	Kubernetes	create delete get list patch update watch
Operatore	certificates.cert-manager.io/finalizers	Kubernetes	create delete get list patch update watch
Operatore	certificatesigningrequests.certificates.k8s.io	Kubernetes	create delete get update watch
Operatore	certificatesigningrequests.certificates.k8s.io/approval	Kubernetes	create delete get update watch
Operatore	certificatesigningrequests.certificates.k8s.io/status	Kubernetes	create delete get update watch
Operatore	clusterissuers.cert-manager.io	Kubernetes	create get watch
Operatore	clusterrolebindings.rbac.authorization.k8s.io	Kubernetes	create delete get list patch update watch
Operatore	clusterroles.rbac.authorization.k8s.io	Kubernetes	create delete get list patch update watch
Operatore	configmaps	Kubernetes	create delete get list patch update watch
Operatore	configmaps/status	Kubernetes	get patch update
Operatore	cronjobs.batch	Kubernetes	create delete get list patch update watch
Operatore	customresourcedefinitions.apiextensions.k8s.io	Kubernetes	get list watch
Operatore	daemonsets.apps	Kubernetes	create delete get list patch update watch
Operatore	deployments.apps	Kubernetes	get list watch
Operatore	deployments.extensions	Kubernetes	get list watch
Operatore	destinationrules.networking.istio.io	Kubernetes	create delete get list patch update watch
Operatore	endpoints	Kubernetes	get list watch
Operatore	endpointslices.discovery.k8s.io	Kubernetes	get list watch
Operatore	events	Kubernetes	create delete get list patch update watch
Operatore	gateways.networking.istio.io	Kubernetes	create delete get list patch update watch
Operatore	horizontalpodautoscalers.autoscaling	Kubernetes	create delete get list patch update watch
Operatore	ingressclasses.networking.k8s.io	Kubernetes	get list watch
Operatore	ingresses.networking.k8s.io/status	Kubernetes	all verbs
Operatore	issuers.cert-manager.io	Kubernetes	create delete get list patch update watch
Operatore	jobs.batch	Kubernetes	create delete get list patch update watch
Operatore	leases.coordination.k8s.io	Kubernetes	create get list update
Operatore	namespaces	Kubernetes	create get list watch
Operatore	nodes	Kubernetes	get list watch
Operatore	peerauthentications.security.istio.io	Kubernetes	create delete get list patch update watch
Operatore	persistentvolumeclaims	Kubernetes	create delete get list patch update watch
Operatore	persistentvolumes	Kubernetes	get list watch
Operatore	poddisruptionbudgets.policy	Kubernetes	create delete get list patch update watch
Operatore	pods	Kubernetes	create delete get list patch update watch
Operatore	pods/exec	Kubernetes	create
Operatore	replicasets.apps	Kubernetes	create delete get list patch update watch
Operatore	replicasets.extensions	Kubernetes	get list watch
Operatore	resourcequotas	Kubernetes	create delete get list patch update watch
Operatore	rolebindings.rbac.authorization.k8s.io	Kubernetes	create delete get list patch update watch
Operatore	roles.rbac.authorization.k8s.io	Kubernetes	create delete get list patch update watch
Operatore	secrets	Kubernetes	batch create delete get list patch update watch
Operatore	securitycontextconstraints.security.openshift.io	Kubernetes	create get list
Operatore	serviceaccounts	Kubernetes	create delete get list patch update watch
Operatore	services	Kubernetes	batch create delete get list patch update watch
Operatore	signers.certificates.k8s.io	Kubernetes	approve
Operatore	statefulsets.apps	Kubernetes	create delete get list patch update watch
Operatore	subjectaccessreviews.authorization.k8s.io	Kubernetes	create get list
Operatore	tokenreviews.authentication.k8s.io	Kubernetes	create
Operatore	virtualservices.networking.istio.io	Kubernetes	create delete get list patch update watch
Organizzazione	apigeeorganizations.apigee.cloud.google.com	Apigee	create delete patch update
Organizzazione	secrets	Kubernetes	create delete patch update
Organizzazione	serviceaccounts	Kubernetes	create delete patch update
Redis	apigeeredis.apigee.cloud.google.com	Apigee	create delete patch update
Redis	secrets	Kubernetes	create delete patch update
Telemetria	apigeetelemetry.apigee.cloud.google.com	Apigee	create delete patch update
Telemetria	secrets	Kubernetes	create delete patch update
Telemetria	serviceaccounts	Kubernetes	create delete patch update
Host virtuale	apigeerouteconfigs.apigee.cloud.google.com	Apigee	create delete patch update
Host virtuale	secrets	Kubernetes	create delete patch update

Vedi anche:

• Utilizzo dell'autorizzazione RBAC
• Determina il verbo della richiesta

Prepararsi all'installazione

I grafici di Apigee hybrid sono ospitati in Google Artifact Registry:

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

Estrai i grafici Helm di Apigee

Utilizzando il comando pull, copia tutti i grafici Helm hybrid di Apigee nel tuo spazio di archiviazione locale con il seguente comando:

export CHART_REPO=oci://us-docker.pkg.dev/apigee-release/apigee-hybrid-helm-charts
export CHART_VERSION=1.10.5
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

Installa Apigee hybrid

Panoramica della sequenza di installazione

L'installazione dei componenti viene eseguita da sinistra a destra in sequenza, come mostrato nella figura seguente. I componenti impilati verticalmente nella figura possono essere installati insieme e in qualsiasi ordine. Una volta installato un componente, puoi aggiornarlo singolarmente e in qualsiasi momento, ad esempio replica, memoria, CPU e così via.

Prepararsi a installare Apigee hybrid con i grafici Helm

1. Crea lo spazio dei nomi che verrà utilizzato per le risorse apigee. Deve corrispondere al campo dello spazio dei nomi nel file overrides.yaml. Se non è presente in overrides.yaml, il valore predefinito è apigee.

   1. Verifica se lo spazio dei nomi esiste già:

      kubectl get namespace apigee

      Se lo spazio dei nomi esiste, l'output include:

        NAME     STATUS   AGE
        apigee   Active   1d

   2. Se lo spazio dei nomi non esiste già, creane uno:

      kubectl create namespace apigee

2. Crea lo spazio dei nomi apigee-system utilizzato dalle risorse dell'operatore Apigee.

   1. Verifica se lo spazio dei nomi esiste già:

      kubectl get namespace apigee-system

   2. Se lo spazio dei nomi non esiste già, creane uno:

      kubectl create namespace apigee-system

3. Crea gli account di servizio e assegna loro i ruoli IAM appropriati. Apigee Hybrid utilizza i seguenti account di servizio:

   Service account	Ruoli IAM
   apigee-cassandra	Storage Object Admin
   apigee-logger	Logs Writer
   apigee-mart	Apigee Connect Agent
   apigee-metrics	Monitoring Metric Writer
   apigee-runtime	Nessun ruolo richiesto
   apigee-synchronizer	Gestore sincronizzatore Apigee
   apigee-udca	Apigee Analytics Agent
   apigee-watcher	Apigee Runtime Agent

   Apigee fornisce uno strumento, create-service-account, nella directory apigee-operator/etc/tools:

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

   Questo strumento crea gli account di servizio, assegna i ruoli IAM a ciascun account e scarica i file dei certificati in formato JSON per ciascun account.

   1. Crea la directory in cui vuoi scaricare i file dei certificati dell'account di servizio. Lo specificherai nel comando seguente al posto di SERVICE_ACCOUNTS_PATH.
   2. Puoi creare tutti gli account di servizio con un unico comando con le seguenti opzioni:

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

   3. Elenca i nomi dei tuoi account di servizio per il file delle sostituzioni:

      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

      Per ulteriori informazioni consulti:

      • Passaggio 4: crea gli account di servizio
      • Informazioni sugli account di servizio
4. Prima dell'installazione, controlla il file overrides.yaml per verificare le impostazioni:
   Importante: Apigee Hybrid 1.10.5 è stato aggiornato con una release di hotfix critica. Se vuoi, puoi applicare le impostazioni di configurazione richieste per il hotfix direttamente nel file delle sostituzioni di configurazione descritto in questo passaggio. Se aggiungi le configurazioni di upgrade ora, non dovrai eseguire ulteriori upgrade dei hotfix in un secondo momento. Le impostazioni di configurazione per il hotfix (v1.10.5-hotfix.1) sono elencate nella guida all'upgrade. Consulta anche la nota di rilascio relativa al rilascio dell'hotfix:

   • hybrid v1.10.5-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"

   Si tratta della stessa configurazione delle sostituzioni che utilizzerai per questa installazione di Helm. Per altre impostazioni, consulta il riferimento per le proprietà di configurazione.

   Per altri esempi di file di override, consulta il passaggio 6: configurare il runtime ibrido.

5. Attiva l'accesso al sincronizzatore. Questo è un prerequisito per l'installazione di Apigee hybrid.

   1. Controlla se l'accesso al sincronizzatore è già abilitato con i seguenti comandi:

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

      L'output dovrebbe essere simile al seguente:

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

   2. Se l'output non include l'ID account di servizio, attiva l'accesso al sincronizzatore. Per eseguire questa operazione, il tuo account deve disporre del ruolo IAM Amministratore organizzazione Apigee (roles/apigee.admin).

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

      Per informazioni più dettagliate, consulta il Passaggio 7: attiva l'accesso al sincronizzatore nella documentazione di installazione di Apigee hybrid.

6. Installa Cert Manager con il seguente comando:

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

7. Installa i CRD di Apigee:

   Nota: da questo passaggio in poi, tutti i comandi devono essere eseguiti nella directory principale del repository del grafico.
   Nota: questo è l'unico metodo supportato per l'installazione dei CRD di Apigee. Non utilizzare kubectl apply senza -k, non omettere --server-side.
   Nota: questo passaggio richiede autorizzazioni elevate per il cluster.

   1. Utilizza la funzionalità di prova simulata kubectl eseguendo il seguente comando:

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

   2. Dopo la convalida con il comando dry-run, esegui il seguente comando:

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

   3. Convalida l'installazione con il comando kubectl get crds:

      kubectl get crds | grep apigee

      L'output dovrebbe essere simile al seguente:

      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
      

8. Controlla le etichette esistenti sui nodi del cluster. Per impostazione predefinita, Apigee pianifica i pod di dati sui nodi con l'etichetta cloud.google.com/gke-nodepool=apigee-data e i pod di runtime vengono pianificati sui nodi con l'etichetta cloud.google.com/gke-nodepool=apigee-runtime. Puoi personalizzare le etichette del pool di nodi nel file overrides.yaml.

   Per ulteriori informazioni, consulta Configurare i pool di nodi dedicati.

Installa i grafici Helm di Apigee hybrid

Nota: prima di eseguire uno dei comandi di upgrade/installazione di Helm, usa la funzionalità di prova di Helm aggiungendo --dry-run alla fine del comando. Consulta helm -h per un elenco dei comandi, delle opzioni e dell'utilizzo supportati.

Strumento di migrazione importante: se hai eseguito la migrazione del tuo cluster alla gestione di Helm con lo strumento di migrazione Helm ibrida di Apigee, nel cluster di destinazione sono presenti risorse esistenti. Per evitare di eliminare accidentalmente le risorse se il comando helm upgrade non va a buon fine, non utilizzare il flag ‑‑atomic.

Ad esempio, nel primo passaggio il comando sarà:

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

1. Installa Apigee Operator/Controller:

   Nota: questo passaggio richiede autorizzazioni elevate per il cluster. Esegui helm -h o helm install -h per i dettagli

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

   Importante: ometti il flag ‑‑atomic per i cluster sottoposti a migrazione.

   Verifica l'installazione di Apigee Operator:

   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.5   1.10.5

   Verifica che sia attivo e funzionante controllandone la 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. Installa il data store Apigee:

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

   Importante: ometti il flag ‑‑atomic per i cluster sottoposti a migrazione.

   Verifica che apigeedatastore sia attivo controllandone lo stato:

   kubectl -n apigee get apigeedatastore default
   

   NAME      STATE       AGE
   default   running    2d

3. Installa la telemetria di Apigee:

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

   Importante: ometti il flag ‑‑atomic per i cluster sottoposti a migrazione.

   Verifica che sia attivo e funzionante controllandone lo stato:

   kubectl -n apigee get apigeetelemetry apigee-telemetry
   

   NAME               STATE     AGE
   apigee-telemetry   running   2d

4. Installa Apigee Redis:

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

   Importante: ometti il flag ‑‑atomic per i cluster sottoposti a migrazione.

   Verifica che sia attivo e funzionante controllandone lo stato:

   kubectl -n apigee get apigeeredis default
   

   NAME      STATE     AGE
   default   running   2d

5. Installa Apigee Ingress Manager:

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

   Importante: ometti il flag ‑‑atomic per i cluster sottoposti a migrazione.

   Verifica che sia attivo e funzionante controllandone la 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. Installa l'organizzazione Apigee:

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

   Importante: ometti il flag ‑‑atomic per i cluster sottoposti a migrazione.

   Verifica che sia attivo controllando lo stato della rispettiva organizzazione:

   kubectl -n apigee get apigeeorg
   

   NAME                      STATE     AGE
   apigee-org1-xxxxx          running   2d

7. Installa l'ambiente.

   Devi installare un ambiente alla volta. Specifica l'ambiente con --set env=ENV_NAME:

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

   Importante: ometti il flag ‑‑atomic per i cluster sottoposti a migrazione.

   Verifica che sia attivo controllando lo stato del rispettivo env:

   kubectl -n apigee get apigeeenv
   

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

8. Crea i certificati TLS. Devi fornire certificati TLS per il gateway di ingresso di runtime nella configurazione ibrida di Apigee.

   1. Crea i certificati. In un ambiente di produzione, dovrai utilizzare certificati firmati. Puoi utilizzare un certificato e una coppia di chiavi o un secret Kubernetes.

      Per la dimostrazione e il test dell'installazione, il gateway di runtime può accettare credenziali autofirmate. Nell'esempio seguente, openssl viene utilizzato per generare le credenziali autofirmate:

      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
      

      Per ulteriori informazioni, consulta Passaggio 5: crea i certificati TLS.

   2. Crea il secret di Kubernetes per fare riferimento ai certificati:

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

9. Installa l'host virtuale.

   Devi installare un gruppo di ambienti (virtualhost) alla volta. Specifica il gruppo di ambienti con --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
   

   Importante: ometti il flag ‑‑atomic per i cluster sottoposti a migrazione.
   Nota: ENV_GROUP_NAME deve essere univoco all'interno dello spazio dei nomi apigee. Ad esempio, se hai un env e un envgroup prod, devi impostare questo nome su prod-envgroup. Il nome del gruppo env successivo dovrebbe essere ancora prod.

   Viene creato ApigeeRouteConfig (ARC), che internamente crea ApigeeRoute (AR) quando lo watcher di Apigee estrae i dettagli relativi al gruppo env dal piano di controllo. Pertanto, controlla che lo stato corrispondente dell'AR sia in esecuzione:

   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

Casi d'uso aggiuntivi per i grafici Helm con Apigee hybrid

Backup e ripristino di Cassandra

1. Per attivare il backup:

   1. Aggiorna i dettagli del backup di Cassandra nel file overrides.yaml:

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

      Nota: quando utilizzi un bucket Cloud Storage, devi creare un account di servizio Google Cloud apigee-cassandra-back con ruoli e/o autorizzazioni appropriati per scrivere nel bucket specificato in dbStorageBucket.

   2. Esegui l'upgrade di Helm nel grafico apigee-datastore:

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

      Importante: ometti il flag ‑‑atomic per i cluster sottoposti a migrazione.
2. Analogamente, per attivare il ripristino:

   1. Aggiorna i dettagli del ripristino di Cassandra nel file overrides.yaml:

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

   2. Esegui l'upgrade di Helm nel grafico apigee-datastore:

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

      Importante: ometti il flag ‑‑atomic per i cluster sottoposti a migrazione.

Per ulteriori dettagli sul backup e sul ripristino di Cassandra, consulta la panoramica del backup di Cassandra.

Espansione su più regioni

La configurazione multiregione con i grafici Helm richiede gli stessi prerequisiti delle attuali procedure apigeectl. Per informazioni dettagliate, consulta Prerequisiti per gli implementazioni multiregione.

La procedura per configurare l'ibrido per più regioni è la stessa della procedura esistente fino alla procedura di configurazione dell'host seed multi-regione e della configurazione del contesto e del cluster Kubernetes.

Configura la prima regione

Per configurare la prima regione e prepararti a configurare la seconda:

1. Segui i passaggi descritti in Configurare Apigee hybrid per più regioni per configurare l'host seed multi-regione sulla tua piattaforma.

2. Per la prima regione creata, recupera i pod nello spazio dei nomi apigee:

   kubectl get pods -o wide -n apigee
   

3. Identifica l'indirizzo host del seme multi-regione per Cassandra in questa regione, ad esempio 10.0.0.11.

4. Prepara il file overrides.yaml per la seconda regione e aggiungi l'indirizzo IP dell'host seed come segue:

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

   Sostituisci quanto segue:

   • SEED_HOST_IP_ADDRESS con l'indirizzo IP dell'host iniziale, ad esempio 10.0.0.11.
   • DATACENTER_NAME con il nome del data center, ad esempio dc-2.
   • RACK_NAME con il nome del rack, ad esempio ra-1.
   • CLUSTER_NAME con il nome del cluster Apigee. Per impostazione predefinita, il valore è apigeecluster. Se utilizzi un nome del cluster diverso, devi specificare un valore per cassandra.clusterName. Questo valore deve essere lo stesso in tutte le regioni.

Configura la seconda regione

Per configurare la nuova regione:

1. Installa cert-manager nella regione 2:

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

2. Copia il certificato dal cluster esistente al nuovo cluster. La nuova CA principale viene utilizzata da Cassandra e da altri componenti ibride per mTLS. Pertanto, è essenziale disporre di certificati coerenti in tutto il cluster.

   1. Imposta il contesto sullo spazio dei nomi originale:

      kubectl config use-context ORIGINAL_CLUSTER_NAME
      

   2. Esporta la configurazione dello spazio dei nomi attuale in un file:

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

   3. Esporta il secret apigee-ca in un file:

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

   4. Imposta il contesto sul nome del cluster della nuova regione:

      kubectl config use-context NEW_CLUSTER_NAME
      

   5. Importa la configurazione dello spazio dei nomi nel nuovo cluster. Assicurati di aggiornare lo spazio dei nomi nel file se utilizzi uno spazio dei nomi diverso nella nuova regione:

      kubectl apply -f apigee-namespace.yaml
      

   6. Importa il secret nel nuovo cluster:

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

3. Ora utilizza i grafici Helm per installare Apigee Hybrid nella nuova regione con i seguenti comandi del grafico Helm (come fatto nella regione 1):

   Nota: per garantire la coerenza, puoi utilizzare gli stessi CRD utilizzando la stessa cartella in cui hai scaricato i grafici. Puoi anche mantenere univoco il file delle sostituzioni tra la regione 1 e la 2 assegnando un nome univoco alle sostituzioni, ad esempio overrides2.yaml e così via.

   helm upgrade operator apigee-operator \
     --install \
     --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
   

   Importante: ometti il flag ‑‑atomic per i cluster sottoposti a migrazione.
4. Una volta installati tutti i componenti, configura Cassandra su tutti i pod nei nuovi data center. Per istruzioni, consulta Configurare Apigee hybrid per più regioni, seleziona la tua piattaforma, scorri fino a Configurare la nuova regione e poi individua il passaggio 5.
5. Una volta completata e verificata la replica dei dati, aggiorna gli host di seed:
   1. Vuoi rimuovere multiRegionSeedHost: 10.0.0.11 da overrides-DATACENTER_NAME.yaml?

      La voce multiRegionSeedHost non è più necessaria dopo l'impostazione della replica dei dati e gli IP dei pod dovrebbero cambiare nel tempo.

   2. Applica di nuovo la modifica per aggiornare la RP apigee datastore:

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

      Importante: ometti il flag ‑‑atomic per i cluster sottoposti a migrazione.

Hosting di immagini in privato

Anziché utilizzare il repository pubblico di Google Cloud, facoltativamente potresti scegliere di ospitare le immagini in privato. Anziché sostituire ogni componente, puoi aggiungere dettagli dell'hub alle sostituzioni:

hub: PRIVATE_REPO

Ad esempio, se viene fornito il seguente hub, il percorso dell'immagine verrà risolto automaticamente:

hub: private-docker-host.com

come:

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

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

Fai clic per espandere un elenco di immagini 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

Per visualizzare un elenco delle immagini Apigee ospitate nel repository Google Cloud sulla riga di comando:

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

Tolleranza

Per utilizzare la funzionalità di incompatibilità e tolleranze di Kubernetes, devi definire la proprietà di override tolerations per ogni componente ibrido Apigee. I seguenti componenti supportano la definizione delle tolleranze:

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

Per ulteriori informazioni su questi componenti, consulta la sezione Riferimento alle proprietà di configurazione.

Ad esempio, per applicare le tolleranze al deployment dell'operatore Apigee:

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

Per applicare le tolleranze al StatefulSet di Cassandra:

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

Disinstalla Apigee hybrid con Helm

Per disinstallare un aggiornamento o una release specifici, puoi utilizzare il comando helm [uninstall/delete] RELEASE-NAME -n NAMESPACE.

Per disinstallare completamente Apigee Hybrid dal cluster:

1. Elimina i virtualhost. Esegui questo comando per ogni virtualhost:

   helm -n apigee delete VIRTUALHOST_RELEASE-NAME
   

2. Elimina gli ambienti. Esegui questo comando per ogni env:

   helm -n apigee delete ENV_RELEASE-NAME
   

3. elimina l'organizzazione Apigee:

   helm -n apigee delete ORG_RELEASE-NAME
   

4. elimina telemetria:

   helm -n apigee delete TELEMETRY_RELEASE-NAME
   

5. Elimina redis:

   helm -n apigee delete REDIS_RELEASE-NAME
   

6. Elimina il gestore di ingressi:

   helm -n apigee delete INGRESS_MANAGER_RELEASE-NAME
   

7. Elimina il datastore:

   helm -n apigee delete DATASTORE_RELEASE-NAME
   

   Suggerimento: se lo stato di apigeeds/default rimane deleting, ma non termina mai, controlla i pod per verificare se un job di pulizia non è riuscito.
8. Elimina l'operatore.
   1. Assicurati che tutte le RP vengano eliminate prima di:

      kubectl -n apigee get apigeeds, apigeetelemetry, apigeeorg, apigreeenv, arc, apigeeredis
      

   2. Elimina l'operatore Apigee:

      helm -n apigee-system delete OPERATOR_RELEASE-NAME
      

9. Elimina i CRD di Apigee hybrid:

   kubectl delete -k  apigee-operator/etc/crds/default/