Upgrade di Apigee hybrid alla versione 1.16

Questa procedura riguarda l'upgrade da Apigee hybrid versione 1.15.x ad Apigee hybrid versione 1.16.11 e dalle versioni precedenti di hybrid 1.16.x alla versione 1.16.11.

Utilizza le stesse procedure per gli upgrade delle versioni secondarie (ad esempio dalla versione 1.15 alla 1.16) e per gli upgrade delle release patch (ad esempio dalla versione 1.16.0 alla 1.16.11).

Se esegui l'upgrade dalla versione 1.14 o precedente di Apigee hybrid, devi prima eseguire l'upgrade alla versione 1.15 prima di eseguire l'upgrade alla versione 1.16.11. Consulta le istruzioni per eseguire l'upgrade di Apigee hybrid alla versione 1.15.

Modifiche rispetto ad Apigee hybrid v1.15

Tieni presente le seguenti modifiche:

  • Profili Seccomp: A partire dalla versione 1.16, Apigee hybrid offre ora la possibilità di applicare profili Seccomp ai componenti di runtime, migliorando significativamente il livello di sicurezza del deployment. Questa funzionalità consente agli amministratori e ai team di sicurezza di Apigee di limitare le chiamate di sistema che un processo in container può effettuare al kernel dell'host. Limitando un container solo alle syscall necessarie, puoi:
    • Migliorare la sicurezza: ridurre il rischio di container breakout ed escalation dei privilegi.
    • Applica il principio del privilegio minimo: assicurati che i componenti abbiano accesso solo alle chiamate di sistema esatte richieste per il loro funzionamento.
    • Soddisfano i requisiti di conformità: forniscono un controllo fondamentale per soddisfare i requisiti di conformità di sicurezza più rigorosi.
    Per saperne di più, consulta Configura i profili Seccomp per la sicurezza dei pod.
  • Rimozione di UDCA in Apigee hybrid: nella versione 1.16 di Apigee hybrid, il componente Unified Data Collection Agent (UDCA) è stato rimosso. Le responsabilità di invio dei dati di analisi, tracciamento e stato del deployment al control plane Apigee vengono ora gestite utilizzando una pipeline di dati basata su Google Cloud Pub/Sub. L'utilizzo della pipeline di dati basata su Pub/Sub è il meccanismo di raccolta dei dati predefinito dalla versione 1.14.0 di Apigee hybrid.
  • Service account apigee-guardrails: Nella versione 1.16.0, Apigee Hybrid introduce un account di servizio Google IAM apigee-guardrails. Questo viene utilizzato dal grafico apigee-operator durante l'installazione per verificare che tutte le API necessarie siano abilitate nel tuo progetto.

    Vedi:

  • Supporto per cert-manager versione 1.18 e 1.19: Apigee hybrid v1.16 supporta cert-manager versione 1.18 e versione 1.19. Nella release 1.18 di cert-manager, è stata apportata una modifica al valore predefinito di Certificate.Spec.PrivateKey.rotationPolicy che può influire sul traffico. Se stai eseguendo l'upgrade da una versione precedente di Apigee hybrid e stai eseguendo l'upgrade alla versione 1.18 o successive di cert-manager, segui la procedura di upgrade di cert-manager in questa guida.

Per ulteriori informazioni sulle funzionalità della versione 1.16 di Hybrid, consulta le note di rilascio di Apigee hybrid v1.16.11.

Prerequisiti

Prima di eseguire l'upgrade alla versione 1.16 di Hybrid, assicurati che la tua installazione soddisfi i seguenti requisiti:

