Questa pagina è stata tradotta dall'API Cloud Translation.

Upgrade di Apigee hybrid alla versione 1.11

Questa procedura riguarda l'upgrade dalla versione ibrida di Apigee dalla versione 1.10.x ad Apigee ibrida versione 1.11.1 e dalle release precedenti dell'ibrido 1.11.x alla versione 1.11.1.

Utilizza le stesse procedure per gli upgrade delle versioni secondarie (ad esempio dalla versione 1.10 alla versione 1.11) e per gli upgrade delle release delle patch (ad esempio dalla versione 1.11.0 alla versione 1.11.1).

Se esegui l'upgrade da Apigee ibrido versione 1.9 o precedente, devi eseguire l'upgrade alla versione ibrida 1.10 prima di eseguire l'upgrade alla versione 1.11.1. Consulta le istruzioni per eseguire l'upgrade di Apigee hybrid alla versione 1.10.

Panoramica dell'upgrade alla versione 1.11.1

L'upgrade ad Apigee hybrid versione 1.11 potrebbe richiedere tempi di inattività.

Durante l'upgrade del controller Apigee alla versione 1.11.1, tutti i deployment Apigee vengono riavviati in sequenza. Per ridurre al minimo i tempi di inattività negli ambienti ibridi di produzione durante un riavvio in sequenza, assicurati di eseguire almeno due cluster (nella stessa regione o in un data center diverso). Devia tutto il traffico di produzione a un singolo cluster, porta offline il cluster di cui stai per eseguire l'upgrade, quindi procedi con il processo di upgrade. Ripeti la procedura per ogni cluster.

Apigee consiglia di eseguire l'upgrade di tutti i cluster il prima possibile per ridurre le probabilità di impatto sulla produzione. Non esiste un limite di tempo per l'upgrade di tutti i cluster rimanenti dopo l'upgrade del primo. Tuttavia, fino all'upgrade di tutti i cluster rimanenti, saranno interessate le seguenti operazioni:

Il backup e ripristino di Cassandra non possono funzionare con versioni miste. Ad esempio, non è possibile utilizzare un backup da versione ibrida 1.10 per ripristinare un'istanza ibrida 1.11.
Il flusso di dati Cassandra non funziona tra versioni ibride miste. Di conseguenza, i cluster Cassandra non possono scalare orizzontalmente.
Ne risentiranno l'espansione e il ritiro della regione, perché queste operazioni dipendono dal flusso di dati Cassandra.

Le procedure per l'upgrade di Apigee hybrid sono organizzate nelle seguenti sezioni:

Preparati per l'upgrade.
Installa la versione del runtime ibrido 1.11.1.

Prerequisiti

Queste istruzioni per l'upgrade presuppongono che sia installata la versione ibrida di Apigee 1.10.x e che tu voglia eseguirne l'upgrade alla versione 1.11.1. Se stai eseguendo l'aggiornamento da una versione precedente, consulta le istruzioni per eseguire l'upgrade di Apigee hybrid alla versione 1.10.

Grafici Helm e `apigeectl`

Nella versione 1.11 puoi scegliere di installare e gestire la piattaforma Apigee ibrida con grafici Helm o apigeectl. Apigee consiglia di utilizzare Helm per gestire l'installazione.

Migrazione alla versione 1.11 con Helm dalla versione 1.10 con `apigeectl`

Per eseguire l'upgrade ad Apigee hybrid v1.11 gestito da Helm da un'installazione ibrida v1.10 gestita con apigeectl:

Innanzitutto, esegui la migrazione del Helm per l'installazione della versione 1.10 seguendo le istruzioni in Eseguire la migrazione di grafici da Apigee hybrid a Helm da apigeectl.
Segui le istruzioni per i grafici Helm riportati di seguito per eseguire l'upgrade dell'installazione.
Nota: quando esegui l'upgrade di un'installazione di cui è stata eseguita la migrazione, devi inserire un flag --force nei comandi helm upgrade.

Preparati per l'upgrade alla versione 1.11

Esegui il backup dell'installazione ibrida (opzione consigliata)

Helm

Queste istruzioni utilizzano la variabile di ambiente APIGEE_HELM_CHARTS_HOME per la directory nel file system in cui hai installato i grafici Helm. Se necessario, cambia la directory in questa directory e definisci la variabile con il seguente comando:
Linux
```
export APIGEE_HELM_CHARTS_HOME=$PWD
echo $APIGEE_HELM_CHARTS_HOME
```
Mac OS
```
export APIGEE_HELM_CHARTS_HOME=$PWD
echo $APIGEE_HELM_CHARTS_HOME
```
Windows
```
set APIGEE_HELM_CHARTS_HOME=%CD%
echo %APIGEE_HELM_CHARTS_HOME%
```
Crea una copia di backup della directory $APIGEE_HELM_CHARTS_HOME/ della versione 1.10. Puoi utilizzare qualsiasi processo di backup. Ad esempio, puoi creare un file tar dell'intera directory con:
```
tar -czvf $APIGEE_HELM_CHARTS_HOME/../apigee-helm-charts-v1.10-backup.tar.gz $APIGEE_HELM_CHARTS_HOME
```
Esegui il backup del database Cassandra seguendo le istruzioni in Backup e ripristino di Cassandra.

Se utilizzi file di certificati del servizio (.json) negli override per autenticare gli account di servizio, assicurati che i file dei certificati dell'account di servizio si trovino nella directory del grafico Helm corretta. I grafici Helm non possono leggere i file all'esterno di ciascuna directory del grafico.

Questo passaggio non è necessario se utilizzi secret di Kubernetes o Workload Identity per autenticare gli account di servizio.

La tabella seguente mostra la destinazione di ciascun file dell'account di servizio, a seconda del tipo di installazione:

Produzione

