Questa pagina è stata tradotta dall'API Cloud Translation.

Eseguire l'upgrade di Apigee hybrid alla versione 1.11

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

Utilizza le stesse procedure per gli upgrade della versione secondaria (ad esempio versione 1.10 alla versione 1.11) e per gli upgrade delle release delle patch (ad esempio da 1.11.0 a 1.11.2).

Se esegui l'upgrade da Apigee hybrid 1.9 o versioni precedenti, devi prima eseguire l'upgrade alla versione ibrida 1.10 prima di eseguire l'upgrade alla versione 1.11.2. Consulta le istruzioni per l'upgrade di Apigee Hybrid alla versione 1.10.

Panoramica dell'aggiornamento alla versione 1.11.2

L'upgrade alla versione 1.11 di Apigee hybrid potrebbe richiedere il tempo di riposo.

Con l'upgrade del controller Apigee alla versione 1.11.2, tutte le istanze vengono sottoposti a un riavvio in sequenza. Per ridurre al minimo i tempi di inattività negli ambienti ibridi di produzione durante un riavvio graduale, assicurati di eseguire almeno due cluster (nella stessa regione/nel medesimo data center o in regioni/data center diversi). Deviare tutto il traffico di produzione su un singolo cluster e mettere offline il cluster di cui vuoi eseguire l'upgrade, quindi procedere con la procedura di upgrade. Ripeti il processo per ogni cluster.

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

Il backup e il ripristino di Cassandra non possono funzionare con versioni miste. Ad esempio, un backup da Hybrid 1.10 non può essere utilizzato per ripristinare un'istanza Hybrid 1.11.
Lo streaming di dati Cassandra non funzionerà tra versioni ibride miste. Di conseguenza, i tuoi cluster Cassandra non possono essere scalati orizzontalmente.
L'espansione e il ritiro delle regioni saranno interessati, in quanto queste operazioni dipendono dall'analisi in streaming dei dati Cassandra.

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

Preparati all'upgrade.
Installa il runtime di hybrid versione 1.11.2.

Prerequisiti

Queste istruzioni per l'upgrade presuppongono che tu abbia installato la versione 1.10.x di Apigee hybrid e voglia eseguirne l'upgrade alla versione 1.11.2. Se esegui 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 Apigee hybrid con i 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 ambiente ibrido Installazione della versione 1.10 gestita con apigeectl:

Innanzitutto, esegui la migrazione di Helm dell'installazione v1.10 seguendo il istruzioni in Eseguire la migrazione dei grafici Apigee da apigeectl a Helm da apigeectl.
Segui le istruzioni per i grafici Helm riportate di seguito per eseguire l'upgrade della tua installazione.
Nota: quando esegui l'upgrade di un'installazione migrata, devi inserire un flag --force nei comandi helm upgrade.

Prepara 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 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 della versione 1.10 $APIGEE_HELM_CHARTS_HOME/. 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 tuo database Cassandra seguendo le istruzioni in Backup e ripristino di Cassandra.

Se utilizzi file di certificati di servizio (.json) nelle tue override per autenticare gli account di servizio, assicurati che i file di certificati degli account di servizio si trovino nella directory del grafico Helm corretta. I grafici Helm non possono leggere i file esterni a ciascuna directory del grafico.

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

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

Produzione

Service account	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 ciascuno dei seguenti directory:

Service account	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 i file del certificato e della chiave TLS (.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. La tua 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 tuo database Cassandra seguendo le istruzioni in Backup e ripristino di Cassandra.

Esegui l'upgrade della versione di Kubernetes

Controlla la versione della tua piattaforma Kubernetes e, se necessario, esegui l'upgrade della piattaforma Kubernetes a un supportata sia dalla versione ibrida 1.10 che da quella ibrida 1/11 Se hai bisogno di assistenza, segui la documentazione della piattaforma.

Fai clic per espandere un elenco delle piattaforme supportate

	1,10 ⁽³⁾	1,11	1,12
GKE su Google Cloud	1.24.x 1.25.x 1.26.x 1.27.x^{(≥ 1.10.5)} 1.28.x^{(≥ 1.10.5)}	1.25.x 1.26.x 1.27.x 1.28.x^{(≥ 1.11.2)} 1.29.x^{(≥ 1.11.2)}	1,26,x 1,27,x 1,28,x 1.29.x^{(≥ 1.12.1)}
GKE su AWS	1.13.x (K8s v1.24.x) 1.14.x (K8s v1.25.x) 1.26.x⁽¹²⁾ 1.27.x^{(≥ 1.10.5)} 1.28.x^{(≥ 1.10.5)}	1.14.x (K8s v1.25.x) 1.26.x⁽¹²⁾ 1.27.x 1.28.x^{(≥ 1.11.2)} 1.29.x^{(≥ 1.11.2)}	1.26.x⁽¹²⁾ 1.27.x 1.28.x 1.29.x^{(≥ 1.12.1)}
GKE su Azure	1.13.x 1.14.x 1.26.x⁽¹²⁾ 1.27.x^{(≥ 1.10.5)} 1.28.x^{(≥ 1.10.5)}	1.14.x 1.26.x⁽¹²⁾ 1.27.x 1.28.x^{(≥ 1.11.2)} 1.29.x^{(≥ 1.11.2)}	1,26 x⁽¹²⁾ 1,27,x 1,28,x 1.29.x^{(≥ 1.12.1)}
Google Distributed Cloud (solo software) su VMware ⁽¹⁾ ⁽¹³⁾	1.13.x 1.14.x 1.15.x (K8s v1.26.x) 1.16.x (K8s v1.27.x) 1.27.x^{(≥ 1.10.5)} 1.28.x^{(≥ 1.10.5)}	1,14,x 1.15.x (K8s v1.26.x) 1.16.x (K8s v1.27.x) 1.28.x^{(≥ 1.11.2)} 1.29.x^{(≥ 1.11.2)}	1.15.x (K8s v1.26.x) 1.16.x (K8s v1.27.x) 1,28,x⁽¹²⁾ 1,29.x^{(≥ 1.12.1)}
Google Distributed Cloud (solo software) su bare metal ⁽¹⁾	1.13.x 1.14.x (K8s v1.25.x) 1.15.x (K8s v1.26.x) 1.16.x (K8s v1.27.x) 1.27.x⁽¹²⁾^{(≥ 1.10.5)} 1.28.x^{(≥ 1.10.5)}	1.14.x 1.15.x (K8s v1.26.x) 1.16.x (K8s v1.27.x) 1.28.x⁽¹²⁾^{(≥ 1.11.2)} 1.29.x^{(≥ 1.11.2)}	1.15.x (K8s v1.26.x) 1.16.x (K8s v1.27.x) 1,28,x⁽¹²⁾ 1,29.x^{(≥ 1.12.1)}
EKS⁽⁷⁾	1.24.x 1.25.x 1.26.x 1.27.x^{(≥ 1.10.5)} 1.28.x^{(≥ 1.10.5)}	1,25,x 1,26,x 1,27,x 1.28.x^{(≥ 1.11.2)} 1.29.x^{(≥ 1.11.2)}	1,26,x 1,27,x 1,28,x 1.29.x^{(≥ 1.12.1)}
AKS⁽⁷⁾	1,24,x 1,25,x 1,26,x 1.27.x^{(≥ 1.10.5)} 1.28.x^{(≥ 1.10.5)}	1.25.x 1.26.x 1.27.x 1.28.x^{(≥ 1.11.2)} 1.29.x^{(≥ 1.11.2)}	1.26.x 1.27.x 1.28.x 1.29.x^{(≥ 1.12.1)}
ApriMaiusc⁽⁷⁾	4,11 4,12 4,14^{(≥ 1,10,5)} 4,15^{(≥ 1.10.5)}	4.12 4.13 4.14 4.15^{(≥ 1.11.2)} 4.16^{(≥ 1.11.2)}	4,12 4,13 4,14 4,15 4,16^{(≥ 1.12.1)}
Rancher Kubernetes Engine (RKE)	v1.26.2+rke2r1 1.27.x^{(≥ 1.10.5)} 1.28.x^{(≥ 1.10.5)}	v1.26.2+rke2r1 v1.27.x 1.28.x^{(≥ 1.11.2)} 1.29.x^{(≥ 1.11.2)}	v1.26.2+rke2r1 v1.27.x 1,28,x 1.29.x^{(≥ 1.12.1)}
VMware Tanzu	N/D	N/D	v1.26.x
Componenti	1,10	1,11	1,12
Anthos Service Mesh	1,17.x⁽¹⁰⁾	1.18.x⁽¹⁰⁾	1,19 x⁽¹⁰⁾
JDK	JDK 11	JDK 11	JDK 11
gestore-certificati	1,10,x 1,11,x 1,12,x	1.11.x 1.12.x 1.13.x	1.11.x 1.12.x 1.13.x
Cassandra	3.11	3.11	4.0
Kubernetes	1,24,x 1,25,x 1,26,x	1.25.x 1.26.x 1.27.x	1,26,x 1,27,x 1,28,x
kubectl			1.27.x 1.28.x 1.29.x
Helm	3,10 e oltre	3,10 e oltre	3.14.2 e versioni successive
Driver CSI Secret Store		1.3.4	1.4.1
Vault		1,13,x	1.15.2
⁽¹⁾ Su Anthos on-premise (Google Distributed Cloud) versione 1.13, segui queste istruzioni per evitare conflitti con `cert-manager`: Conflitto tra installazione di cert-manager ⁽²⁾ Assistenza disponibile con Apigee hybrid versione 1.7.2 e successive. ⁽³⁾ Le date ufficiali di ritiro delle versioni 1.10 e precedenti di Apigee Hybrid sono state raggiunte. Le regolari patch mensili non sono più disponibili. Queste release non sono più ufficialmente supportate, ad eccezione dei clienti con eccezioni esplicite e ufficiali per il supporto continuo. Gli altri clienti devono eseguire l'upgrade. ⁽⁴⁾Le versioni 1.12 e precedenti di Anthos on-premise (Google Distributed Cloud) non sono più supportate. Consulta i Criteri di supporto delle versioni di Distributed Cloud on bare metal e l'elenco delle versioni supportate di Distributed Cloud on VMware. ⁽⁵⁾Google Distributed Cloud on bare metal o VMware richiede Anthos Service Mesh 1.14 o versioni successive. Ti consigliamo di eseguire l'upgrade alla versione ibrida 1.8 e di passare al gateway di ingresso Apigee, che non richiede più l'installazione di Anthos Service Mesh nel cluster ibrido. ⁽⁶⁾ Assistenza disponibile con Apigee ibrida versione 1.8.4 e successive. ⁽⁷⁾ Non supportato con Apigee hybrid versione 1.8.4 e successive. ⁽⁸⁾ Assistenza disponibile con Apigee ibrido versione 1.7.6 e successive. ⁽⁹⁾ Non supportato con Apigee ibrido versione 1.8.5 e successive. ⁽¹⁰⁾ Anthos Service Mesh 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 di GKE su AWS ora rispecchiano le versioni di Kubernetes. Consulta la versione di GKE Enterprise e l'assistenza per l'upgrade per i dettagli sulle versioni e le patch consigliate. ⁽¹³⁾ Vault non è certificato su Google Distributed Cloud per VMware. ⁽¹⁴⁾ Assistenza disponibile con Apigee hybrid versione 1.10.5 e successive. ⁽¹⁵⁾ Assistenza disponibile con Apigee hybrid versione 1.11.2 e successive. ⁽¹⁶⁾ Assistenza disponibile con Apigee hybrid versione 1.12.1 e successive.

Informazioni sui cluster collegati

Per le versioni di Apigee hybrid 1.7.x e precedenti, devi utilizzare cluster collegati a GKE 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. L'attacco al cluster consente a Google di misurare l'utilizzo di Anthos Service Mesh.

Per la versione ibrida di Apigee 1.8.x, sono necessari i cluster collegati a GKE se utilizzi Anthos Service Mesh per il gateway di ingresso. Se utilizzi il gateway di ingresso Apigee, i cluster collegati sono facoltativi.

Installa il runtime ibrido 1.11.2

Helm

Prepararsi per l'upgrade dei grafici Helm

Apporta la seguente modifica al file overrides.yaml per attivare i grafici apigee-operator e apigee-env per utilizzare il tag corretto (1.11.2-hotfix.2):
```
ao:
  image:
    url: "gcr.io/apigee-release/hybrid/apigee-operators"
    tag: "1.11.2-hotfix.2"
runtime:
  image:
    url: "gcr.io/apigee-release/hybrid/apigee-runtime"
    tag: "1.11.2-hotfix.2"
```
Consulta le note di rilascio di Apigee 1.11.2-hotfix.2.

Eseguire il pull dei grafici Apigee Helm.

I grafici ibridi 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 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.11.2
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 di 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 simulata kubectl eseguendo il seguente comando:

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

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

Convalida l'installazione con il comando kubectl get crds:

kubectl get crds | grep apigee

Dovresti vedere un output 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 e i pod di runtime vengono pianificati sui nodi con l'etichetta cloud.google.com/gke-nodepool=apigee-runtime. Puoi personalizza le etichette del pool di nodi nel file overrides.yaml.

Per ulteriori informazioni, vedi Configurazione di pool di nodi dedicati.

Installa i grafici Helm di Apigee hybrid

Nota: prima di eseguire qualsiasi comando di upgrade/installazione di Helm, usa la funzionalità di prova di Helm aggiungendo --dry-run alla fine il comando. Consulta helm -h per un 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 di Apigee Operator/Controller:

Nota: questo passaggio richiede autorizzazioni elevate per il cluster. 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

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.2   1.11.2

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

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

Verifica che apigeedatastore sia attivo e funzionante controllandone lo stato:

kubectl -n apigee get apigeedatastore default

NAME      STATE       AGE
default   running    2d

Esegui l'upgrade della telemetria 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

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

Verifica che sia attivo e funzionante controllandone lo stato:

kubectl -n apigee get apigeeredis default

NAME      STATE     AGE
default   running   2d

Esegui l'upgrade del gestore in entrata 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

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

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

Verifica che sia attivo 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 installato in precedenza il grafico apigee-env. In Hybrid v1.10, in genere è apigee-env-ENV_NAME. In Hybrid versione 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 delle sostituzioni per la versione 1.11.2
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 funzionante controllando lo stato del rispettivo ambiente:
```
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 quanto segue per ciascun 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 installato in precedenza la Grafico apigee-virtualhost. Nella versione ibrida v1.10, di solito viene apigee-virtualhost-ENV_GROUP_NAME. In Hybrid versione 1.11 e successive, solitamente è 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_RELEASE_NAME deve essere univoco all'interno del spazio dei nomi apigee.
  Ad esempio, se hai un ambiente denominato prod e un gruppo di ambienti denominato prod, imposta il valore di ENV_GROUP_RELEASE_NAME su un valore univoco, ad esempio prod-envgroup.
2. Controlla lo stato di ApigeeRoute (AR).
  Installazione di virtualhosts crea ApigeeRouteConfig (ARC), che crea internamente ApigeeRoute (AR) dopo che l'osservatore Apigee ha eseguito il pull del gruppo env correlato i dettagli dal piano di controllo. Pertanto, verifica 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
```

`apigeectl`

Memorizza il numero della versione più recente in una variabile utilizzando il seguente 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

Controlla che la variabile sia stata compilata con un numero di versione utilizzando il seguente comando. Se Se vuoi usare una versione diversa, puoi salvarla in una variabile di ambiente.
```
echo $VERSION
```
Dovresti vedere la versione ibrida di Apigee più recente:
```
  1.11.2
```
Assicurati di essere nella directory di base ibrida (la directory principale in cui si trova il file eseguibile apigeectl):
```
cd $APIGEECTL_HOME/..
```

Scarica il pacchetto della 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 a 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 con il nome della 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 i contenuti del file gzip scaricato nella directory di 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 ./
```
Per impostazione predefinita, i contenuti tar vengono espansi in una directory con la versione e la piattaforma in il nome. Ad esempio: ./apigeectl_1.11.2-xxxxxxx_linux_64. Rinomina la directory a apigeectl utilizzando il seguente comando:
Linux
```
mv apigeectl_1.11.2-xxxxxxx_linux_64 apigeectl
```
Mac OS
```
mv apigeectl_1.11.2-xxxxxxx_mac_64 apigeectl
```
Windows
```
rename apigeectl_1.11.2-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.2
```
Crea una directory hybrid-base-directory/hybrid-files, quindi spostati al suo interno. La directory hybrid-filesè il luogo in cui si trovano i file di configurazione, come il file delle sostituzioni, 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 seguente comando e assicurati che i percorsi dei link rimandino alle posizioni corrette:
```
ls -l | grep ^l
```

Apporta la seguente modifica al file overrides.yaml per consentire all'operatore e al runtime di utilizzare il tag corretto (1.11.2-hotfix.2):

ao:
  image:
    url: "gcr.io/apigee-release/hybrid/apigee-operators"
    tag: "1.11.2-hotfix.2"
runtime:
  image:
    url: "gcr.io/apigee-release/hybrid/apigee-runtime"
    tag: "1.11.2-hotfix.2"

Vedi le note di rilascio di Apigee 1.11.2-hotfix.2.

Esegui un'inizializzazione dry run 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 nel codice esempio riportato sopra con il nome e il percorso del file degli override e di ogni istanza in questa pagina verrà sostituito.
Se non ci sono errori, inizializzare ibrido 1.11.2:
```
$APIGEECTL_HOME/apigeectl init -f OVERRIDES_FILE
```
Nota: apigeectl installazioni e configurazioni Gateway in entrata Apigee quando esegui apigeectl init.
Controlla lo stato dell'inizializzazione:
```
$APIGEECTL_HOME/apigeectl check-ready -f OVERRIDES_FILE
```
Se l'esito è positivo, l'output dice: All containers ready.
```
kubectl describe apigeeds -n apigee
```
Nell'output, cerca State: running.
Verifica la presenza di errori con una prova simulata del comando apply utilizzando il flag --dry-run:
```
$APIGEECTL_HOME/apigeectl apply -f OVERRIDES_FILE --dry-run=client
```
Se non sono presenti errori, applica le sostituzioni. Seleziona e segui le istruzioni per gli ambienti di produzione oppure ambienti non di produzione, a seconda dell'installazione.
Produzione

Per gli ambienti di produzione, eseguire l'upgrade di ogni componente ibrido individualmente, e controlla lo stato del componente di cui è stato eseguito l'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. Verifica di completamento:
  $APIGEECTL_HOME/apigeectl check-ready -f OVERRIDES_FILE
  Suggerimento: se check-ready non funziona, puoi ricevere più informazioni sui tuoi pod con:
  kubectl -n NAMESPACE get pods
  
  dove NAMESPACE è il tuo spazio dei nomi Apigee hybrid.
  Procedi al passaggio successivo solo quando i pod sono pronti.
4. Applica le sostituzioni 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. Avvia i componenti Redis:
  $APIGEECTL_HOME/apigeectl apply -f OVERRIDES_FILE --redis
6. Applica le sostituzioni per eseguire l'upgrade dei componenti a livello di organizzazione (MART, Watcher e Apigee Connect) e controlla 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 degli ambienti. Hai a disposizione due opzioni:
  - Per ambiente: applica le sostituzioni a un ambiente alla volta e controlla 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 verificare il completamento:
  $APIGEECTL_HOME/apigeectl apply -f OVERRIDES_FILE --settings virtualhosts
  $APIGEECTL_HOME/apigeectl check-ready -f OVERRIDES_FILE
Non prod

Nella maggior parte degli ambienti di produzione, demo o sperimentali, puoi applicare le sostituzioni a tutti i componenti contemporaneamente. Se il tuo ambiente non di produzione è di grandi dimensioni e complesso o se rispecchia molto da vicino un ambiente di produzione, ti consigliamo di utilizzare le istruzioni per 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

Rollback di un upgrade in corso...

Per eseguire il rollback di un upgrade precedente:

Helm

Per tornare alla versione precedente, utilizza i grafici e il file degli override dal dell'installazione precedente.

Crea la seguente variabile di ambiente:
- PREVIOUS_HELM_CHARTS_HOME: la directory in cui si trovava la versione ibrida di Apigee precedente I grafici Helm sono installati. Questa è la versione a cui esegui il rollback.
Esegui il rollback dei virtualhost. Ripeti il comando seguente per ogni gruppo di ambienti menzionati nel file degli 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 installato in precedenza il grafico apigee-virtualhost. Nella versione ibrida v1.10, di solito viene apigee-virtualhost-ENV_GROUP_NAME. In Hybrid versione 1.11 e successive, solitamente è ENV_GROUP_NAME.
Esegui il rollback degli ambienti. Ripeti il comando seguente per ciascun ambiente menzionato nel file degli 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 installato in precedenza la Grafico apigee-env. In Hybrid v1.10, in genere è apigee-env-ENV_NAME. In Hybrid versione 1.11 e successive, solitamente è 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 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 di Apigee Controller:

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

Esegui il rollback dei CRD ibridi di Apigee:

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

`apigeectl`

Ripulisci i job completati per lo spazio dei nomi dell'ambiente di runtime ibrido, dove NAMESPACE è lo spazio dei nomi specificato nel file delle sostituzioni, se ne hai specificato uno. 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}')
```

Esegui la pulizia dei 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 seguenti 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:

Nella directory hybrid-files, esegui apigeectl apply:
```
$APIGEECTL_HOME/apigeectl apply -f ORIGINAL_OVERRIDES_FILE
```
dove ORIGINAL_OVERRIDES_FILE è il percorso e il nome del file delle sostituzioni per l'installazione ibrida della versione precedente, ad esempio ./overrides/overrides1.10.yaml.
Controlla lo stato dei tuoi pod:
```
kubectl -n NAMESPACE get pods
```
Dove NAMESPACE è il tuo spazio dei nomi ibrido Apigee.

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

Vai al passaggio successivo solo quando il pod apigeeds è in esecuzione.

Esegui il seguente comando per annotare i valori del nuovo conteggio delle repliche per il gestore dei messaggi dopo l'upgrade. Se questi valori non corrispondono a quelli impostati in precedenza, modifica i valori nel file delle sostituzioni 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 avere il seguente aspetto:
```
      autoScaler:
        minReplicas: 2
        maxReplicas: 10
```

Corsa di apigeectl init:

$APIGEECTL_HOME/apigeectl init -f ORIGINAL_OVERRIDES_FILE

Eseguire l'upgrade di Apigee hybrid alla versione 1.11

Panoramica dell'aggiornamento alla versione 1.11.2

Prerequisiti

Grafici Helm e apigeectl

Migrazione alla versione 1.11 con Helm dalla versione 1.10 con apigeectl

Prepara 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 un elenco delle piattaforme supportate

Componenti

Informazioni sui cluster collegati

Installa il runtime ibrido 1.11.2

Helm

Prepararsi per l'upgrade dei grafici Helm

Installa i grafici Helm di Apigee hybrid

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 prod

Rollback di un upgrade in corso...

Helm

apigeectl

Grafici Helm e `apigeectl`

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

`apigeectl`

`apigeectl`

`apigeectl`