Prima di eseguire l'upgrade alla versione 1.16.11: limitazioni e note importanti

  • Apigee hybrid 1.16.11 introduce un nuovo limite di proxy per ambiente migliorato che consente di eseguire il deployment di più proxy e flussi condivisi in un singolo ambiente. Consulta Limiti: proxy API per comprendere i limiti relativi al numero di proxy e flussi condivisi di cui puoi eseguire il deployment per ambiente. Questa funzionalità è disponibile solo per le organizzazioni ibride appena create e non può essere applicata alle organizzazioni di cui è stato eseguito l'upgrade. Per utilizzare questa funzionalità, esegui una nuova installazione della versione 1.16.11 di Hybrid e crea una nuova organizzazione.

    Questa funzionalità è disponibile esclusivamente nell'ambito del piano di abbonamento 2024 ed è soggetta ai diritti concessi nell'ambito di questo abbonamento. Per saperne di più su questa funzionalità, consulta Limiti dei proxy per ambiente migliorati.

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

    Quando esegui l'upgrade del controller Apigee alla versione 1.16.11, tutti i deployment Apigee vengono riavviati 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/data center o in regioni/data center diversi). Devia tutto il traffico di produzione a un singolo cluster e 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 dopo l'inizio dell'upgrade per ridurre le probabilità di impatto sulla produzione. Non esiste un limite di tempo entro il quale eseguire l'upgrade di tutti i cluster rimanenti dopo l'upgrade del primo. Tuttavia, finché non viene eseguito l'upgrade di tutti i cluster rimanenti, il backup e il ripristino di Cassandra non possono funzionare con versioni miste. Ad esempio, un backup di Hybrid 1.15 non può essere utilizzato per ripristinare un'istanza di Hybrid 1.16.

  • Le modifiche al piano di gestione non devono essere completamente sospese durante un upgrade. Eventuali sospensioni temporanee richieste alle modifiche del piano di gestione sono indicate nelle istruzioni di upgrade riportate di seguito.

Panoramica dell'upgrade alla versione 1.16.11

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

  1. Preparati all'upgrade.
  2. Installa la versione 1.16.11 del runtime hybrid.

Preparati all'upgrade alla versione 1.16

Esegui il backup dell'installazione ibrida

  1. 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, passa a 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%
  2. Crea una copia di backup della directory $APIGEE_HELM_CHARTS_HOME/ della versione 1.15. 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.15-backup.tar.gz $APIGEE_HELM_CHARTS_HOME
  3. Esegui il backup del database Cassandra seguendo le istruzioni riportate in Backup e ripristino di Cassandra.
  4. Assicurati che i file di chiave e certificato TLS (.crt, .key e/o .pem) si trovino nella directory $APIGEE_HELM_CHARTS_HOME/apigee-virtualhost/.

Esegui l'upgrade della versione di Kubernetes

Controlla la versione della tua piattaforma Kubernetes e, se necessario, esegui l'upgrade a una versione supportata sia dalla versione 1.15 che dalla versione 1.16 di Hybrid. Se hai bisogno di aiuto, consulta la documentazione della tua piattaforma.

Estrai i grafici Helm di Apigee.

I grafici di Apigee Hybrid 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 nello 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.16.11
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

Modifica kustomization.yaml per uno spazio dei nomi Apigee personalizzato

Se il tuo spazio dei nomi Apigee non è apigee, modifica il file apigee-operator/etc/crds/default/kustomization.yaml e sostituisci il valore namespace con il tuo spazio dei nomi Apigee.

apiVersion: kustomize.config.k8s.io/v1beta1
kind: Kustomization

namespace: APIGEE_NAMESPACE

Se utilizzi apigee come spazio dei nomi, non devi modificare il file.

  • Installa le CRD Apigee aggiornate:

    1. Utilizza la funzionalità dry run di 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 questo 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                    2024-08-21T14:48:30Z