Account di servizio	Nome file predefinito	Directory dei grafici Helm
`apigee-cassandra`	`PROJECT_ID-apigee-cassandra.json`	`$APIGEE_HELM_CHARTS_HOME/apigee-datastore/`
`apigee-logger`	`PROJECT_ID-apigee-logger.json`	`$APIGEE_HELM_CHARTS_HOME/apigee-telemetry/`
`apigee-mart`	`PROJECT_ID-apigee-mart.json`	`$APIGEE_HELM_CHARTS_HOME/apigee-org/`
`apigee-metrics`	`PROJECT_ID-apigee-metrics.json`	`$APIGEE_HELM_CHARTS_HOME/apigee-telemetry/`
`apigee-runtime`	`PROJECT_ID-apigee-runtime.json`	`$APIGEE_HELM_CHARTS_HOME/apigee-env`
`apigee-synchronizer`	`PROJECT_ID-apigee-synchronizer.json`	`$APIGEE_HELM_CHARTS_HOME/apigee-env/`
`apigee-udca`	`PROJECT_ID-apigee-udca.json`	`$APIGEE_HELM_CHARTS_HOME/apigee-org/`
`apigee-watcher`	`PROJECT_ID-apigee-watcher.json`	`$APIGEE_HELM_CHARTS_HOME/apigee-org/`

Non di produzione

Crea una copia del file dell'account di servizio apigee-non-prod in ciascuna delle seguenti directory:

Account di servizio	Nome file predefinito	Directory dei grafici Helm
`apigee-non-prod`	`PROJECT_ID-apigee-non-prod.json`	`$APIGEE_HELM_CHARTS_HOME/apigee-datastore/` `$APIGEE_HELM_CHARTS_HOME/apigee-telemetry/` `$APIGEE_HELM_CHARTS_HOME/apigee-org/` `$APIGEE_HELM_CHARTS_HOME/apigee-env/`

Assicurati che il certificato TLS e i file della chiave (.crt, .key e/o .pem) si trovino nella directory $APIGEE_HELM_CHARTS_HOME/apigee-virtualhost/.

`apigeectl`

Gli esempi in queste istruzioni utilizzano la seguente struttura di directory. L'installazione potrebbe essere diversa. Modifica le istruzioni in base alla struttura dell'installazione.

hybrid-v1.11-root-directory/
└── apigeectl/
    └── config/
    └── plugins/
    └── templates/
    └── tools/
└── hybrid-files/
    └── overrides/
    └── service-accounts/
    └── certs/
hybrid-v1.10-root-directory/

Queste istruzioni utilizzano la variabile di ambiente APIGEECTL_HOME per la directory nel file system in cui hai installato apigeectl. Se necessario, cambia directory nella directory apigeectl e definisci la variabile con il seguente comando:
Linux
```
export APIGEECTL_HOME=$PWD
echo $APIGEECTL_HOME
```
Mac OS
```
export APIGEECTL_HOME=$PWD
echo $APIGEECTL_HOME
```
Windows
```
set APIGEECTL_HOME=%CD%
echo %APIGEECTL_HOME%
```
Crea una copia di backup della directory $APIGEECTL_HOME/ della versione 1.10. Ad esempio:
```
tar -czvf $APIGEECTL_HOME/../apigeectl-v1.10-backup.tar.gz $APIGEECTL_HOME
```
Esegui il backup del database Cassandra seguendo le istruzioni in Backup e ripristino di Cassandra.

Esegui l'upgrade della versione di Kubernetes

Controlla la versione della piattaforma Kubernetes e, se necessario, esegui l'upgrade della piattaforma Kubernetes a una versione supportata sia dall'ibrido 1.10 sia dall'ibrido 1.11. Se hai bisogno di assistenza, segui la documentazione della piattaforma.

Fai clic per espandere l'elenco delle piattaforme supportate

	Versioni ibride di Apigee