apigeedeployments.apigee.cloud.google.com                   2024-08-21T14:48:30Z
apigeeenvironments.apigee.cloud.google.com                  2024-08-21T14:48:31Z
apigeeissues.apigee.cloud.google.com                        2024-08-21T14:48:31Z
apigeeorganizations.apigee.cloud.google.com                 2024-08-21T14:48:32Z
apigeeredis.apigee.cloud.google.com                         2024-08-21T14:48:33Z
apigeerouteconfigs.apigee.cloud.google.com                  2024-08-21T14:48:33Z
apigeeroutes.apigee.cloud.google.com                        2024-08-21T14:48:33Z
apigeetelemetries.apigee.cloud.google.com                   2024-08-21T14:48:34Z
cassandradatareplications.apigee.cloud.google.com           2024-08-21T14: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 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 saperne di più, consulta Configurazione dei pool di nodi dedicati.

    • Configurare il account di servizio apigee-guardrails

    A partire dalla versione 1.16 di Hybrid, il account di servizio apigee-guardrails è necessario per eseguire l'upgrade del grafico apigee-operator.

    Nella procedura seguente, seleziona il tipo di autenticazione del account di servizio che stai utilizzando.

    1. Verifica di poter eseguire create-service-account. Se hai appena scaricato i grafici, il file create-service-account potrebbe non essere in modalità eseguibile. Nella directory APIGEE_HELM_CHARTS_HOME, esegui questo comando: 
      ./apigee-operator/etc/tools/create-service-account --help

      Se l'output è permission denied, devi rendere eseguibile il file, ad esempio con chmod in Linux, MacOS o UNIX o in Esplora risorse di Windows o con il comando icacls in Windows. Ad esempio: 

      chmod +x ./apigee-operator/etc/tools/create-service-account
    2. Crea il account di servizio apigee-guardrails:

      Secret Kubernetes

      ./apigee-operator/etc/tools/create-service-account \
  --env prod \
  --profile apigee-guardrails \
  --dir service-accounts

      Questo comando crea il account di servizio apigee-guardrails e scarica la chiave nella directory service-accounts/.

      File JSON

      ./apigee-operator/etc/tools/create-service-account \
  --env prod \
  --profile apigee-guardrails \
  --dir ./apigee-operator/

      Questo comando crea il account di servizio apigee-guardrails e scarica la chiave nella directory del grafico apigee-operator/.

      Vault

      ./apigee-operator/etc/tools/create-service-account \
  --env prod \
  --profile apigee-guardrails \
  --dir service-accounts

      Questo comando crea il account di servizio apigee-guardrails e scarica la chiave nella directory service-accounts/.

      WIF per GKE

      ./apigee-operator/etc/tools/create-service-account \
  --env prod \
  --profile apigee-guardrails \
  --dir service-accounts

      Questo comando crea il account di servizio apigee-guardrails e scarica la chiave nella directory apigee-operator/etc/tools/service-accounts/. Il file di chiave scaricato non è necessario e può essere eliminato.

      WIF su altre piattaforme

      ./apigee-operator/etc/tools/create-service-account \
  --env prod \
  --profile apigee-guardrails \
  --dir service-accounts

      Questo comando crea il account di servizio apigee-guardrails e scarica la chiave nella directory service-accounts/.
    3. Configura l'autenticazione per il account di servizio apigee-guardrails:

      Secret Kubernetes

      Crea il secret Kubernetes utilizzando il file della chiave del account di servizio apigee-guardrails nella directory service-accounts/:

      kubectl create secret generic apigee-guardrails-svc-account \
    --from-file="client_secret.json=$APIGEE_HELM_CHARTS_HOME/service-accounts/$PROJECT_ID-apigee-guardrails.json" \
    -n $APIGEE_NAMESPACE

      Aggiungi quanto segue al tuo file overrides.yaml:

      guardrails:
  serviceAccountRef: apigee-guardrails-svc-account

      File JSON

      Aggiungi quanto segue al file overrides.yaml, utilizzando il percorso del file della chiave del account di servizio apigee-guardrails nella directory apigee-operator/:

      guardrails:
  serviceAccountPath: $PROJECT_ID-apigee-guardrails.json

      Vault

      1. Aggiorna il secret Vault secret/data/apigee/orgsakeys per aggiungere una voce guardrails con i contenuti del file della chiave del account di servizio apigee-guardrails. 
        vault kv patch secret/apigee/orgsakeys guardrails="$(cat ./service-accounts/hybrid115-apigee-guardrails.json)"
      2. Il account di servizio Kubernetes (KSA) per i guardrail è denominato apigee-operator-guardrails-sa. Aggiungi il KSA di Guardrails agli account di servizio specifici dell'organizzazione associati al ruolo apigee-orgsakeys in Vault.
        1. Recupera l'elenco attuale delle associazioni KSA: 
          vault read auth/kubernetes/role/apigee-orgsakeys

          L'output deve avere il seguente formato:

          Key                                         Value
---                                         -----
alias_name_source                           serviceaccount_uid
bound_service_account_names                 BOUND_SERVICE_ACCOUNT_NAMES
bound_service_account_namespace_selector    n/a
bound_service_account_namespaces            APIGEE_NAMESPACE

          Nell'output, BOUND_SERVICE_ACCOUNT_NAMES è un elenco di nomi di account di servizio separati da virgole. Aggiungi apigee-operator-guardrails-sa all'elenco dei nomi, ad esempio (senza i ritorni a capo aggiunti per leggibilità):

          apigee-manager,apigee-cassandra-default,apigee-cassandra-backup-sa,
apigee-cassandra-restore-sa,apigee-cassandra-schema-setup-myhybrido
rg-5b044c1,apigee-cassandra-schema-val-myhybridorg-5b044c1,apigee-c
assandra-user-setup-myhybridorg-5b044c1,apigee-mart-myhybridorg-5b0
44c1,apigee-mint-task-scheduler-myhybridorg-5b044c1,apigee-connect-
agent-myhybridorg-5b044c1,apigee-watcher-myhybridorg-5b044c1,apigee
-metrics-apigee-telemetry,apigee-open-telemetry,apigee-synchronizer
-myhybridorg-dev-ee52aca,apigee-runtime-telemetry-collector-apigee-
telemetry,apigee-logger-apigee-e-myhybrridorg-dev-ee52aca,apigee-sy
nchronizer-myhybridog-prod-2d0221c,apigee-runtime-myhybridorg-prod-
2d0221c,apigee-operator-guardrails-sa
        2. Aggiorna le associazioni al ruolo apigee-orgsakeys con l'elenco aggiornato dei nomi dei account di servizio: 
          vault write auth/kubernetes/role/apigee-orgsakeys \
  bound_service_account_names=UPDATED_BOUND_SERVICE_ACCOUNT_NAMES \
  bound_service_account_namespaces=APIGEE_NAMESPACE \
  policies=apigee-orgsakeys-auth \
  ttl=1m
      3. Aggiungi "guardrail" a SecretProviderClass
        1. Modifica il file spc-org.yaml.
        2. In spec.parameters.objects, aggiungi una voce guardrails: 
                - objectName: "guardrails"
        secretPath: ""
        secretKey: ""
        3. Aggiorna il tuo SecretProviderClass: 
          kubectl -n APIGEE_NAMESPACE apply -f spc-org.yaml

      WIF per GKE

      Il account di servizio Kubernetes (KSA) per i guardrail è denominato apigee-operator-guardrails-sa. Crea l'associazione per il account di servizio Google (GSA) apigee-guardrails con il seguente comando:

      gcloud iam service-accounts add-iam-policy-binding apigee-guardrails@$PROJECT_ID.iam.gserviceaccount.com \
    --role roles/iam.workloadIdentityUser \
    --member "serviceAccount:$PROJECT_ID.svc.id.goog[$APIGEE_NAMESPACE/apigee-operator-guardrails-sa]" \
    --project $PROJECT_ID

      Aggiungi quanto segue al tuo file overrides.yaml:

      guardrails:
  gsa: apigee-guardrails@$PROJECT_ID.iam.gserviceaccount.com

      WIF su altre piattaforme

      Il account di servizio Kubernetes (KSA) per i guardrail è denominato apigee-operator-guardrails-sa. Devi concedere al service account Kubernetes (KSA) di Guardrails l'accesso per simulare l'identità del account di servizio Google (GSA) apigee-guardrails e configurare gli override per utilizzare un file di configurazione delle credenziali.

      1. Concedi al KSA l'accesso per simulare l'identità del GSA con il seguente comando:

        Modello

        gcloud iam service-accounts add-iam-policy-binding \
  apigee-guardrails@$PROJECT_ID.iam.gserviceaccount.com \
  --member="principal://iam.googleapis.com/projects/PROJECT_NUMBER/locations/global/workloadIdentityPools/POOL_ID/subject/system:serviceaccount:APIGEE_NAMESPACE:apigee-operator-guardrails-sa" \
  --role=roles/iam.workloadIdentityUser

        Esempio

        gcloud iam service-accounts add-iam-policy-binding \
  apigee-guardrails@my-project.iam.gserviceaccount.com \
  --member="principal://iam.googleapis.com/projects/1234567890/locations/global/workloadIdentityPools/my-pool/subject/system:serviceaccount:apigee:apigee-operator-guardrails-sa" \
  --role=roles/iam.workloadIdentityUser

        Dove:

        • PROJECT_ID: l'ID del tuo progetto Google Cloud.
        • PROJECT_NUMBER: il numero di progetto in cui hai creato il pool di identità del workload.
        • POOL_ID: l'ID del pool di identità del workload.
        • APIGEE_NAMESPACE: lo spazio dei nomi in cui è installato Apigee hybrid.
      2. Crea un file di configurazione delle credenziali per il account di servizio apigee-guardrails: 
        gcloud iam workload-identity-pools create-cred-config \
  projects/PROJECT_NUMBER/locations/global/workloadIdentityPools/POOL_ID/providers/WORKLOAD_PROVIDER_ID \
  --service-account=apigee-guardrails@$PROJECT_ID.iam.gserviceaccount.com \
  --credential-source-file=/var/run/service-account/token \
  --credential-source-type=text \
  --output-file=apigee-guardrails-credential-configuration.json

        dove WORKLOAD_PROVIDER_ID è l'ID del provider di pool di identità del workload.

      3. Configura apigee-guardrails per utilizzare la federazione delle identità per i workload con uno dei seguenti metodi:

        WIF: secrets

        1. Crea un nuovo secret di Kubernetes utilizzando il file di origine delle credenziali per ogni file di configurazione delle credenziali. 
          kubectl create secret -n APIGEE_NAMESPACE generic guardrails-workload-identity-secret --from-file="client_secret.json=./apigee-guardrails-credential-configuration.json"
        2. Sostituisci il valore di serviceAccountRef con il nuovo secret: 
          guardrails:
  serviceAccountRef: guardrails-workload-identity-secret

        WIF: file

        Sposta il file apigee-guardrails-credential-configuration.json generato nella directory del grafico apigee-operator/.

        Aggiungi quanto segue al tuo file overrides.yaml:

        guardrails:
  serviceAccountPath: apigee-guardrails-credential-configuration.json

        WIF: Vault

        Aggiorna la chiave del account di servizio per guardrails in Vault con il file di origine delle credenziali corrispondente: 

        SAKEY=$(cat .apigee-guardrails-credential-configuration.json); kubectl -n APIGEE_NAMESPACE exec vault-0 -- vault kv patch secret/apigee/orgsakeys guardrails="$SAKEY"

        Per saperne di più, consulta Storing service account keys in Hashicorp Vault.

    Esegui l'upgrade di cert-manager

    Apigee hybrid v1.16 supporta le versioni di cert-manager dalla 1.16 alla 1.19. In cert-manager 1.18 è stata apportata una modifica che può causare un problema con il traffico. Nella versione 1.18 di cert-manager, il valore predefinito di Certificate.Spec.PrivateKey.rotationPolicy è stato modificato da Never a Always. Per le installazioni di Apigee hybrid aggiornate, questo può causare un problema con il traffico. Quando esegui l'upgrade alla versione 1.16 di Hybrid da una versione precedente, devi modificare il certificato apigee-ca per compensare questa modifica o mantenere la versione di cert-manager alla release 1.17.x o precedente.

    Prima di eseguire l'upgrade di cert-manager alla versione 1.18 o 1.19, segui questa procedura per modificare il certificato apigee-ca e impostare il valore di Certificate.Spec.PrivateKey.rotationPolicy su Never.

    1. Controlla i contenuti del certificato apigee-ca per verificare se rotationPolicy è impostato: 
      kubectl get certificate apigee-ca -n cert-manager -o yaml

      Cerca i valori in spec.privateKey nell'output:

      ...