Piattaforme	1,8 ⁽³⁾	1,9 ⁽³⁾	1,1	1,11
Anthos (Google Cloud - GKE)	1,21.x ^{(≤ 1,8.3)} 1,22.x ^{(≤ 1,8.3)} 1,23,x ^{(≤ 1,8.4)} 1,24.x ^{{1,4.x 13}^{{1.4{/1,4{/1,4{/1,2x1,2{/1,4{/1,2x1,2x1,2{/1}}	1.23.x 1.24.x 1.25.x 1.26.x ^{(≥ 1.9.2)}	1.24.x 1.25.x 1.26.x	1.25.x 1.26.x 1.27.x
Anthos (AWS)	1.10.x 1.11.x 1.12.x 1.13.x 1,25⁽¹³⁾	1.12.x 1.13.x 1,25⁽¹³⁾	1,13.x 1,25⁽¹³⁾ 1,26⁽¹³⁾	1,14.x 1,25⁽¹³⁾ 1,26⁽¹³⁾
Anthos (Azure)	1.10.x 1.11.x 1.12.x 1.13.x 1.14.x	1.12.x 1.13.x 1.14.x	1.13.x 1.14.x 1.15.x	1.14.x 1.15.x 1.16.x
Anthos (on-premise - VMware) ⁽¹⁾ ⁽¹⁴⁾	1.10.x ⁽⁴⁾ 1.11.x ⁽⁴⁾ 1.12.x ⁽⁴⁾ ⁽⁵⁾ 1.13.x ⁽⁵⁾ 1.14.x {1,14.x	1.12.x ⁽⁴⁾ 1.13.x 1.14.x 1.15.x	1.13.x 1.14.x 1.15.x 1.16.x	1.14.x 1.15.x 1.16.x
Anthos (bare metal)⁽¹⁾	1.10.x ⁽⁴⁾ 1.11.x ⁽⁴⁾ 1.12.x ⁽⁴⁾ ⁽⁵⁾ 1.13.x ⁽⁵⁾ 1.14.x {1,14.x {1.x}	1.12.x ⁽⁴⁾ 1.13.x 1.14.x 1.15.x	1.13.x 1.14.x 1.15.x 1.16.x	1.14.x 1.15.x 1.16.x
EKS⁽⁷⁾	1,22.x ^{(≤ 1,8.3)} 1,23.x ^{(≤ 1,8.4)} 1.24.x ^{(≥ 1.8.4)} 1,25.x {15.x ^{1,25.x ^(4){/1	1.23.x 1.24.x 1.25.x 1.26.x ^{(≥ 1.9.2)}	1.24.x 1.25.x 1.26.x	1.25.x 1.26.x 1.27.x
AKS⁽⁷⁾	1,22.x ^{(≤ 1,8.3)} 1,23.x ^{(≤ 1,8.4)} 1.24.x ^{(≥ 1.8.4)} 1,25.x {15.x ^{1,25.x ^(4){/1	1.23.x 1.24.x 1.25.x 1.26.x ^{(≥ 1.9.2)}	1.24.x 1.25.x 1.26.x	1.25.x 1.26.x 1.27.x
OpenMaiusc⁽⁷⁾	4,8 4,9 4,10	4,10 4,11	4,11 4,12	4,12 4,13 4,14
Rancher Kubernetes Engine (RKE)⁽⁷⁾	N/A	1.3.8	v1.26.2+rke2r1	v1.26.2+rke2r1 v1.27.x
Componenti	1,8 ⁽³⁾	1,9 ⁽³⁾	1,1	1,11
Anthos Service Mesh (ASM)	1.11.x 1.12.x 1.13.x 1.14.x 1.15.x	1.17.x⁽¹¹⁾	1.17.x⁽¹¹⁾	1.18.x⁽¹¹⁾
JDK	11 LUG	11 LUG	11 LUG	11 LUG
cert-manager	1.7.x 1.8.x 1.9.x 1.10.x 1.11.x	1.10.x 1.11.x	1.10.x 1.11.x 1.12.x	1.11.x 1.12.x 1.13.x
Cassandra	3.11.9	3.11.9	3.11.9	3.11.9
⁽¹⁾ Su Anthos versioni 1.8, 1.9 e 1.10, segui le istruzioni in questi documenti per evitare conflitti con `cert-manager`: Anthos 1.8.2+: conflitto con `cert-manager` durante l'upgrade alla versione 1.8.2 o successive. Anthos 1.9: conflitto con `cert-manager` durante l'upgrade alla versione 1.9.0 o 1.9.1. Anthos 1.10 e versioni successive: installazione di `cert-manager` in conflitto. ⁽²⁾ Supporto disponibile con Apigee hybrid versione 1.7.2 e successive. ⁽³⁾ Sono state raggiunte le date di fine del ciclo di vita ufficiali per le versioni ibride di Apigee 1.9 e versioni precedenti. Le patch mensili regolari non sono più disponibili. Queste release non sono più supportate ufficialmente, fatta eccezione per i clienti con eccezioni esplicite e ufficiali per il supporto continuo. Gli altri clienti devono eseguire l'upgrade. ⁽⁴⁾Anthos su Bare Metal e VMWare versioni 1.12 e precedenti non sono supportate. Consulta le norme relative al supporto delle versioni di Anthos on Bare Metal e le Cluster Anthos su VMware VMware. ⁽⁵⁾Anthos su Bare Metal e VMWare richiede ASM 1.14 o versioni successive. Ti consigliamo di eseguire l'upgrade alla versione ibrida 1.8 e di passare al gateway in entrata Apigee, che non richiede più l'installazione di ASM sul cluster ibrido. ⁽⁶⁾ Supporto disponibile con Apigee hybrid versione 1.8.4 e successive. ⁽⁷⁾ I cluster collegati non sono obbligatori per Apigee hybrid v1.8 e successive utilizzando il ingressgateway Apigee.. ⁽⁸⁾ Non supportato con Apigee hybrid versione 1.8.4 e successive. ⁽⁹⁾ Supporto disponibile con Apigee hybrid versione 1.7.6 e successive. ⁽¹⁰⁾ Non supportato con Apigee hybrid versione 1.8.5 e successive. ⁽¹¹⁾ ASM viene installato automaticamente con Apigee hybrid 1.9 e versioni successive. Assistenza ⁽¹²⁾ disponibile con Apigee hybrid versione 1.9.2 e successive. ⁽¹³⁾ I numeri di versione dei cluster Anthos su AWS (multi-cloud) ora riflettono le versioni di Kubernetes. Consulta la pagina relativa al supporto per la versione e l'upgrade di Anthos per i dettagli delle versioni e le patch consigliate. ⁽¹⁴⁾ Vault non è certificato su Anthos (on-premise - VMware).

Informazioni sui cluster collegati

Per la versione ibrida di Apigee 1.7.x e precedenti, devi utilizzare i cluster collegati ad Anthos se vuoi eseguire Apigee hybrid in un contesto multi-cloud su Elastic Kubernetes Service (EKS), Azure Kubernetes Service (AKS) o un altro fornitore di servizi Kubernetes di terze parti supportato. Il collegamento al cluster consente a Google di misurare l'utilizzo di Anthos Service Mesh (ASM). La registrazione del cluster di terze parti è facoltativa. Registrati solo se vuoi visualizzare il cluster collegato nella Google Cloud Console. Per maggiori informazioni, consulta Collegare cluster Kubernetes di terze parti a Google Cloud.

Per Apigee versione ibrida 1.8.x, i cluster collegati ad Anthos sono richiesti se utilizzi Anthos Service Mesh per il gateway in entrata. Se utilizzi il gateway Ingress Apigee, i cluster collegati ad Anthos sono facoltativi.

installa il runtime ibrido 1.11.1

Helm

Preparati per l'upgrade dei grafici Helm

Esegui il pull dei grafici Helm di Apigee.

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

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

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

export CHART_REPO=oci://us-docker.pkg.dev/apigee-release/apigee-hybrid-helm-charts
export CHART_VERSION=1.11.1
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 cert-manager, se necessario.
Se devi eseguire l'upgrade della versione di cert-manager, installa la nuova versione con il seguente comando:
```
kubectl apply -f https://github.com/cert-manager/cert-manager/releases/download/v1.11.1/cert-manager.yaml
```

Installa i CRD Apigee aggiornati:

Nota: questo è l'unico metodo supportato per installare i CRD Apigee. Non utilizzare kubectl apply senza -k; non omettere --server-side.

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

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

Dopo la convalida con il comando di prova, esegui questo comando:

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

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

Controlla le etichette 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, mentre i pod di runtime vengono pianificati sui nodi con l'etichetta cloud.google.com/gke-nodepool=apigee-runtime. Puoi personalizzare le etichette dei pool di nodi nel file overrides.yaml.

Per maggiori informazioni, consulta Configurare pool di nodi dedicati.

Installa i grafici Helm ibridi di Apigee

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

In caso contrario, vai alla directory APIGEE_HELM_CHARTS_HOME. Esegui i seguenti comandi da quella directory.

Esegui l'upgrade dell'operatore/controller Apigee:

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

Prova:

helm upgrade operator apigee-operator/ \
  --install \
  --create-namespace \
  --namespace apigee-system \
  -f OVERRIDES_FILE \
  --dry-run

Esegui l'upgrade del grafico:

helm upgrade operator apigee-operator/ \
  --install \
  --create-namespace \
  --namespace apigee-system \
  -f OVERRIDES_FILE

Nota:per le installazioni migrate, utilizza:

helm upgrade operator apigee-operator/ \
  --install \
  --create-namespace \
  --namespace apigee-system \
  --force \
  -f OVERRIDES_FILE

Verifica l'installazione dell'operatore 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.11.1   1.11.1

Verifica che sia attivo e funzionante controllando 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

Esegui l'upgrade del datastore Apigee:

Prova:

helm upgrade datastore apigee-datastore/ \
  --install \
  --namespace apigee \
  -f OVERRIDES_FILE \
  --dry-run

Esegui l'upgrade del grafico:

helm upgrade datastore apigee-datastore/ \
  --install \
  --namespace apigee \
  -f OVERRIDES_FILE

Nota:per le installazioni migrate, utilizza:

helm upgrade datastore apigee-datastore/ \
  --install \
  --namespace apigee \
  --force \
  -f OVERRIDES_FILE

Verifica che apigeedatastore sia attivo e in esecuzione controllandone lo stato:

kubectl -n apigee get apigeedatastore default

NAME      STATE       AGE
default   running    2d

Esegui l'upgrade della telemetria di Apigee:

Prova:

helm upgrade telemetry apigee-telemetry/ \
  --install \
  --namespace apigee \
  -f OVERRIDES_FILE \
  --dry-run

Esegui l'upgrade del grafico:

helm upgrade telemetry apigee-telemetry/ \
  --install \
  --namespace apigee \
  -f OVERRIDES_FILE

Nota:per le installazioni migrate, utilizza:

helm upgrade telemetry apigee-telemetry/ \
  --install \
  --namespace apigee \
  --force \
  -f OVERRIDES_FILE

Verifica che sia attivo controllandone lo stato:

kubectl -n apigee get apigeetelemetry apigee-telemetry

NAME               STATE     AGE
apigee-telemetry   running   2d

Esegui l'upgrade di Apigee Redis:

Prova:

helm upgrade redis apigee-redis/ \
  --install \
  --namespace apigee \
  -f OVERRIDES_FILE \
  --dry-run

Esegui l'upgrade del grafico:

helm upgrade redis apigee-redis/ \
  --install \
  --namespace apigee \
  -f OVERRIDES_FILE

Nota:per le installazioni migrate, utilizza:

helm upgrade redis apigee-redis/ \
  --install \
  --namespace apigee \
  --force \
  -f OVERRIDES_FILE

Verifica che sia attivo controllandone lo stato:

kubectl -n apigee get apigeeredis default

NAME      STATE     AGE
default   running   2d

Esegui l'upgrade del gestore Ingress Apigee:

Prova:

helm upgrade ingress-manager apigee-ingress-manager/ \
  --install \
  --namespace apigee \
  -f OVERRIDES_FILE \
  --dry-run

Esegui l'upgrade del grafico:

helm upgrade ingress-manager apigee-ingress-manager/ \
  --install \
  --namespace apigee \
  -f OVERRIDES_FILE

Nota:per le installazioni migrate, utilizza:

helm upgrade ingress-manager apigee-ingress-manager/ \
  --install \
  --namespace apigee \
  --force \
  -f OVERRIDES_FILE

Verifica che sia attivo e funzionante controllando 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

Esegui l'upgrade dell'organizzazione Apigee:

Prova:

helm upgrade ORG_NAME apigee-org/ \
  --install \
  --namespace apigee \
  -f OVERRIDES_FILE \
  --dry-run

Esegui l'upgrade del grafico:

helm upgrade ORG_NAME apigee-org/ \
  --install \
  --namespace apigee \
  -f OVERRIDES_FILE

Nota:per le installazioni migrate, utilizza:

helm upgrade ORG_NAME apigee-org/ \
  --install \
  --namespace apigee \
  --force \
  -f OVERRIDES_FILE

Verifica che sia in esecuzione controllando lo stato della rispettiva organizzazione:

kubectl -n apigee get apigeeorg

NAME                      STATE     AGE
apigee-org1-xxxxx          running   2d

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

Prova:
```
helm upgrade ENV_RELEASE_NAME apigee-env/ \
  --install \
  --namespace apigee \
  --set env=ENV_NAME \
  -f OVERRIDES_FILE \
  --dry-run
```
- ENV_RELEASE_NAME è il nome con cui hai precedentemente installato il grafico apigee-env. Nella versione ibrida 1.10, di solito è apigee-env-ENV_NAME. Nella versione ibrida 1.11 e successive, in genere è ENV_NAME.
- ENV_NAME è il nome dell'ambiente di cui stai eseguendo l'upgrade.
- OVERRIDES_FILE è il nuovo file di override per la versione 1.11.1
Esegui l'upgrade del grafico:
```
helm upgrade ENV_RELEASE_NAME apigee-env/ \
  --install \
  --namespace apigee \
  --set env=ENV_NAME \
  -f OVERRIDES_FILE
```
Nota:per le installazioni migrate, utilizza:
```
helm upgrade ENV_RELEASE_NAME apigee-env/ \
  --install \
  --namespace apigee \
  --set env=ENV_NAME \
  --force \
  -f OVERRIDES_FILE
```
Verifica che sia attivo e in esecuzione controllando lo stato dell'ambiente corrispondente:
```
kubectl -n apigee get apigeeenv
```
```
NAME                          STATE       AGE   GATEWAYTYPE
apigee-org1-dev-xxx            running     2d
```
Esegui l'upgrade dei gruppi di ambienti (virtualhosts).
1. Devi eseguire l'upgrade di un gruppo di ambienti (virtualhost) alla volta. Specifica il gruppo di ambienti con --set envgroup=ENV_GROUP_NAME. Ripeti i seguenti comandi per ogni gruppo env menzionato nel file override.yaml:
  Prova:
```
helm upgrade ENV_GROUP_RELEASE_NAME apigee-virtualhost/ \
  --install \
  --namespace apigee \
  --set envgroup=ENV_GROUP_NAME \
  -f OVERRIDES_FILE \
  --dry-run
```
  ENV_GROUP_RELEASE_NAME è il nome con cui hai precedentemente installato il grafico apigee-virtualhost. Nella versione ibrida 1.10, di solito è apigee-virtualhost-ENV_GROUP_NAME. Nella versione ibrida 1.11 e successive, di solito è ENV_GROUP_NAME.
  
  Esegui l'upgrade del grafico:
```
helm upgrade ENV_GROUP_RELEASE_NAME apigee-virtualhost/ \
  --install \
  --namespace apigee \
  --set envgroup=ENV_GROUP_NAME \
  -f OVERRIDES_FILE
```
  Nota:per le installazioni migrate, utilizza:
```
helm upgrade ENV_GROUP_RELEASE_NAME apigee-virtualhost/ \
  --install \
  --namespace apigee \
  --set envgroup=ENV_GROUP_NAME \
  --force \
  -f OVERRIDES_FILE
```
  Nota: ENV_GROUP_NAME deve essere univoco all'interno dello spazio dei nomi apigee. Ad esempio, se hai un envgroup e un envgroup prod, devi impostare questo nome su prod-envgroup. Il nome del gruppo di ambienti successivi deve ancora essere prod.
2. Controlla lo stato di ApigeeRoute (AR).
  L'installazione di virtualhosts crea ApigeeRouteConfig (ARC), che crea internamente ApigeeRoute (AR) dopo che il watcher Apigee estrae i dettagli relativi al gruppo env dal piano di controllo. Verifica quindi che lo stato dell'AR corrispondente 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
```

`apigeectl`

Archivia il numero di versione più recente in una variabile utilizzando questo comando:

Linux

export VERSION=$(curl -s \
  https://storage.googleapis.com/apigee-release/hybrid/apigee-hybrid-setup/current-version.txt?ignoreCache=1)

Mac OS

export VERSION=$(curl -s \
  https://storage.googleapis.com/apigee-release/hybrid/apigee-hybrid-setup/current-version.txt)

Windows

for /f "tokens=*" %a in ('curl -s ^
  https://storage.googleapis.com/apigee-release/hybrid/apigee-hybrid-setup/current-version.txt') ^
do set VERSION=%a

Verifica che la variabile sia stata compilata con un numero di versione utilizzando il seguente comando. Se vuoi utilizzare una versione diversa, puoi salvarla in una variabile di ambiente.
```
echo $VERSION
```
Dovresti visualizzare l'ultima versione ibrida di Apigee:
```
  1.11.1
```
Assicurati di essere nella directory di base ibrida (la directory padre della directory in cui si trova il file eseguibile apigeectl):
```
cd $APIGEECTL_HOME/..
```

Scarica il pacchetto di release per il tuo sistema operativo utilizzando il seguente comando. Assicurati di selezionare la tua piattaforma nella seguente tabella:

Linux

Linux a 64 bit:

curl -LO \
  https://storage.googleapis.com/apigee-release/hybrid/apigee-hybrid-setup/$VERSION/apigeectl_linux_64.tar.gz

Mac OS

Mac 64 bit:

curl -LO \
  https://storage.googleapis.com/apigee-release/hybrid/apigee-hybrid-setup/$VERSION/apigeectl_mac_64.tar.gz

Windows

Windows a 64 bit:

curl -LO ^
  https://storage.googleapis.com/apigee-release/hybrid/apigee-hybrid-setup/%VERSION%/apigeectl_windows_64.zip

Rinomina la directory apigeectl/ attuale in un nome di directory di backup. Ad esempio:

Linux

mv $APIGEECTL_HOME/ $APIGEECTL_HOME-v1.10/

Mac OS

mv $APIGEECTL_HOME/ $APIGEECTL_HOME-v1.10/

Windows

rename %APIGEECTL_HOME% %APIGEECTL_HOME%-v1.10

Estrai il contenuto del file gzip scaricato nella directory base ibrida. La directory di base ibrida è la directory in cui si trova la directory apigeectl-v1.10 rinominata:
Linux
```
tar xvzf filename.tar.gz -C ./
```
Mac OS
```
tar xvzf filename.tar.gz -C ./
```
Windows
```
tar xvzf filename.zip -C ./
```
I contenuti tar vengono, per impostazione predefinita, espansi in una directory che contiene la versione e la piattaforma nel nome. Ad esempio: ./apigeectl_1.11.1-xxxxxxx_linux_64. Rinomina la directory in apigeectl utilizzando il seguente comando:
Linux
```
mv apigeectl_1.11.1-xxxxxxx_linux_64 apigeectl
```
Mac OS
```
mv apigeectl_1.11.1-xxxxxxx_mac_64 apigeectl
```
Windows
```
rename apigeectl_1.11.1-xxxxxxx_windows_64 apigeectl
```
Passa alla directory apigeectl:
```
cd ./apigeectl
```
Questa è la home directory apigeectl. È qui che si trova il comando eseguibile apigeectl.
Queste istruzioni utilizzano la variabile di ambiente $APIGEECTL_HOME per la directory nel file system in cui è installata l'utilità apigeectl. Se necessario, cambia directory nella directory apigeectl e definisci la variabile con il seguente comando:
Linux
```
export APIGEECTL_HOME=$PWD
```
```
echo $APIGEECTL_HOME
```
Mac OS
```
export APIGEECTL_HOME=$PWD
```
```
echo $APIGEECTL_HOME
```
Windows
```
set APIGEECTL_HOME=%CD%
```
```
echo %APIGEECTL_HOME%
```
Verifica la versione di apigeectl con il comando version:
```
./apigeectl version
```
```
Version: 1.11.1
```
Crea una directory hybrid-base-directory/hybrid-files e quindi spostala al suo interno. La directory hybrid-files è la posizione dei file di configurazione, come il file di override, i certificati e gli account di servizio. Ad esempio:
Linux
```
mkdir $APIGEECTL_HOME/../hybrid-files
```
```
cd $APIGEECTL_HOME/../hybrid-files
```
Mac OS
```
mkdir $APIGEECTL_HOME/../hybrid-files
```
```
cd $APIGEECTL_HOME/../hybrid-files
```
Windows
```
mkdir %APIGEECTL_HOME%/../hybrid-files
```
```
cd %APIGEECTL_HOME%/../hybrid-files
```
Verifica che kubectl sia impostato sul contesto corretto utilizzando il seguente comando. Il contesto attuale deve essere impostato sul cluster in cui stai eseguendo l'upgrade di Apigee hybrid.
```
kubectl config get-contexts | grep \*
```
Nella directory hybrid-files:
1. Aggiorna i seguenti link simbolici a $APIGEECTL_HOME. Questi link ti consentono di eseguire il comando apigeectl appena installato dall'interno della directory hybrid-files:
```
ln -nfs $APIGEECTL_HOME/tools tools
ln -nfs $APIGEECTL_HOME/config config
ln -nfs $APIGEECTL_HOME/templates templates
ln -nfs $APIGEECTL_HOME/plugins plugins
```
2. Per verificare che i link simbolici siano stati creati correttamente, esegui il comando seguente e assicurati che i percorsi dei link rimandino alle posizioni corrette:
```
ls -l | grep ^l
```
Esegui un'inizializzazione di prova per verificare la presenza di errori:
```
${APIGEECTL_HOME}/apigeectl init -f OVERRIDES_FILE --dry-run=client
```
Dove OVERRIDES_FILE è il nome del file di override, ad esempio ./overrides/overrides.yaml.

Suggerimento: puoi sostituire OVERRIDES_FILE nell'esempio di codice riportato sopra con il nome e il percorso del file di override. In questo modo tutte le istanze su questa pagina verranno sostituite.
Se non sono presenti errori, inizializza l'ibrido 1.11.1:
```
$APIGEECTL_HOME/apigeectl init -f OVERRIDES_FILE
```
Nota: apigeectl installa e configura il gateway in entrata Apigee quando esegui apigeectl init.
Controlla lo stato di inizializzazione:
```
$APIGEECTL_HOME/apigeectl check-ready -f OVERRIDES_FILE
```
Se l'operazione riesce, l'output dice: All containers ready.
```
kubectl describe apigeeds -n apigee
```
Cerca State: running nell'output.
Verifica la presenza di errori con una prova del comando apply utilizzando il flag --dry-run:
```
$APIGEECTL_HOME/apigeectl apply -f OVERRIDES_FILE --dry-run=client
```
Se non sono presenti errori, applica gli override. Seleziona e segui le istruzioni per gli ambienti di produzione o non di produzione, a seconda dell'installazione.
Produzione

Per gli ambienti di produzione, esegui l'upgrade di ogni componente ibrido singolarmente e controlla lo stato del componente sottoposto ad upgrade prima di passare al componente successivo.
1. Assicurati di essere nella directory hybrid-files.
2. Applica gli override per eseguire l'upgrade di Cassandra:
```
$APIGEECTL_HOME/apigeectl apply -f OVERRIDES_FILE --datastore
```
3. Completamento del controllo:
```
$APIGEECTL_HOME/apigeectl check-ready -f OVERRIDES_FILE
```
  Suggerimento:se il valore check-ready non va a buon fine, puoi ottenere ulteriori informazioni sui tuoi pod con:
  kubectl -n NAMESPACE get pods
  
  Dove NAMESPACE è lo spazio dei nomi ibrido di Apigee.
  Procedi al passaggio successivo solo quando i pod sono pronti.
4. Applica gli override per eseguire l'upgrade dei componenti di telemetria e controlla il completamento:
```
$APIGEECTL_HOME/apigeectl apply -f OVERRIDES_FILE --telemetry
```
```
$APIGEECTL_HOME/apigeectl check-ready -f OVERRIDES_FILE
```
5. Visualizza i componenti Redis:
```
$APIGEECTL_HOME/apigeectl apply -f OVERRIDES_FILE --redis
```
6. Applica gli override per eseguire l'upgrade dei componenti a livello di organizzazione (MART, Watcher e Apigee Connect) e verifica il completamento:
```
$APIGEECTL_HOME/apigeectl apply -f OVERRIDES_FILE --org
```
```
$APIGEECTL_HOME/apigeectl check-ready -f OVERRIDES_FILE
```
7. Applica gli override per eseguire l'upgrade dei tuoi ambienti. Hai due possibilità:
  - Ambiente per ambiente: applica gli override a un ambiente alla volta e verifica il completamento. Ripeti questo passaggio per ogni ambiente:
    $APIGEECTL_HOME/apigeectl apply -f OVERRIDES_FILE --env ENV_NAME
    
    $APIGEECTL_HOME/apigeectl check-ready -f OVERRIDES_FILE
    
    Dove ENV_NAME è il nome dell'ambiente di cui stai eseguendo l'upgrade.
  - Tutti gli ambienti contemporaneamente: applica gli override a tutti gli ambienti contemporaneamente e verifica il completamento:
    $APIGEECTL_HOME/apigeectl apply -f OVERRIDES_FILE --all-envs
    
    $APIGEECTL_HOME/apigeectl check-ready -f OVERRIDES_FILE
8. Applica gli override per eseguire l'upgrade dei componenti virtualhosts e controlla il completamento:
```
$APIGEECTL_HOME/apigeectl apply -f OVERRIDES_FILE --settings virtualhosts
```
```
$APIGEECTL_HOME/apigeectl check-ready -f OVERRIDES_FILE
```
Non di produzione

Nella maggior parte degli ambienti non di produzione, demo o sperimentali, puoi applicare gli override a tutti i componenti contemporaneamente. Se il tuo ambiente non di produzione è di grandi dimensioni e complesso o riproduce da vicino un ambiente di produzione, puoi utilizzare le istruzioni per eseguire l'upgrade degli ambienti di produzione.
1. Assicurati di essere nella directory hybrid-files.
2. ```
$APIGEECTL_HOME/apigeectl apply -f OVERRIDES_FILE
```
3. Controlla lo stato:
```
$APIGEECTL_HOME/apigeectl check-ready -f OVERRIDES_FILE
```

Installazione di `1.11.1-hotfix.1`

Utilizza i seguenti comandi per installare la release di aggiornamento rapido, 1.11.1-hotfix.1. Per ulteriori informazioni, consulta ibrid 1.11.1-hotfix.1 nelle note di rilascio di Apigee.

Apri il file di override.
Innanzitutto, aggiorna il file di override. Segui le istruzioni appropriate per lo strumento che stai utilizzando per gestire Apigee hybrid, Helm o apigeectl:
Helm
1. Nella stanza istiod, cambia la versione del tag immagine (se presente) in versione 1.17.8. Ad esempio:
```
istiod:
  image:
    url: "gcr.io/apigee-release/hybrid/apigee-asm-istiod"
    tag: "1.17.8-asm.20-distroless"
```
2. Nella stanza apigeeIngressGateway, cambia la versione del tag immagine (se presente) in versione 1.17.8. Ad esempio:
```
apigeeIngressGateway:
  image:
    url: "gcr.io/apigee-release/hybrid/apigee-asm-ingress"
    tag: "1.17.8-asm.20-distroless"
```
3. Salva il file.
apigeectl
1. Nella stanza istiod, cambia la versione del tag immagine (se presente) in versione 1.17.8. Ad esempio:
```
istiod:
  image:
    url: "gcr.io/apigee-release/hybrid/apigee-asm-istiod"
    tag: "1.17.8-asm.20-distroless"
```
2. A seconda di come hai scelto di installare Apigee hybrid, potresti avere una stanza ingressGateway o ingressGateways. Individua la stanza visualizzata nel file di override e modifica la versione del tag immagine (se presente) in versione 1.17.8. Ad esempio, se hai una stanza ingressGateway:
```
ingressGateway:
  image:
    url: "gcr.io/apigee-release/hybrid/apigee-asm-ingress"
    tag: "1.17.8-asm.20-distroless"
```
  oppure, se hai una ingressGateways stanza:
```
ingressGateways:
  - name: gateway1
    image:
      url: "gcr.io/apigee-release/hybrid/apigee-asm-ingress"
      tag: "1.17.8-asm.20-distroless"
    ...
  - name: gateway2
    image:
      url: "gcr.io/apigee-release/hybrid/apigee-asm-ingress"
      tag: "1.17.8-asm.20-distroless"
    ... 
```
3. Salva il file.

Quindi, applica le modifiche. Segui le istruzioni appropriate per lo strumento che stai utilizzando per gestire Apigee hybrid, Helm o apigeectl:

Helm

Installa il grafico apigee-ingress-manager con il seguente comando:

helm upgrade ingress-manager apigee-ingress-manager/ \
  --install \
  --namespace "YOUR_APIGEE_NAMESPACE" \
  --atomic \
  -f OVERRIDES_FILE

Installa il grafico apigee-org con il seguente comando:

helm upgrade ORG_NAME apigee-org/ \
    --install \
    --namespace "YOUR_APIGEE_NAMESPACE" \
    --atomic \
    -f OVERRIDES_FILE

Verifica lo stato dei pod:

kubectl get pods -n YOUR_APIGEE_NAMESPACE

`apigeectl`

Esegui questo comando per inizializzare il componente istiod:

$APIGEECTL_HOME/apigeectl init -f OVERRIDES_FILE

$APIGEECTL_HOME/apigeectl check-ready -f OVERRIDES_FILE

Esegui questo comando per applicare le modifiche ai componenti Apigee Ingress. Se disponi di più organizzazioni, ripeti questo comando per ognuna:
```
$APIGEECTL_HOME/apigeectl apply --org -f OVERRIDES_FILE
```
```
$APIGEECTL_HOME/apigeectl check-ready -f OVERRIDES_FILE
```

Verifica lo stato dei pod:

kubectl get pods -n YOUR_APIGEE_NAMESPACE

Rollback di un upgrade

Per eseguire il rollback di un upgrade precedente, segui questi passaggi:

Helm

Per eseguire il rollback alla versione precedente, utilizza i grafici dei grafici e il file di override dell'installazione precedente.

Crea la seguente variabile di ambiente:
- PREVIOUS_HELM_CHARTS_HOME: la directory in cui sono installati i precedenti grafici Helm ibridi di Apigee. Questa è la versione a cui stai eseguendo il rollback.
Esegui il rollback dei virtualhost. Ripeti il comando seguente per ciascun gruppo di ambienti menzionato nel file di override.
```
helm upgrade ENV_GROUP_RELEASE_NAME $PREVIOUS_HELM_CHARTS_HOME/apigee-virtualhost/ \
  --namespace apigee \
  --atomic \
  --set envgroup=ENV_GROUP_NAME \
  -f PREVIOUS_OVERRIDES_FILE
```
ENV_GROUP_RELEASE_NAME è il nome con cui hai precedentemente installato il grafico apigee-virtualhost. Nella versione ibrida 1.10, di solito è apigee-virtualhost-ENV_GROUP_NAME. Nella versione ibrida 1.11 e successive, di solito è ENV_GROUP_NAME.
Esegui il rollback degli envs. Ripeti il comando seguente per ogni ambiente menzionato nel file di override.
```
helm upgrade apigee-env-ENV_NAME $PREVIOUS_HELM_CHARTS_HOME/apigee-env/ \
  --install \
  --namespace apigee \
  --atomic \
  --set env=ENV_NAME \
  -f PREVIOUS_OVERRIDES_FILE
```
ENV_RELEASE_NAME è il nome con cui hai precedentemente installato il grafico apigee-env. Nella versione ibrida 1.10, di solito è apigee-env-ENV_NAME. Nella versione ibrida 1.11 e successive, di solito è ENV_NAME.

Esegui il rollback dell'organizzazione:

helm upgrade ORG_NAME $PREVIOUS_HELM_CHARTS_HOME/apigee-org/ \
  --install \
  --namespace apigee \
  --atomic \
  -f PREVIOUS_OVERRIDES_FILE

Esegui il rollback di Ingress Manager:

helm upgrade ingress-manager $PREVIOUS_HELM_CHARTS_HOME/apigee-ingress-manager/ \
  --install \
  --namespace apigee \
  --atomic \
  -f PREVIOUS_OVERRIDES_FILE

Esegui il rollback di Redis:

helm upgrade redis $PREVIOUS_HELM_CHARTS_HOME/apigee-redis/ \
  --install \
  --namespace apigee \
  --atomic \
  -f PREVIOUS_OVERRIDES_FILE

Esegui il rollback della telemetria di Apigee:

helm upgrade telemetry $PREVIOUS_HELM_CHARTS_HOME/apigee-telemetry/ \
  --install \
  --namespace apigee \
  --atomic \
  -f PREVIOUS_OVERRIDES_FILE

Esegui il rollback di Apigee Datastore (il componente di database Cassandra):

helm upgrade datastore $PREVIOUS_HELM_CHARTS_HOME/apigee-datastore/ \
  --install \
  --namespace apigee \
  --atomic \
  -f PREVIOUS_OVERRIDES_FILE

Esegui il rollback del controller Apigee:

helm upgrade operator $PREVIOUS_HELM_CHARTS_HOME/apigee-operator/ \
  --install \
  --namespace apigee-system \
  --atomic \
  -f PREVIOUS_OVERRIDES_FILE

Esegui il rollback dei CRD ibridi Apigee:

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

`apigeectl`

Esegui la pulizia dei job completati per lo spazio dei nomi del runtime ibrido, dove NAMESPACE è lo spazio dei nomi specificato nel file di override, se hai specificato uno spazio dei nomi. In caso contrario, lo spazio dei nomi predefinito è apigee:
```
kubectl delete job -n NAMESPACE \
  $(kubectl get job -n NAMESPACE \
  -o=jsonpath='{.items[?(@.status.succeeded==1)].metadata.name}')
```

Pulisci i job completati per lo spazio dei nomi apigee-system:

kubectl delete job -n apigee-system \
  $(kubectl get job -n apigee-system \
  -o=jsonpath='{.items[?(@.status.succeeded==1)].metadata.name}')

Modifica la variabile APIGEECTL_HOME in modo che punti alla directory che contiene la versione precedente di apigeectl. Ad esempio:
```
export APIGEECTL_HOME=PATH_TO_PREVIOUS_APIGEECTL_DIRECTORY
```
Esegui i comandi indicati nella directory radice dell'installazione di cui vuoi eseguire il rollback. Assicurati di utilizzare il file di override originale per la versione a cui vuoi eseguire il rollback:
1. Nella directory dei file ibridi, esegui apigeectl apply:
```
$APIGEECTL_HOME/apigeectl apply -f ORIGINAL_OVERRIDES_FILE
```
  Dove ORIGINAL_OVERRIDES_FILE è il percorso e il nome file relativi del file di override per l'installazione ibrida della versione precedente, ad esempio ./overrides/overrides1.10.yaml.
2. Controlla lo stato dei pod:
```
kubectl -n NAMESPACE get pods
```
  Dove NAMESPACE è lo spazio dei nomi ibrido di Apigee.
3. Controlla lo stato di apigeeds:
```
kubectl describe apigeeds -n apigee
```
  L'output dovrebbe essere simile al seguente:
```
Status:
  Cassandra Data Replication:
  Cassandra Pod Ips:
    10.8.2.204
  Cassandra Ready Replicas:  1
  Components:
    Cassandra:
      Last Successfully Released Version:
        Revision:  v1-f8aa9a82b9f69613
        Version:   v1
      Replicas:
        Available:  1
        Ready:      1
        Total:      1
        Updated:    1
      State:        running
  Scaling:
    In Progress:         false
    Operation:
    Requested Replicas:  0
  State:                 running
```
  Procedi al passaggio successivo solo quando il pod apigeeds è in esecuzione.
4. Esegui questo comando per prendere nota dei valori del conteggio delle nuove repliche per il processore di messaggi dopo l'upgrade. Se questi valori non corrispondono a quelli che hai impostato in precedenza, modifica i valori nel file di override in modo che corrispondano alla configurazione precedente.
```
apigeectl apply -f ORIGINAL_OVERRIDES_FILE --dry-run=client --print-yaml --env ENV_NAME 2>/dev/null |grep "runtime:" -A 25 -B 1| grep "autoScaler" -A 2
```
  L'output dovrebbe essere simile al seguente:
```
      autoScaler:
        minReplicas: 2
        maxReplicas: 10
```
5. Esecuzione apigeectl init:
```
$APIGEECTL_HOME/apigeectl init -f ORIGINAL_OVERRIDES_FILE
```

Upgrade di Apigee hybrid alla versione 1.11

Panoramica dell'upgrade alla versione 1.11.1

Prerequisiti

Grafici Helm e apigeectl

Migrazione alla versione 1.11 con Helm dalla versione 1.10 con apigeectl

Preparati per l'upgrade alla versione 1.11

Esegui il backup dell'installazione ibrida (opzione consigliata)

Helm

Linux

Mac OS

Windows

Produzione

Non di produzione

apigeectl

Linux

Mac OS

Windows

Esegui l'upgrade della versione di Kubernetes

Fai clic per espandere l'elenco delle piattaforme supportate

Piattaforme

Componenti

Informazioni sui cluster collegati

installa il runtime ibrido 1.11.1

Helm

Preparati per l'upgrade dei grafici Helm

Installa i grafici Helm ibridi di Apigee

apigeectl

Linux

Mac OS

Windows

Linux

Mac OS

Windows

Linux

Mac OS

Windows

Linux

Mac OS

Windows

Linux

Mac OS

Windows

Linux

Mac OS

Windows

Linux

Mac OS

Windows

Produzione

Non di produzione

Installazione di 1.11.1-hotfix.1

Helm

apigeectl

Helm

apigeectl

Rollback di un upgrade

Helm

apigeectl

Grafici Helm e `apigeectl`

Migrazione alla versione 1.11 con Helm dalla versione 1.10 con `apigeectl`

`apigeectl`

`apigeectl`

Installazione di `1.11.1-hotfix.1`

`apigeectl`

`apigeectl`

`apigeectl`