spec:
  commonName: apigee-hybrid
  duration: 87600h
  isCA: true
  issuerRef:
    group: cert-manager.io
    kind: ClusterIssuer
    name: apigee-root-certificate-issuer
  privateKey:
    algorithm: ECDSA
    # Note: rotationPolicy would appear here if it is set.
    size: 256
  secretName: apigee-ca
...
    2. Se rotationPolicy non è impostato o se è impostato su Always, modifica il certificato apigee-ca per impostare il valore di rotationPolicy su Never:
      1. Esegui prima un dry run: 
        kubectl patch Certificate \
  --dry-run=server \
  -n cert-manager \
  --type=json \
  -p='[{"op": "replace", "path": "/spec/privateKey/rotationPolicy", "value": "Never"}]' \
  -o=yaml \
  apigee-ca
      2. Applica la patch al certificato: 
        kubectl patch Certificate \
  -n cert-manager \
  --type=json \
  -p='[{"op": "replace", "path": "/spec/privateKey/rotationPolicy", "value": "Never"}]' \
  -o=yaml \
  apigee-ca
    3. Verifica che il valore di rotationPolicy sia ora impostato su Never: 
      kubectl get certificate apigee-ca -n cert-manager -o yaml

      L'output dovrebbe essere simile al seguente:

      ...
spec:
  commonName: apigee-hybrid
  duration: 87600h
  isCA: true
  issuerRef:
    group: cert-manager.io
    kind: ClusterIssuer
    name: apigee-root-certificate-issuer
  privateKey:
    algorithm: ECDSA
    rotationPolicy: Never
    size: 256
  secretName: apigee-ca
...
    4. Esegui l'upgrade di cert-manager. Il comando seguente scaricherà e installerà cert-manager v1.19.2: 
      kubectl apply -f https://github.com/cert-manager/cert-manager/releases/download/v1.19.2/cert-manager.yaml

      Per un elenco delle versioni supportate, consulta Piattaforme e versioni supportate: cert-manager.

    Vedi:

    Installa il runtime ibrido 1.16.11

    1. In caso contrario, vai alla directory APIGEE_HELM_CHARTS_HOME. Esegui i seguenti comandi da quella directory.
    2. Esegui l'upgrade dell'operatore/controller Apigee:

      Dry run:

      helm upgrade operator apigee-operator/ \
  --install \
  --namespace APIGEE_NAMESPACE \
  -f OVERRIDES_FILE \
  --dry-run=server

      Esegui l'upgrade del grafico:

      helm upgrade operator apigee-operator/ \
  --install \
  --namespace APIGEE_NAMESPACE \
  -f OVERRIDES_FILE

      Verifica l'installazione dell'operatore Apigee:

      helm ls -n APIGEE_NAMESPACE

      NAME       NAMESPACE       REVISION   UPDATED                                STATUS     CHART                   APP VERSION
operator   apigee   3          2024-08-21 00:42:44.492009 -0800 PST   deployed   apigee-operator-1.16.11   1.16.11

      Verifica che sia attivo e funzionante controllandone la disponibilità:

      kubectl -n APIGEE_NAMESPACE get deploy apigee-controller-manager

      NAME                        READY   UP-TO-DATE   AVAILABLE   AGE
apigee-controller-manager   1/1     1            1           7d20h
    3. Esegui l'upgrade del datastore Apigee:

      Dry run:

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

      Esegui l'upgrade del grafico:

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

      Verifica che apigeedatastore sia attivo e funzionante controllandone lo stato:

      kubectl -n APIGEE_NAMESPACE get apigeedatastore default

      NAME      STATE       AGE
default   running    2d
    4. Esegui l'upgrade della telemetria di Apigee:

      Dry run:

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

      Esegui l'upgrade del grafico:

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

      Verifica che sia attivo e funzionante controllandone lo stato:

      kubectl -n APIGEE_NAMESPACE get apigeetelemetry apigee-telemetry

      NAME               STATE     AGE
apigee-telemetry   running   2d
    5. Esegui l'upgrade di Apigee Redis:

      Dry run:

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

      Esegui l'upgrade del grafico:

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

      Verifica che sia attivo e funzionante controllandone lo stato:

      kubectl -n APIGEE_NAMESPACE get apigeeredis default

      NAME      STATE     AGE
default   running   2d
    6. Esegui l'upgrade di Apigee Ingress Manager:

      Dry run:

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

      Esegui l'upgrade del grafico:

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

      Verifica che sia attivo e funzionante controllando la sua disponibilità:

      kubectl -n APIGEE_NAMESPACE get deployment apigee-ingressgateway-manager

      NAME                            READY   UP-TO-DATE   AVAILABLE   AGE
apigee-ingressgateway-manager   2/2     2            2           2d
    7. Esegui l'upgrade dell'organizzazione Apigee:

      Dry run:

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

      Esegui l'upgrade del grafico:

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

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

      kubectl -n APIGEE_NAMESPACE get apigeeorg

      NAME                      STATE     AGE
apigee-my-org-my-env      running   2d
    8. Esegui l'upgrade dell'ambiente.

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

      Dry run:

      helm upgrade ENV_RELEASE_NAME apigee-env/ \
  --install \
  --namespace APIGEE_NAMESPACE \
  --set env=ENV_NAME \
  -f OVERRIDES_FILE \
  --dry-run=server
      • ENV_RELEASE_NAME è un nome utilizzato per monitorare l'installazione e gli upgrade del grafico apigee-env. Questo nome deve essere univoco rispetto agli altri nomi delle release Helm nell'installazione. Di solito è uguale a ENV_NAME. Tuttavia, se l'ambiente ha lo stesso nome del gruppo di ambienti, devi utilizzare nomi di release diversi per l'ambiente e il gruppo di ambienti, ad esempio dev-env-release e dev-envgroup-release. Per ulteriori informazioni sulle release in Helm, consulta Tre concetti importanti nella documentazione di Helm.
      • ENV_NAME è il nome dell'ambiente di cui stai eseguendo l'upgrade.
      • OVERRIDES_FILE è il nuovo file di override per la versione 1.16.11

      Esegui l'upgrade del grafico:

      helm upgrade ENV_RELEASE_NAME apigee-env/ \
  --install \
  --namespace APIGEE_NAMESPACE \
  --set env=ENV_NAME \
  -f OVERRIDES_FILE

      Verifica che sia attivo e funzionante controllando lo stato del rispettivo ambiente:

      kubectl -n APIGEE_NAMESPACE get apigeeenv

      NAME                          STATE       AGE   GATEWAYTYPE
apigee-my-org-my-env          running     2d
    9. 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 ambiente con --set envgroup=ENV_GROUP_NAME. Ripeti i seguenti comandi per ogni gruppo di ambienti menzionato nel file overrides.yaml:

        Dry run:

        helm upgrade ENV_GROUP_RELEASE_NAME apigee-virtualhost/ \
  --install \
  --namespace APIGEE_NAMESPACE \
  --set envgroup=ENV_GROUP_NAME \
  -f OVERRIDES_FILE \
  --dry-run=server

        ENV_GROUP_RELEASE_NAME è il nome con cui hai installato in precedenza il grafico apigee-virtualhost. Di solito è ENV_GROUP_NAME.

        Esegui l'upgrade del grafico:

        helm upgrade ENV_GROUP_RELEASE_NAME apigee-virtualhost/ \
  --install \
  --namespace APIGEE_NAMESPACE \
  --set envgroup=ENV_GROUP_NAME \
  -f OVERRIDES_FILE
      2. Controlla lo stato di ApigeeRoute (AR).

        L'installazione di virtualhosts crea ApigeeRouteConfig (ARC), che a sua volta crea internamente ApigeeRoute (AR) dopo che il watcher Apigee estrae i dettagli relativi al gruppo di ambienti dal control plane. Pertanto, verifica che lo stato del router AR corrispondente sia in esecuzione: 

        kubectl -n APIGEE_NAMESPACE get arc

        NAME                                STATE   AGE
apigee-org1-dev-egroup                       2d
         
        kubectl -n APIGEE_NAMESPACE get ar

        NAME                                        STATE     AGE
apigee-org1-dev-egroup-123abc               running   2d
    10. Dopo aver verificato che l'upgrade di tutte le installazioni è stato eseguito correttamente, elimina la release apigee-operator precedente dallo spazio dei nomi apigee-system.
      1. Disinstalla la versione precedente di operator: 
        helm delete operator -n apigee-system
      2. Elimina lo spazio dei nomi apigee-system: 
        kubectl delete namespace apigee-system
    11. Esegui di nuovo l'upgrade di operator nello spazio dei nomi Apigee per reinstallare le risorse con ambito cluster eliminate: 
      helm upgrade operator apigee-operator/ \
  --install \
  --namespace APIGEE_NAMESPACE \
  --atomic \
  -f overrides.yaml

    Eseguire il rollback a una versione precedente

    Per eseguire il rollback alla versione precedente, utilizza la versione precedente del grafico per eseguire il rollback della procedura di upgrade in ordine inverso. Inizia con apigee-virtualhost e torna indietro fino a apigee-operator, quindi ripristina i CRD.

    1. Ripristina i grafici. I seguenti comandi presuppongono che tu stia utilizzando i grafici della versione precedente (v1.15.x).

      1. Esegui questo comando per ogni gruppo di ambienti:

        helm upgrade ENV_GROUP_RELEASE_NAME apigee-virtualhost/ \
  --install \
  --namespace APIGEE_NAMESPACE \
  --atomic \
  --set envgroup=ENV_GROUP_NAME \
  -f 1.15_OVERRIDES_FILE

      2. Esegui questo comando per ogni ambiente:

        helm upgrade ENV_RELEASE_NAME apigee-env/ \
  --install \
  --namespace APIGEE_NAMESPACE \
  --atomic \
  --set env=ENV_NAME \
  -f 1.15_OVERRIDES_FILE

      3. apigee-org:

        helm upgrade ORG_NAME apigee-org/ \
  --install \
  --namespace APIGEE_NAMESPACE \
  --atomic \
  -f 1.15_OVERRIDES_FILE

      4. apigee-ingress-manager:

        helm upgrade ingress-manager apigee-ingress-manager/ \
  --install \
  --namespace APIGEE_NAMESPACE \
  --atomic \
  -f 1.15_OVERRIDES_FILE

      5. apigee-redis:

        helm upgrade redis apigee-redis/ \
  --install \
  --namespace APIGEE_NAMESPACE \
  --atomic \
  -f 1.15_OVERRIDES_FILE

      6. apigee-telemetry:

        helm upgrade telemetry apigee-telemetry/ \
  --install \
  --namespace APIGEE_NAMESPACE \
  --atomic \
  -f 1.15_OVERRIDES_FILE

      7. apigee-datastore:

        helm upgrade datastore apigee-datastore/ \
  --install \
  --namespace APIGEE_NAMESPACE \
  --atomic \
  -f 1.15_OVERRIDES_FILE

      8. apigee-operator:

        helm upgrade operator apigee-operator/ \
  --install \
  --namespace APIGEE_NAMESPACE \
  --atomic \
  -f 1.15_OVERRIDES_FILE
    2. Ripristina i CRD reinstallando i CRD precedenti. 
      kubectl apply -k apigee-operator/etc/crds/default/ \
  --server-side \
  --force-conflicts \
  --validate=false