Passaggio 11: installa Apigee hybrid utilizzando Helm

Version 1.15 (latest)

   Supported versions:

• v1.15 (latest)                        
• v1.14                        
• v1.13                         
• List of supported versions

   Unsupported versions:

• v1.12                         
• v1.11                         
• v1.10                                      
• v1.9                                         
• v1.8                                         
• v1.7                                         
• v1.6                                         
• v1.5                                         
• v1.4                                         
• v1.3                                         
• v1.2                                         
• v1.1                                         

Installa i componenti del runtime di Apigee hybrid

In questo passaggio utilizzerai Helm per installare i seguenti componenti di Apigee hybrid:

• Operatore Apigee
• Datastore Apigee
• Telemetria Apigee
• Apigee Redis
• Apigee ingress manager
• Organizzazione Apigee
• I tuoi ambienti Apigee

Installerai i grafici per ogni ambiente uno alla volta. La sequenza di installazione dei componenti è importante.

Note preinstallazione

1. Se non hai ancora installato Helm v3.14.2+, segui le istruzioni in Installazione di Helm.

2. Apigee hybrid utilizza le protezioni Helm per verificare la configurazione prima di installare o eseguire l'upgrade di un grafico. Potresti visualizzare informazioni specifiche per i guardrail nell'output di ciascuno dei comandi in questa sezione, ad esempio:

   # Source: apigee-operator/templates/apigee-operators-guardrails.yaml
   apiVersion: v1
   kind: Pod
   metadata:
     name: apigee-hybrid-helm-guardrail-operator
     namespace:  APIGEE_NAMESPACE
     annotations:
       helm.sh/hook: pre-install,pre-upgrade
       helm.sh/hook-delete-policy: before-hook-creation,hook-succeeded
     labels:
       app: apigee-hybrid-helm-guardrail
   

   Se uno dei comandi helm upgrade non va a buon fine, puoi utilizzare l'output delle misure di salvaguardia per diagnosticare la causa. Consulta Diagnostica dei problemi relativi alle barriere protettive.

3. Prima di eseguire uno dei comandi di upgrade/installazione di Helm, utilizza la funzionalità di prova di Helm aggiungendo --dry-run=server alla fine del comando. Consulta helm install --h per elencare comandi, opzioni e utilizzo supportati.

Passaggi di installazione

Seleziona le istruzioni di installazione per il tipo di autenticazione del account di servizio nell'installazione ibrida:

Secret Kubernetes

1. In caso contrario, vai alla directory APIGEE_HELM_CHARTS_HOME. Esegui i seguenti comandi da questa directory.
2. Installa l'operatore/controller Apigee:
   Nota:questo passaggio richiede autorizzazioni del cluster elevate. Esegui helm -h o helm install -h per maggiori dettagli
   1. Prova:

      helm upgrade operator apigee-operator/ \
        --install \
        --namespace APIGEE_NAMESPACE \
        --atomic \
        -f overrides.yaml \
        --dry-run=server
      

   2. Installa il grafico:

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

   3. Verifica l'installazione dell'operatore Apigee:

      helm ls -n APIGEE_NAMESPACE
      

      NAME       NAMESPACE       REVISION   UPDATED                                STATUS     CHART                                       APP VERSION
      operator   apigee   3          2025-06-26 00:42:44.492009 -0800 PST   deployed   apigee-operator-1.15.1   1.15.1
      

   4. Verifica che sia in funzione controllando la sua disponibilità:

      kubectl -n APIGEE_NAMESPACE get deploy apigee-controller-manager
      

      NAME                        READY   UP-TO-DATE   AVAILABLE   AGE
      apigee-controller-manager   1/1     1            1           34s
      

3. Installa Apigee datastore:

   1. Prova:

      helm upgrade datastore apigee-datastore/ \
        --install \
        --namespace APIGEE_NAMESPACE \
        --atomic \
        -f overrides.yaml \
        --dry-run=server
      

   2. Installa il grafico:

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

   3. Verifica che apigeedatastore sia in esecuzione controllandone lo stato prima di procedere con il passaggio successivo:

      kubectl -n APIGEE_NAMESPACE get apigeedatastore default
      

      NAME      STATE       AGE
      default   running    51s
      

4. Installa la telemetria di Apigee:

   1. Prova:

      helm upgrade telemetry apigee-telemetry/ \
        --install \
        --namespace APIGEE_NAMESPACE \
        --atomic \
        -f overrides.yaml \
        --dry-run=server
      

   2. Installa il grafico:

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

   3. Verifica che sia attivo e funzionante controllandone lo stato:

      kubectl -n APIGEE_NAMESPACE get apigeetelemetry apigee-telemetry
      

      NAME               STATE     AGE
      apigee-telemetry   running   55s
      

5. Installa Apigee Redis:

   1. Prova:

      helm upgrade redis apigee-redis/ \
        --install \
        --namespace APIGEE_NAMESPACE \
        --atomic \
        -f overrides.yaml \
        --dry-run=server
      

   2. Installa il grafico:

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

   3. Verifica che sia attivo e funzionante controllandone lo stato:

      kubectl -n APIGEE_NAMESPACE get apigeeredis default
      

      NAME      STATE     AGE
      default   running   79s
      

6. Installa Apigee Ingress Manager:

   1. Prova:

      helm upgrade ingress-manager apigee-ingress-manager/ \
        --install \
        --namespace APIGEE_NAMESPACE \
        --atomic \
        -f overrides.yaml \
        --dry-run=server
      

   2. Installa il grafico:

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

   3. Verifica che sia in funzione 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           16s
      

7. Installa l'organizzazione Apigee. Se hai impostato la variabile di ambiente $ORG_NAME nella shell, puoi utilizzarla nei comandi seguenti:

   1. Prova:

      helm upgrade $ORG_NAME apigee-org/ \
        --install \
        --namespace APIGEE_NAMESPACE \
        --atomic \
        -f overrides.yaml \
        --dry-run=server
      

   2. Installa il grafico:

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

   3. Verifica che sia attivo e funzionante controllando lo stato dell'organizzazione corrispondente:

      kubectl -n APIGEE_NAMESPACE get apigeeorg
      

      NAME                      STATE     AGE
      my-project-123abcd        running   4m18s
      

8. Installa l'ambiente.

   Devi installare un ambiente alla volta. Specifica l'ambiente con --set env=ENV_NAME. Se hai impostato la variabile di ambiente $ENV_NAME nella shell, puoi utilizzarla nei comandi seguenti:

   1. Prova:

      helm upgrade ENV_RELEASE_NAME apigee-env/ \
        --install \
        --namespace APIGEE_NAMESPACE \
        --atomic \
        --set env=$ENV_NAME \
        -f overrides.yaml \
        --dry-run=server
      

      ENV_RELEASE_NAME è un nome utilizzato per tenere traccia dell'installazione e degli 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 il tuo ambiente ha lo stesso nome del tuo 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.

   2. Installa il grafico:

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

   3. Verifica che sia attivo e funzionante controllando lo stato dell'ambiente corrispondente:

      kubectl -n APIGEE_NAMESPACE get apigeeenv
      

      NAME                       STATE     AGE   GATEWAYTYPE
      apigee-my-project-my-env   running   3m1s
      

9. Installa i gruppi di ambienti (virtualhosts).
   1. Devi installare un gruppo di ambienti (virtualhost) alla volta. Specifica il gruppo di ambienti con --set envgroup=ENV_GROUP. Se hai impostato la variabile di ambiente $ENV_GROUP nella shell, puoi utilizzarla nei comandi seguenti. Ripeti i seguenti comandi per ogni gruppo di ambienti menzionato nel file overrides.yaml:

      Prova:

      helm upgrade ENV_GROUP_RELEASE_NAME apigee-virtualhost/ \
        --install \
        --namespace APIGEE_NAMESPACE \
        --atomic \
        --set envgroup=$ENV_GROUP \
        -f overrides.yaml \
        --dry-run=server
      

      ENV_GROUP_RELEASE_NAME è un nome utilizzato per tenere traccia dell'installazione e degli upgrade del grafico apigee-virtualhosts. Questo nome deve essere univoco rispetto agli altri nomi delle release Helm nell'installazione. Di solito è uguale a ENV_GROUP. Tuttavia, se il gruppo di ambienti ha lo stesso nome di un ambiente nell'installazione, devi utilizzare nomi di release diversi per il gruppo di ambienti e l'ambiente, ad esempio dev-envgroup-release e dev-env-release. Per saperne di più sulle release in Helm, consulta la sezione Tre concetti importanti nella documentazione di Helm.

   2. Installa il grafico:

      helm upgrade ENV_GROUP_RELEASE_NAME apigee-virtualhost/ \
        --install \
        --namespace APIGEE_NAMESPACE \
        --atomic \
        --set envgroup=$ENV_GROUP \
        -f overrides.yaml
      

      Nota: ENV_GROUP deve essere univoco all'interno dello spazio dei nomi apigee. Ad esempio, se hai un ambiente prod e un gruppo di ambienti, devi impostare questo nome su prod-envgroup. Il nome del gruppo di ambienti successivo deve comunque essere prod.
   3. Controlla lo stato di ApigeeRoute (AR).

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

      kubectl -n APIGEE_NAMESPACE get arc
      

      NAME                                STATE   AGE
      apigee-org1-dev-egroup                       2m
      

      kubectl -n APIGEE_NAMESPACE get ar
      

      NAME                                                        STATE     AGE
      apigee-ingressgateway-internal-chaining-my-project-123abcd   running   19m
      my-project-myenvgroup-000-321dcba                            running   2m30s
      

File JSON

1. In caso contrario, vai alla directory APIGEE_HELM_CHARTS_HOME. Esegui i seguenti comandi da questa directory.
2. Installa l'operatore/controller Apigee:
   Nota:questo passaggio richiede autorizzazioni del cluster elevate. Esegui helm -h o helm install -h per maggiori dettagli
   1. Prova:

      helm upgrade operator apigee-operator/ \
        --install \
        --namespace APIGEE_NAMESPACE \
        --atomic \
        -f overrides.yaml \
        --dry-run=server
      

   2. Installa il grafico:

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

   3. Verifica l'installazione dell'operatore Apigee:

      helm ls -n APIGEE_NAMESPACE
      

      NAME       NAMESPACE       REVISION   UPDATED                                STATUS     CHART                                       APP VERSION
      operator   apigee   3          2025-06-26 00:42:44.492009 -0800 PST   deployed   apigee-operator-1.15.1   1.15.1
      

   4. Verifica che sia in funzione controllando la sua disponibilità:

      kubectl -n APIGEE_NAMESPACE get deploy apigee-controller-manager
      

      NAME                        READY   UP-TO-DATE   AVAILABLE   AGE
      apigee-controller-manager   1/1     1            1           34s
      

3. Installa Apigee datastore:

   1. Prova:

      helm upgrade datastore apigee-datastore/ \
        --install \
        --namespace APIGEE_NAMESPACE \
        --atomic \
        -f overrides.yaml \
        --dry-run=server
      

   2. Installa il grafico:

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

   3. Verifica che apigeedatastore sia in esecuzione controllandone lo stato prima di procedere con il passaggio successivo:

      kubectl -n APIGEE_NAMESPACE get apigeedatastore default
      

      NAME      STATE       AGE
      default   running    51s
      

4. Installa la telemetria di Apigee:

   1. Prova:

      helm upgrade telemetry apigee-telemetry/ \
        --install \
        --namespace APIGEE_NAMESPACE \
        --atomic \
        -f overrides.yaml \
        --dry-run=server
      

   2. Installa il grafico:

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

   3. Verifica che sia attivo e funzionante controllandone lo stato:

      kubectl -n APIGEE_NAMESPACE get apigeetelemetry apigee-telemetry
      

      NAME               STATE     AGE
      apigee-telemetry   running   55s
      

5. Installa Apigee Redis:

   1. Prova:

      helm upgrade redis apigee-redis/ \
        --install \
        --namespace APIGEE_NAMESPACE \
        --atomic \
        -f overrides.yaml \
        --dry-run=server
      

   2. Installa il grafico:

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

   3. Verifica che sia attivo e funzionante controllandone lo stato:

      kubectl -n APIGEE_NAMESPACE get apigeeredis default
      

      NAME      STATE     AGE
      default   running   79s
      

6. Installa Apigee Ingress Manager:

   1. Prova:

      helm upgrade ingress-manager apigee-ingress-manager/ \
        --install \
        --namespace APIGEE_NAMESPACE \
        --atomic \
        -f overrides.yaml \
        --dry-run=server
      

   2. Installa il grafico:

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

   3. Verifica che sia in funzione 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           16s
      

7. Installa l'organizzazione Apigee. Se hai impostato la variabile di ambiente $ORG_NAME nella shell, puoi utilizzarla nei comandi seguenti:

   1. Prova:

      helm upgrade $ORG_NAME apigee-org/ \
        --install \
        --namespace APIGEE_NAMESPACE \
        --atomic \
        -f overrides.yaml \
        --dry-run=server
      

   2. Installa il grafico:

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

   3. Verifica che sia attivo e funzionante controllando lo stato dell'organizzazione corrispondente:

      kubectl -n APIGEE_NAMESPACE get apigeeorg
      

      NAME                      STATE     AGE
      my-project-123abcd        running   4m18s
      

8. Installa l'ambiente.

   Devi installare un ambiente alla volta. Specifica l'ambiente con --set env=ENV_NAME. Se hai impostato la variabile di ambiente $ENV_NAME nella shell, puoi utilizzarla nei comandi seguenti:

   1. Prova:

      helm upgrade ENV_RELEASE_NAME apigee-env/ \
        --install \
        --namespace APIGEE_NAMESPACE \
        --atomic \
        --set env=$ENV_NAME \
        -f overrides.yaml \
        --dry-run=server
      

      ENV_RELEASE_NAME è un nome utilizzato per tenere traccia dell'installazione e degli 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 il tuo ambiente ha lo stesso nome del tuo 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.

   2. Installa il grafico:

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

   3. Verifica che sia attivo e funzionante controllando lo stato dell'ambiente corrispondente:

      kubectl -n APIGEE_NAMESPACE get apigeeenv
      

      NAME                       STATE     AGE   GATEWAYTYPE
      apigee-my-project-my-env   running   3m1s
      

9. Installa i gruppi di ambienti (virtualhosts).
   1. Devi installare un gruppo di ambienti (virtualhost) alla volta. Specifica il gruppo di ambienti con --set envgroup=ENV_GROUP. Se hai impostato la variabile di ambiente $ENV_GROUP nella shell, puoi utilizzarla nei comandi seguenti. Ripeti i seguenti comandi per ogni gruppo di ambienti menzionato nel file overrides.yaml:

      Prova:

      helm upgrade ENV_GROUP_RELEASE_NAME apigee-virtualhost/ \
        --install \
        --namespace APIGEE_NAMESPACE \
        --atomic \
        --set envgroup=$ENV_GROUP \
        -f overrides.yaml \
        --dry-run=server
      

      ENV_GROUP_RELEASE_NAME è un nome utilizzato per tenere traccia dell'installazione e degli upgrade del grafico apigee-virtualhosts. Questo nome deve essere univoco rispetto agli altri nomi delle release Helm nell'installazione. Di solito è uguale a ENV_GROUP. Tuttavia, se il gruppo di ambienti ha lo stesso nome di un ambiente nell'installazione, devi utilizzare nomi di release diversi per il gruppo di ambienti e l'ambiente, ad esempio dev-envgroup-release e dev-env-release. Per saperne di più sulle release in Helm, consulta la sezione Tre concetti importanti nella documentazione di Helm.

   2. Installa il grafico:

      helm upgrade ENV_GROUP_RELEASE_NAME apigee-virtualhost/ \
        --install \
        --namespace APIGEE_NAMESPACE \
        --atomic \
        --set envgroup=$ENV_GROUP \
        -f overrides.yaml
      

      Nota: ENV_GROUP deve essere univoco all'interno dello spazio dei nomi apigee. Ad esempio, se hai un ambiente prod e un gruppo di ambienti, devi impostare questo nome su prod-envgroup. Il nome del gruppo di ambienti successivo deve comunque essere prod.
   3. Controlla lo stato di ApigeeRoute (AR).

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

      kubectl -n APIGEE_NAMESPACE get arc
      

      NAME                                STATE   AGE
      apigee-org1-dev-egroup                       2m
      

      kubectl -n APIGEE_NAMESPACE get ar
      

      NAME                                                        STATE     AGE
      apigee-ingressgateway-internal-chaining-my-project-123abcd   running   19m
      my-project-myenvgroup-000-321dcba                            running   2m30s
      

Vault

1. In caso contrario, vai alla directory APIGEE_HELM_CHARTS_HOME. Esegui i seguenti comandi da questa directory.
2. Installa l'operatore/controller Apigee:
   Nota:questo passaggio richiede autorizzazioni del cluster elevate. Esegui helm -h o helm install -h per maggiori dettagli
   1. Prova:

      helm upgrade operator apigee-operator/ \
        --install \
        --namespace APIGEE_NAMESPACE \
        --atomic \
        -f overrides.yaml \
        --dry-run=server
      

   2. Installa il grafico:

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

   3. Verifica l'installazione dell'operatore Apigee:

      helm ls -n APIGEE_NAMESPACE
      

      NAME       NAMESPACE       REVISION   UPDATED                                STATUS     CHART                                       APP VERSION
      operator   apigee   3          2025-06-26 00:42:44.492009 -0800 PST   deployed   apigee-operator-1.15.1   1.15.1
      

   4. Verifica che sia in funzione controllando la sua disponibilità:

      kubectl -n APIGEE_NAMESPACE get deploy apigee-controller-manager
      

      NAME                        READY   UP-TO-DATE   AVAILABLE   AGE
      apigee-controller-manager   1/1     1            1           34s
      

3. Installa Apigee datastore:

   1. Prova:

      helm upgrade datastore apigee-datastore/ \
        --install \
        --namespace APIGEE_NAMESPACE \
        --atomic \
        -f overrides.yaml \
        --dry-run=server
      

   2. Installa il grafico:

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

   3. Verifica che apigeedatastore sia in esecuzione controllandone lo stato prima di procedere con il passaggio successivo:

      kubectl -n APIGEE_NAMESPACE get apigeedatastore default
      

      NAME      STATE       AGE
      default   running    51s
      

4. Installa la telemetria di Apigee:

   1. Prova:

      helm upgrade telemetry apigee-telemetry/ \
        --install \
        --namespace APIGEE_NAMESPACE \
        --atomic \
        -f overrides.yaml \
        --dry-run=server
      

   2. Installa il grafico:

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

   3. Verifica che sia attivo e funzionante controllandone lo stato:

      kubectl -n APIGEE_NAMESPACE get apigeetelemetry apigee-telemetry
      

      NAME               STATE     AGE
      apigee-telemetry   running   55s
      

5. Installa Apigee Redis:

   1. Prova:

      helm upgrade redis apigee-redis/ \
        --install \
        --namespace APIGEE_NAMESPACE \
        --atomic \
        -f overrides.yaml \
        --dry-run=server
      

   2. Installa il grafico:

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

   3. Verifica che sia attivo e funzionante controllandone lo stato:

      kubectl -n APIGEE_NAMESPACE get apigeeredis default
      

      NAME      STATE     AGE
      default   running   79s
      

6. Installa Apigee Ingress Manager:

   1. Prova:

      helm upgrade ingress-manager apigee-ingress-manager/ \
        --install \
        --namespace APIGEE_NAMESPACE \
        --atomic \
        -f overrides.yaml \
        --dry-run=server
      

   2. Installa il grafico:

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

   3. Verifica che sia in funzione 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           16s
      

7. Installa l'organizzazione Apigee. Se hai impostato la variabile di ambiente $ORG_NAME nella shell, puoi utilizzarla nei comandi seguenti:

   1. Prova:

      helm upgrade $ORG_NAME apigee-org/ \
        --install \
        --namespace APIGEE_NAMESPACE \
        --atomic \
        -f overrides.yaml \
        --dry-run=server
      

   2. Installa il grafico:

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

   3. Verifica che sia attivo e funzionante controllando lo stato dell'organizzazione corrispondente:

      kubectl -n APIGEE_NAMESPACE get apigeeorg
      

      NAME                      STATE     AGE
      my-project-123abcd        running   4m18s
      

8. Installa l'ambiente.

   Devi installare un ambiente alla volta. Specifica l'ambiente con --set env=ENV_NAME. Se hai impostato la variabile di ambiente $ENV_NAME nella shell, puoi utilizzarla nei comandi seguenti:

   1. Prova:

      helm upgrade ENV_RELEASE_NAME apigee-env/ \
        --install \
        --namespace APIGEE_NAMESPACE \
        --atomic \
        --set env=$ENV_NAME \
        -f overrides.yaml \
        --dry-run=server
      

      ENV_RELEASE_NAME è un nome utilizzato per tenere traccia dell'installazione e degli 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 il tuo ambiente ha lo stesso nome del tuo 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.

   2. Installa il grafico:

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

   3. Verifica che sia attivo e funzionante controllando lo stato dell'ambiente corrispondente:

      kubectl -n APIGEE_NAMESPACE get apigeeenv
      

      NAME                       STATE     AGE   GATEWAYTYPE
      apigee-my-project-my-env   running   3m1s
      

9. Installa i gruppi di ambienti (virtualhosts).
   1. Devi installare un gruppo di ambienti (virtualhost) alla volta. Specifica il gruppo di ambienti con --set envgroup=ENV_GROUP. Se hai impostato la variabile di ambiente $ENV_GROUP nella shell, puoi utilizzarla nei comandi seguenti. Ripeti i seguenti comandi per ogni gruppo di ambienti menzionato nel file overrides.yaml:

      Prova:

      helm upgrade ENV_GROUP_RELEASE_NAME apigee-virtualhost/ \
        --install \
        --namespace APIGEE_NAMESPACE \
        --atomic \
        --set envgroup=$ENV_GROUP \
        -f overrides.yaml \
        --dry-run=server
      

      ENV_GROUP_RELEASE_NAME è un nome utilizzato per tenere traccia dell'installazione e degli upgrade del grafico apigee-virtualhosts. Questo nome deve essere univoco rispetto agli altri nomi delle release Helm nell'installazione. Di solito è uguale a ENV_GROUP. Tuttavia, se il gruppo di ambienti ha lo stesso nome di un ambiente nell'installazione, devi utilizzare nomi di release diversi per il gruppo di ambienti e l'ambiente, ad esempio dev-envgroup-release e dev-env-release. Per saperne di più sulle release in Helm, consulta la sezione Tre concetti importanti nella documentazione di Helm.

   2. Installa il grafico:

      helm upgrade ENV_GROUP_RELEASE_NAME apigee-virtualhost/ \
        --install \
        --namespace APIGEE_NAMESPACE \
        --atomic \
        --set envgroup=$ENV_GROUP \
        -f overrides.yaml
      

      Nota: ENV_GROUP deve essere univoco all'interno dello spazio dei nomi apigee. Ad esempio, se hai un ambiente prod e un gruppo di ambienti, devi impostare questo nome su prod-envgroup. Il nome del gruppo di ambienti successivo deve comunque essere prod.
   3. Controlla lo stato di ApigeeRoute (AR).

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

      kubectl -n APIGEE_NAMESPACE get arc
      

      NAME                                STATE   AGE
      apigee-org1-dev-egroup                       2m
      

      kubectl -n APIGEE_NAMESPACE get ar
      

      NAME                                                        STATE     AGE
      apigee-ingressgateway-internal-chaining-my-project-123abcd   running   19m
      my-project-myenvgroup-000-321dcba                            running   2m30s
      

WIF per GKE

1. In caso contrario, vai alla directory APIGEE_HELM_CHARTS_HOME. Esegui i seguenti comandi da questa directory.
2. Installa l'operatore/controller Apigee:
   Nota:questo passaggio richiede autorizzazioni del cluster elevate. Esegui helm -h o helm install -h per maggiori dettagli
   1. Prova:

      helm upgrade operator apigee-operator/ \
        --install \
        --namespace APIGEE_NAMESPACE \
        --atomic \
        -f overrides.yaml \
        --dry-run=server
      

   2. Installa il grafico:

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

   3. Verifica l'installazione dell'operatore Apigee:

      helm ls -n APIGEE_NAMESPACE
      

      NAME       NAMESPACE       REVISION   UPDATED                                STATUS     CHART                                       APP VERSION
      operator   apigee   3          2025-06-26 00:42:44.492009 -0800 PST   deployed   apigee-operator-1.15.1   1.15.1
      

   4. Verifica che sia in funzione controllando la sua disponibilità:

      kubectl -n APIGEE_NAMESPACE get deploy apigee-controller-manager
      

      NAME                        READY   UP-TO-DATE   AVAILABLE   AGE
      apigee-controller-manager   1/1     1            1           34s
      

3. Installa Apigee datastore:

   1. Prova:

      helm upgrade datastore apigee-datastore/ \
        --install \
        --namespace APIGEE_NAMESPACE \
        --atomic \
        -f overrides.yaml \
        --dry-run=server
      

   2. Configura i binding del account di servizio per Cassandra per Workload Identity Federation for GKE:

      L'output del comando helm upgrade avrebbe dovuto contenere i comandi nella sezione NOTE. Segui questi comandi per configurare i binding dell'account di servizio. Devono essere presenti due comandi nel formato:

      Produzione

      gcloud iam service-accounts add-iam-policy-binding CASSANDRA_SERVICE_ACCOUNT_EMAIL \
        --role roles/iam.workloadIdentityUser \
        --member "serviceAccount:PROJECT_ID.svc.id.goog[apigee/apigee-cassandra-default]" \
        --project PROJECT_ID
      

      Non di produzione

      gcloud iam service-accounts add-iam-policy-binding NON_PROD_SERVICE_ACCOUNT_EMAIL \
        --role roles/iam.workloadIdentityUser \
        --member "serviceAccount:PROJECT_ID.svc.id.goog[apigee/apigee-cassandra-default]" \
        --project PROJECT_ID
      

      E:

      Produzione

      kubectl annotate serviceaccount apigee-cassandra-default \
        iam.gke.io/gcp-service-account=CASSANDRA_SERVICE_ACCOUNT_EMAIL \
        --namespace APIGEE_NAMESPACE
      

      Non di produzione

      kubectl annotate serviceaccount apigee-cassandra-default \
        iam.gke.io/gcp-service-account=NON_PROD_SERVICE_ACCOUNT_EMAIL \
        --namespace APIGEE_NAMESPACE
      

      Ad esempio:

      Produzione

      NOTES:
      For Cassandra backup GKE Workload Identity, please make sure to add the following membership to the IAM policy binding using the respective kubernetes SA (KSA).
        gcloud iam service-accounts add-iam-policy-binding [e-mail] \
              --role roles/iam.workloadIdentityUser \
              --member "serviceAccount:my-project.svc.id.goog[apigee/apigee-cassandra-default]" \
              --project my-project
      
        kubectl annotate serviceaccount apigee-cassandra-default \
              iam.gke.io/gcp-service-account=[e-mail] \
              --namespace apigee
      

      Non di produzione

      NOTES:
      For Cassandra backup GKE Workload Identity, please make sure to add the following membership to the IAM policy binding using the respective kubernetes SA (KSA).
        gcloud iam service-accounts add-iam-policy-binding [e-mail] \
              --role roles/iam.workloadIdentityUser \
              --member "serviceAccount:my-project.svc.id.goog[apigee/apigee-cassandra-default]" \
              --project my-project
      
        kubectl annotate serviceaccount apigee-cassandra-default \
              iam.gke.io/gcp-service-account=[e-mail] \
              --namespace apigee
      

      (Facoltativo) Se non vuoi configurare il backup di Cassandra in questo momento, modifica il file di override per rimuovere o commentare la sezione cassandra.backup prima di eseguire il comando helm upgrade senza il flag --dry-run. Per ulteriori informazioni sulla configurazione del backup di Cassandra, consulta Backup e ripristino di Cassandra.

   3. Installa il grafico:

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

   4. Verifica che apigeedatastore sia in esecuzione controllandone lo stato prima di procedere con il passaggio successivo:

      kubectl -n APIGEE_NAMESPACE get apigeedatastore default
      

      NAME      STATE       AGE
      default   running    51s
      

4. Installa la telemetria di Apigee:

   1. Prova:

      helm upgrade telemetry apigee-telemetry/ \
        --install \
        --namespace APIGEE_NAMESPACE \
        --atomic \
        -f overrides.yaml \
        --dry-run=server
      

   2. Configura i binding del account di servizio per Loggeer e Metrics per la federazione delle identità per i carichi di lavoro per GKE:

      L'output del comando helm upgrade avrebbe dovuto contenere i comandi nella sezione NOTE. Segui questi comandi per configurare i binding dell'account di servizio. Devono essere presenti due comandi nel formato:

      Logger KSA: apigee-logger-apigee-telemetry

      gcloud iam service-accounts add-iam-policy-binding LOGGER_SERVICE_ACCOUNT_EMAIL \
        --role roles/iam.workloadIdentityUser \
        --member "serviceAccount:PROJECT_ID.svc.id.goog[apigee/apigee-logger-apigee-telemetry]" \
        --project PROJECT_ID
      

      KSA delle metriche: apigee-metrics-sa

      Produzione

      gcloud iam service-accounts add-iam-policy-binding METRICS_SERVICE_ACCOUNT_EMAIL \
        --role roles/iam.workloadIdentityUser \
        --member "serviceAccount:PROJECT_ID.svc.id.goog[apigee/apigee-metrics-sa]" \
        --project PROJECT_ID

      Non di produzione

      gcloud iam service-accounts add-iam-policy-binding NON_PROD_SERVICE_ACCOUNT_EMAIL \
        --role roles/iam.workloadIdentityUser \
        --member "serviceAccount:PROJECT_ID.svc.id.goog[apigee/apigee-metrics-sa]" \
        --project PROJECT_ID

      Ad esempio:

      Produzione

      NOTES:
      For GKE Workload Identity, please make sure to add the following membership to the IAM policy binding using the respective kubernetes SA (KSA).
        Logger KSA: apigee-logger-apigee-telemetry
        gcloud iam service-accounts add-iam-policy-binding [e-mail] \
              --role roles/iam.workloadIdentityUser \
              --member "serviceAccount:my-project.svc.id.goog[apigee/apigee-logger-apigee-telemetry]" \
              --project my-project
      
        Metrics KSA: apigee-metrics-sa
        gcloud iam service-accounts add-iam-policy-binding [e-mail] \
              --role roles/iam.workloadIdentityUser \
              --member "serviceAccount:my-project.svc.id.goog[apigee/apigee-metrics-sa]" \
              --project my-project
      

      Non di produzione

      NOTES:
      For GKE Workload Identity, please make sure to add the following membership to the IAM policy binding using the respective kubernetes SA (KSA).
        Logger KSA: apigee-logger-apigee-telemetry
        gcloud iam service-accounts add-iam-policy-binding [e-mail] \
              --role roles/iam.workloadIdentityUser \
              --member "serviceAccount:my-project.svc.id.goog[apigee/apigee-logger-apigee-telemetry]" \
              --project my-project
      
        Metrics KSA: apigee-metrics-sa
        gcloud iam service-accounts add-iam-policy-binding [e-mail] \
              --role roles/iam.workloadIdentityUser \
              --member "serviceAccount:my-project.svc.id.goog[apigee/apigee-metrics-sa]" \
              --project my-project
      

   3. Installa il grafico:

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

   4. Verifica che sia attivo e funzionante controllandone lo stato:

      kubectl -n APIGEE_NAMESPACE get apigeetelemetry apigee-telemetry
      

      NAME               STATE     AGE
      apigee-telemetry   running   55s
      

5. Installa Apigee Redis:

   1. Prova:

      helm upgrade redis apigee-redis/ \
        --install \
        --namespace APIGEE_NAMESPACE \
        --atomic \
        -f overrides.yaml \
        --dry-run=server
      

   2. Installa il grafico:

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

   3. Verifica che sia attivo e funzionante controllandone lo stato:

      kubectl -n APIGEE_NAMESPACE get apigeeredis default
      

      NAME      STATE     AGE
      default   running   79s
      

6. Installa Apigee Ingress Manager:

   1. Prova:

      helm upgrade ingress-manager apigee-ingress-manager/ \
        --install \
        --namespace APIGEE_NAMESPACE \
        --atomic \
        -f overrides.yaml \
        --dry-run=server
      

   2. Installa il grafico:

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

   3. Verifica che sia in funzione 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           16s
      

7. Installa l'organizzazione Apigee. Se hai impostato la variabile di ambiente $ORG_NAME nella shell, puoi utilizzarla nei comandi seguenti:

   1. Prova:

      helm upgrade $ORG_NAME apigee-org/ \
        --install \
        --namespace APIGEE_NAMESPACE \
        --atomic \
        -f overrides.yaml \
        --dry-run=server
      

   2. Configura i binding del account di servizio per i componenti con ambito organizzativo per Workload Identity Federation for GKE, MART, Apigee Connect, UDCA e Watcher.

      L'output del comando helm upgrade avrebbe dovuto contenere i comandi nella sezione NOTE. Segui questi comandi per configurare i binding dell'account di servizio. Devono essere presenti quattro comandi.

      Nota:i nomi delle KSA includono un ID hash univoco per la tua organizzazione, ad esempio apigee-mart-my-project-123abcd-sa.

      MART KSA: apigee-mart-PROJECT_ID-ORG_HASH_ID-sa

      Produzione

      gcloud iam service-accounts add-iam-policy-binding MART_SERVICE_ACCOUNT_EMAIL \
        --role roles/iam.workloadIdentityUser \
        --member "serviceAccount:PROJECT_ID.svc.id.goog[apigee/apigee-mart-PROJECT_ID-ORG_HASH_ID-sa]" \
        --project PROJECT_ID
      

      Non di produzione

      gcloud iam service-accounts add-iam-policy-binding NON_PROD_SERVICE_ACCOUNT_EMAIL \
        --role roles/iam.workloadIdentityUser \
        --member "serviceAccount:PROJECT_ID.svc.id.goog[apigee/apigee-mart-PROJECT_ID-ORG_HASH_ID-sa]" \
        --project PROJECT_ID
      

      Connect Agent KSA: apigee-connect-agent-PROJECT_ID-ORG_HASH_ID-sa

      Nota:Apigee Connect utilizza l'account di servizio Google MART.

      Produzione

      gcloud iam service-accounts add-iam-policy-binding MART_SERVICE_ACCOUNT_EMAIL \
        --role roles/iam.workloadIdentityUser \
        --member "serviceAccount:PROJECT_ID.svc.id.goog[apigee/apigee-connect-agent-PROJECT_ID-ORG_HASH_ID-sa]" \
        --project PROJECT_ID
      

      Non di produzione

      gcloud iam service-accounts add-iam-policy-binding NON_PROD_SERVICE_ACCOUNT_EMAIL \
        --role roles/iam.workloadIdentityUser \
        --member "serviceAccount:PROJECT_ID.svc.id.goog[apigee/apigee-connect-agent-PROJECT_ID-ORG_HASH_ID-sa]" \
        --project PROJECT_ID
      

      Utilità di pianificazione delle attività Mint KSA: (se utilizzi la monetizzazione per Apigee hybrid) apigee-mint-task-scheduler-PROJECT_ID-ORG_HASH_ID-sa

      Produzione

      gcloud iam service-accounts add-iam-policy-binding MINT_TASK_SCHEDULER_SERVICE_ACCOUNT_EMAIL \
        --role roles/iam.workloadIdentityUser \
        --member "serviceAccount:PROJECT_ID.svc.id.goog[apigee/apigee-mint-task-scheduler-PROJECT_ID-ORG_HASH_ID-sa]" \
        --project PROJECT_ID
      

      Non di produzione

      gcloud iam service-accounts add-iam-policy-binding NON_PROD_SERVICE_ACCOUNT_EMAIL \
        --role roles/iam.workloadIdentityUser \
        --member "serviceAccount:PROJECT_ID.svc.id.goog[apigee/apigee-mint-task-scheduler-PROJECT_ID-ORG_HASH_ID-sa]" \
        --project PROJECT_ID
      

      UDCA KSA: apigee-udca-PROJECT_ID-ORG_HASH_ID-sa

      Produzione

      gcloud iam service-accounts add-iam-policy-binding UDCA_SERVICE_ACCOUNT_EMAIL \
        --role roles/iam.workloadIdentityUser \
        --member "serviceAccount:PROJECT_ID.svc.id.goog[apigee/apigee-udca-PROJECT_ID-ORG_HASH_ID-sa]" \
        --project PROJECT_ID
      

      Non di produzione

      gcloud iam service-accounts add-iam-policy-binding NON_PROD_SERVICE_ACCOUNT_EMAIL \
        --role roles/iam.workloadIdentityUser \
        --member "serviceAccount:PROJECT_ID.svc.id.goog[apigee/apigee-udca-PROJECT_ID-ORG_HASH_ID-sa]" \
        --project PROJECT_ID
      

      Watcher KSA: apigee-watcher-PROJECT_ID-ORG_HASH_ID-sa

      Produzione

      gcloud iam service-accounts add-iam-policy-binding WATCHER_SERVICE_ACCOUNT_EMAIL \
        --role roles/iam.workloadIdentityUser \
        --member "serviceAccount:PROJECT_ID.svc.id.goog[apigee/apigee-watcher-PROJECT_ID-ORG_HASH_ID-sa]" \
        --project PROJECT_ID
      

      Non di produzione

      gcloud iam service-accounts add-iam-policy-binding NON_PROD_SERVICE_ACCOUNT_EMAIL \
        --role roles/iam.workloadIdentityUser \
        --member "serviceAccount:PROJECT_ID.svc.id.goog[apigee/apigee-watcher-PROJECT_ID-ORG_HASH_ID-sa]" \
        --project PROJECT_ID
      

      Ad esempio:

      Produzione

      NOTES:
      For Apigee Organization GKE Workload Identity, my-project, please make sure to add the following membership to the IAM policy binding using the respective kubernetes SA (KSA).
      
      
        MART KSA: apigee-mart-my-project-1a2b3c4-sa
        gcloud iam service-accounts add-iam-policy-binding [e-mail] \
              --role roles/iam.workloadIdentityUser \
              --member "serviceAccount:my-project.svc.id.goog[apigee/apigee-mart-my-project-1a2b3c4-sa]" \
              --project my-project
      
      
        Connect Agent KSA: apigee-connect-agent-my-project-1a2b3c4-sa
        gcloud iam service-accounts add-iam-policy-binding [e-mail] \
              --role roles/iam.workloadIdentityUser \
              --member "serviceAccount:my-project.svc.id.goog[apigee/apigee-connect-agent-my-project-1a2b3c4-sa]" \
              --project my-project
      
      
        Mint task scheduler KSA: apigee-mint-task-scheduler-my-project-1a2b3c4-sa
        gcloud iam service-accounts add-iam-policy-binding [e-mail] \
              --role roles/iam.workloadIdentityUser \
              --member "serviceAccount:my-project.svc.id.goog[apigee/apigee-mint-task-scheduler-my-project-1a2b3c4-sa]" \
              --project my-project
      
      
        UDCA KSA: apigee-udca-my-project-1a2b3c4-sa
        gcloud iam service-accounts add-iam-policy-binding [e-mail] \
              --role roles/iam.workloadIdentityUser \
              --member "serviceAccount:my-project.svc.id.goog[apigee/apigee-udca-my-project-1a2b3c4-sa]" \
              --project my-project
      
      
        Watcher KSA: apigee-watcher-my-project-1a2b3c4-sa
        gcloud iam service-accounts add-iam-policy-binding [e-mail] \
              --role roles/iam.workloadIdentityUser \
              --member "serviceAccount:my-project.svc.id.goog[apigee/apigee-watcher-my-project-1a2b3c4-sa]" \
              --project my-project
      

      Non di produzione

      NOTES:
      For Apigee Organization GKE Workload Identity, my-project, please make sure to add the following membership to the IAM policy binding using the respective kubernetes SA (KSA).
      
        MART KSA: apigee-mart-my-project-1a2b3c4-sa
        gcloud iam service-accounts add-iam-policy-binding [e-mail] \
              --role roles/iam.workloadIdentityUser \
              --member "serviceAccount:my-project.svc.id.goog[apigee/apigee-mart-my-project-1a2b3c4-sa]" \
              --project my-project
      
      
        Connect Agent KSA: apigee-connect-agent-my-project-1a2b3c4-sa
        gcloud iam service-accounts add-iam-policy-binding [e-mail] \
              --role roles/iam.workloadIdentityUser \
              --member "serviceAccount:my-project.svc.id.goog[apigee/apigee-connect-agent-my-project-1a2b3c4-sa]" \
              --project my-project
      
      
        UDCA KSA: apigee-udca-my-project-1a2b3c4-sa
        gcloud iam service-accounts add-iam-policy-binding [e-mail] \
              --role roles/iam.workloadIdentityUser \
              --member "serviceAccount:my-project.svc.id.goog[apigee/apigee-udca-my-project-1a2b3c4-sa]" \
              --project my-project
      
      
        Watcher KSA: apigee-watcher-my-project-1a2b3c4-sa
        gcloud iam service-accounts add-iam-policy-binding [e-mail] \
              --role roles/iam.workloadIdentityUser \
              --member "serviceAccount:my-project.svc.id.goog[apigee/apigee-watcher-my-project-1a2b3c4-sa]" \
              --project my-project
      

   3. Installa il grafico:

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

   4. Verifica che sia attivo e funzionante controllando lo stato dell'organizzazione corrispondente:

      kubectl -n APIGEE_NAMESPACE get apigeeorg
      

      NAME                      STATE     AGE
      my-project-123abcd        running   4m18s
      

8. Installa l'ambiente.

   Devi installare un ambiente alla volta. Specifica l'ambiente con --set env=ENV_NAME. Se hai impostato la variabile di ambiente $ENV_NAME nella shell, puoi utilizzarla nei comandi seguenti:

   1. Prova:

      helm upgrade ENV_RELEASE_NAME apigee-env/ \
        --install \
        --namespace APIGEE_NAMESPACE \
        --atomic \
        --set env=$ENV_NAME \
        -f overrides.yaml \
        --dry-run=server
      

      ENV_RELEASE_NAME è un nome utilizzato per tenere traccia dell'installazione e degli 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 il tuo ambiente ha lo stesso nome del tuo 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.

   2. Configura i binding del account di servizio per i componenti con ambito di ambiente per Workload Identity Federation for GKE, Runtime, Synchronizer e UDCA.

      L'output del comando helm upgrade avrebbe dovuto contenere i comandi nella sezione NOTE. Segui questi comandi per configurare i binding dell'account di servizio. Devono essere presenti quattro comandi.

      Nota:i nomi KSA includono un ID hash univoco per il tuo ambiente, ad esempio apigee-mart-my-project--myenv-abc1234-sa.

      Runtime KSA: apigee-runtime-PROJECT_ID-ENV_NAME-ENV_HASH_ID-sa

      Produzione

      gcloud iam service-accounts add-iam-policy-binding RUNTIME_SERVICE_ACCOUNT_EMAIL \
        --role roles/iam.workloadIdentityUser \
        --member "serviceAccount:PROJECT_ID.svc.id.goog[apigee/apigee-runtime-PROJECT_ID-ENV_NAME-ENV_HASH_ID-sa]" \
        --project PROJECT_ID
      

      Non di produzione

      gcloud iam service-accounts add-iam-policy-binding NON_PROD_SERVICE_ACCOUNT_EMAIL \
        --role roles/iam.workloadIdentityUser \
        --member "serviceAccount:PROJECT_ID.svc.id.goog[apigee/apigee-runtime-PROJECT_ID-ENV_NAME-ENV_HASH_ID-sa]" \
        --project PROJECT_ID
      

      Synchronizer KSA: apigee-synchronizer-PROJECT_ID-ENV_NAME-ENV_HASH_ID-sa

      Produzione

      gcloud iam service-accounts add-iam-policy-binding SYNCHRONIZER_SERVICE_ACCOUNT_EMAIL \
        --role roles/iam.workloadIdentityUser \
        --member "serviceAccount:PROJECT_ID.svc.id.goog[apigee/apigee-synchronizer-PROJECT_ID-ENV_NAME-ENV_HASH_ID-sa]" \
        --project PROJECT_ID
      

      Non di produzione

      gcloud iam service-accounts add-iam-policy-binding NON_PROD_SERVICE_ACCOUNT_EMAIL \
        --role roles/iam.workloadIdentityUser \
        --member "serviceAccount:PROJECT_ID.svc.id.goog[apigee/apigee-synchronizer-PROJECT_ID-ENV_NAME-ENV_HASH_ID-sa]" \
        --project PROJECT_ID
      

      UDCA KSA: apigee-udca-PROJECT_ID-ORG_HASH_ID-ENV_NAME-ENV_HASH_ID-sa

      Produzione

      gcloud iam service-accounts add-iam-policy-binding UDCA_SERVICE_ACCOUNT_EMAIL \
        --role roles/iam.workloadIdentityUser \
        --member "serviceAccount:PROJECT_ID.svc.id.goog[apigee/apigee-udca-PROJECT_ID-ENV_NAME-ENV_HASH_ID-sa]" \
        --project PROJECT_ID
      

      Non di produzione

      gcloud iam service-accounts add-iam-policy-binding NON_PROD_SERVICE_ACCOUNT_EMAIL \
        --role roles/iam.workloadIdentityUser \
        --member "serviceAccount:PROJECT_ID.svc.id.goog[apigee/apigee-udca-PROJECT_ID-ENV_NAME-ENV_HASH_ID-sa]" \
        --project PROJECT_ID
      

      Ad esempio:

      NOTES:
      For Apigee Environment GKE Workload Identity, my-env, please make sure to add the following membership to the IAM policy binding using the respective kubernetes SA (KSA).
      
      
        Runtime KSA: apigee-runtime-my-project-my-env-b2c3d4e-sa
        gcloud iam service-accounts add-iam-policy-binding [e-mail] \
              --role roles/iam.workloadIdentityUser \
              --member "serviceAccount:my-project.svc.id.goog[apigee/apigee-runtime-my-project-my-env-b2c3d4e-sa]" \
              --project my-project
      
      
        Synchronizer KSA: apigee-synchronizer-my-project-my-env-b2c3d4e-sa
        gcloud iam service-accounts add-iam-policy-binding [e-mail] \
              --role roles/iam.workloadIdentityUser \
              --member "serviceAccount:my-project.svc.id.goog[apigee/apigee-synchronizer-my-project-my-env-b2c3d4e-sa]" \
              --project my-project
      
      
        UDCA KSA: apigee-udca-my-project-my-env-b2c3d4e-sa:
        gcloud iam service-accounts add-iam-policy-binding [e-mail] \
              --role roles/iam.workloadIdentityUser \
              --member "serviceAccount:my-project.svc.id.goog[apigee/apigee-udca-my-project-my-env-b2c3d4e-sa]" \
              --project my-project
      

   3. Installa il grafico:

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

   4. Verifica che sia attivo e funzionante controllando lo stato dell'ambiente corrispondente:

      kubectl -n APIGEE_NAMESPACE get apigeeenv
      

      NAME                       STATE     AGE   GATEWAYTYPE
      apigee-my-project-my-env   running   3m1s
      

9. Installa i gruppi di ambienti (virtualhosts).
   1. Devi installare un gruppo di ambienti (virtualhost) alla volta. Specifica il gruppo di ambienti con --set envgroup=ENV_GROUP. Se hai impostato la variabile di ambiente $ENV_GROUP nella shell, puoi utilizzarla nei comandi seguenti. Ripeti i seguenti comandi per ogni gruppo di ambienti menzionato nel file overrides.yaml:

      Prova:

      helm upgrade ENV_GROUP_RELEASE_NAME apigee-virtualhost/ \
        --install \
        --namespace APIGEE_NAMESPACE \
        --atomic \
        --set envgroup=$ENV_GROUP \
        -f overrides.yaml \
        --dry-run=server
      

      ENV_GROUP_RELEASE_NAME è un nome utilizzato per tenere traccia dell'installazione e degli upgrade del grafico apigee-virtualhosts. Questo nome deve essere univoco rispetto agli altri nomi delle release Helm nell'installazione. Di solito è uguale a ENV_GROUP. Tuttavia, se il gruppo di ambienti ha lo stesso nome di un ambiente nell'installazione, devi utilizzare nomi di release diversi per il gruppo di ambienti e l'ambiente, ad esempio dev-envgroup-release e dev-env-release. Per saperne di più sulle release in Helm, consulta la sezione Tre concetti importanti nella documentazione di Helm.

   2. Installa il grafico:

      helm upgrade ENV_GROUP_RELEASE_NAME apigee-virtualhost/ \
        --install \
        --namespace APIGEE_NAMESPACE \
        --atomic \
        --set envgroup=$ENV_GROUP \
        -f overrides.yaml
      

      Nota: ENV_GROUP deve essere univoco all'interno dello spazio dei nomi apigee. Ad esempio, se hai un ambiente prod e un gruppo di ambienti, devi impostare questo nome su prod-envgroup. Il nome del gruppo di ambienti successivo deve comunque essere prod.
   3. Controlla lo stato di ApigeeRoute (AR).

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

      kubectl -n APIGEE_NAMESPACE get arc
      

      NAME                                STATE   AGE
      apigee-org1-dev-egroup                       2m
      

      kubectl -n APIGEE_NAMESPACE get ar
      

      NAME                                                        STATE     AGE
      apigee-ingressgateway-internal-chaining-my-project-123abcd   running   19m
      my-project-myenvgroup-000-321dcba                            running   2m30s
      

10. (Facoltativo) Puoi visualizzare lo stato dei tuoi service account Kubernetes nella pagina Kubernetes: Panoramica dei carichi di lavoro in Google Cloud console.

    Vai a Carichi di lavoro

    Nota:potresti visualizzare uno stato di errore per il account di servizio apigee-cassandra-backup. Questo perché al momento non stai eseguendo il backup o il ripristino e questi processi non sono ancora stati configurati completamente. Per ulteriori informazioni sul backup e sul ripristino di Cassandra, vedi Panoramica del backup di Cassandra.

WIF su altre piattaforme

1. In caso contrario, vai alla directory APIGEE_HELM_CHARTS_HOME. Esegui i seguenti comandi da questa directory.
2. Installa l'operatore/controller Apigee:
   Nota:questo passaggio richiede autorizzazioni del cluster elevate. Esegui helm -h o helm install -h per maggiori dettagli
   1. Prova:

      helm upgrade operator apigee-operator/ \
        --install \
        --namespace APIGEE_NAMESPACE \
        --atomic \
        -f overrides.yaml \
        --dry-run=server
      

   2. Installa il grafico:

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

   3. Verifica l'installazione dell'operatore Apigee:

      helm ls -n APIGEE_NAMESPACE
      

      NAME       NAMESPACE       REVISION   UPDATED                                STATUS     CHART                                       APP VERSION
      operator   apigee   3          2025-06-26 00:42:44.492009 -0800 PST   deployed   apigee-operator-1.15.1   1.15.1
      

   4. Verifica che sia in funzione controllando la sua disponibilità:

      kubectl -n APIGEE_NAMESPACE get deploy apigee-controller-manager
      

      NAME                        READY   UP-TO-DATE   AVAILABLE   AGE
      apigee-controller-manager   1/1     1            1           34s
      

3. Installa Apigee datastore:

   1. Prova:

      helm upgrade datastore apigee-datastore/ \
        --install \
        --namespace APIGEE_NAMESPACE \
        --atomic \
        -f overrides.yaml \
        --dry-run=server
      

   2. Installa il grafico:

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

   3. Se hai attivato il backup o il ripristino di Cassandra, concedi agli account di servizio Kubernetes di Cassandra l'accesso per rappresentare l'apigee-cassandraservice account IAM associato.
      1. Elenca gli indirizzi email dell'account di servizio IAM per Cassandra:

         Produzione

         gcloud iam service-accounts list --project PROJECT_ID | grep "apigee-cassandra"

         Non di produzione

         gcloud iam service-accounts list --project PROJECT_ID | grep "apigee-non-prod"

         L'output dovrebbe essere simile al seguente:

         Produzione

         apigee-cassandra      [e-mail]      False
                           

         Non di produzione

         apigee-non-prod       [e-mail]      False
                           

      2. Elenca i service account Kubernetes di Cassandra:

         kubectl get serviceaccount -n APIGEE_NAMESPACE | grep "apigee-cassandra"

         L'output dovrebbe essere simile al seguente:

         apigee-cassandra-backup-sa                       0   7m37s
         apigee-cassandra-default                         0   7m12s
         apigee-cassandra-guardrails-sa                   0   6m43s
         apigee-cassandra-restore-sa                      0   7m37s
         apigee-cassandra-schema-setup-my-project-1a2b2c4 0   7m30s
         apigee-cassandra-schema-val-my-project-1a2b2c4   0   7m29s
         apigee-cassandra-user-setup-my-project-1a2b2c4   0   7m22s
                       

      3. Se hai creato i service account Kubernetes apigee-cassandra-backup-sa o apigee-cassandra-restore-sa, concedi a ciascuno di essi l'accesso per rappresentare il account di servizio IAM apigee-cassandra con il seguente comando:

         Produzione

         Modello

         gcloud iam service-accounts add-iam-policy-binding \
           CASSANDRA_IAM_SA_EMAIL \
             --member="principal://iam.googleapis.com/projects/PROJECT_NUMBER/locations/global/workloadIdentityPools/POOL_ID/subject/MAPPED_SUBJECT" \
             --role=roles/iam.workloadIdentityUser

         Esempio

         gcloud iam service-accounts add-iam-policy-binding \
           [e-mail] \
             --member="principal://iam.googleapis.com/projects/1234567890/locations/global/workloadIdentityPools/my-pool/subject/system:serviceaccount:apigee:apigee-cassandra-backup-sa" \
             --role=roles/iam.workloadIdentityUser

         Non di produzione

         Modello

         gcloud iam service-accounts add-iam-policy-binding \
           NON_PROD_IAM_SA_EMAIL \
             --member="principal://iam.googleapis.com/projects/PROJECT_NUMBER/locations/global/workloadIdentityPools/POOL_ID/subject/MAPPED_SUBJECT" \
             --role=roles/iam.workloadIdentityUser

         Esempio

         gcloud iam service-accounts add-iam-policy-binding \
           [e-mail] \
             --member="principal://iam.googleapis.com/projects/1234567890/locations/global/workloadIdentityPools/my-pool/subject/system:serviceaccount:apigee:apigee-cassandra-backup-sa" \
             --role=roles/iam.workloadIdentityUser

         Dove:

         • CASSANDRA_IAM_SA_EMAIL: l'indirizzo email del account di servizio IAM di Cassandra.
         • PROJECT_NUMBER: il numero di progetto del progetto in cui hai creato il pool di identità del workload.
           Nota:devi utilizzare il numero di progetto nell'identificatore membro. L'utilizzo dell'ID progetto non è supportato. Puoi trovare il numero di progetto con il seguente comando:

           gcloud projects describe PROJECT_ID --format="value(projectNumber)"

         • POOL_ID: l'ID del pool di identità del workload.
         • MAPPED_SUBJECT: il service account Kubernetes dalla rivendicazione nel token ID. Nella maggior parte delle installazioni ibride, questo avrà il formato: system:serviceaccount:APIGEE_NAMESPACE:K8S_SA_NAME.
           • Per apigee-cassandra-backup-sa, sarà qualcosa di simile a system:serviceaccount:apigee:apigee-cassandra-backup-sa.
           • Per apigee-cassandra-restore-sa, sarà qualcosa di simile a system:serviceaccount:apigee:apigee-cassandra-restore-sa.
           Suggerimento:nel passaggio Aggiungi il cluster come provider del pool di identità del workload del passaggio 5: configura l'autenticazione dell'account di servizio, hai mappato google.subject=assertions.sub. Pertanto, il valore di MAPPED_SUBJECT sarà il valore nel token ID dopo "sub": . Puoi trovare il soggetto mappato per un account di servizio Kubernetes cercando il token ID per sub seguito dal nome del account di servizio.

           Ad esempio, invia i contenuti del token ID tramite grep -E 'sub.*apigee-cassandra-backup-sa'

   4. Verifica che apigeedatastore sia in esecuzione controllandone lo stato prima di procedere con il passaggio successivo:

      kubectl -n APIGEE_NAMESPACE get apigeedatastore default
      

      NAME      STATE       AGE
      default   running    51s
      

4. Installa la telemetria di Apigee:

   1. Prova:

      helm upgrade telemetry apigee-telemetry/ \
        --install \
        --namespace APIGEE_NAMESPACE \
        --atomic \
        -f overrides.yaml \
        --dry-run=server
      

   2. Installa il grafico:

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

   3. Verifica che sia attivo e funzionante controllandone lo stato:

      kubectl -n APIGEE_NAMESPACE get apigeetelemetry apigee-telemetry
      

      NAME               STATE     AGE
      apigee-telemetry   running   55s
      

   4. Concedi agli account di servizio Kubernetes di telemetria l'accesso per rappresentare il service account IAM apigee-metrics associato.
      1. Elenca l'indirizzo email del account di servizio IAM per le metriche:

         Produzione

         gcloud iam service-accounts list --project PROJECT_ID | grep "apigee-metrics"

         L'output dovrebbe essere simile al seguente:

         apigee-metrics   [e-mail]   False

         Non di produzione

         gcloud iam service-accounts list --project PROJECT_ID | grep "apigee-non-prod"

         L'output dovrebbe essere simile al seguente:

         apigee-non-prod   [e-mail]   False

      2. Elenca i service account Kubernetes di telemetria:

         kubectl get serviceaccount -n APIGEE_NAMESPACE | grep "telemetry"

         L'output dovrebbe essere simile al seguente:

         apigee-metrics-apigee-telemetry                    0   42m
         apigee-open-telemetry-collector-apigee-telemetry   0   37m

      3. Concedi a ogni service account Kubernetes di telemetria l'accesso per rappresentare il account di servizio IAM apigee-metrics con il seguente comando:

         Produzione

         Apigee Metrics KSA: apigee-metrics-apigee-telemetry to apigee-metrics account di servizio Google IAM

         Codice

         gcloud iam service-accounts add-iam-policy-binding \
           METRICS_IAM_SA_EMAIL \
             --member="principal://iam.googleapis.com/projects/PROJECT_NUMBER/locations/global/workloadIdentityPools/POOL_ID/subject/MAPPED_SUBJECT" \
             --role=roles/iam.workloadIdentityUser

         Esempio

         gcloud iam service-accounts add-iam-policy-binding \
           [e-mail] \
             --member="principal://iam.googleapis.com/projects/1234567890/locations/global/workloadIdentityPools/my-pool/subject/system:serviceaccount:apigee:apigee-metrics-apigee-telemetry" \
             --role=roles/iam.workloadIdentityUser

         Apigee OpenTelemetry Collector KSA: apigee-open-telemetry-collector-apigee-telemetry a apigee-metrics account di servizio Google IAM

         Codice

         gcloud iam service-accounts add-iam-policy-binding \
           METRICS_IAM_SA_EMAIL \
             --member="principal://iam.googleapis.com/projects/PROJECT_NUMBER/locations/global/workloadIdentityPools/POOL_ID/subject/MAPPED_SUBJECT" \
             --role=roles/iam.workloadIdentityUser

         Esempio

         gcloud iam service-accounts add-iam-policy-binding \
           [e-mail] \
             --member="principal://iam.googleapis.com/projects/1234567890/locations/global/workloadIdentityPools/my-pool/subject/system:serviceaccount:apigee:apigee-open-telemetry-collector-apigee-telemetry" \
             --role=roles/iam.workloadIdentityUser

         Non di produzione

         Apigee Metrics KSA: apigee-metrics-apigee-telemetry to apigee-non-prod account di servizio Google IAM

         Codice

         gcloud iam service-accounts add-iam-policy-binding \
           NON_PROD_IAM_SA_EMAIL \
             --member="principal://iam.googleapis.com/projects/PROJECT_NUMBER/locations/global/workloadIdentityPools/POOL_ID/subject/MAPPED_SUBJECT" \
             --role=roles/iam.workloadIdentityUser

         Esempio

         gcloud iam service-accounts add-iam-policy-binding \
           [e-mail] \
             --member="principal://iam.googleapis.com/projects/1234567890/locations/global/workloadIdentityPools/my-pool/subject/system:serviceaccount:apigee:apigee-metrics-apigee-telemetry" \
             --role=roles/iam.workloadIdentityUser

         Apigee OpenTelemetry Collector KSA: apigee-open-telemetry-collector-apigee-telemetry a apigee-non-prod account di servizio Google IAM

         Codice

         gcloud iam service-accounts add-iam-policy-binding \
           NON_PROD_IAM_SA_EMAIL \
             --member="principal://iam.googleapis.com/projects/PROJECT_NUMBER/locations/global/workloadIdentityPools/POOL_ID/subject/MAPPED_SUBJECT" \
             --role=roles/iam.workloadIdentityUser

         Esempio

         gcloud iam service-accounts add-iam-policy-binding \
           [e-mail] \
             --member="principal://iam.googleapis.com/projects/1234567890/locations/global/workloadIdentityPools/my-pool/subject/system:serviceaccount:apigee:apigee-open-telemetry-collector-apigee-telemetry" \
             --role=roles/iam.workloadIdentityUser

5. Installa Apigee Redis:

   1. Prova:

      helm upgrade redis apigee-redis/ \
        --install \
        --namespace APIGEE_NAMESPACE \
        --atomic \
        -f overrides.yaml \
        --dry-run=server
      

   2. Installa il grafico:

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

   3. Verifica che sia attivo e funzionante controllandone lo stato:

      kubectl -n APIGEE_NAMESPACE get apigeeredis default
      

      NAME      STATE     AGE
      default   running   79s
      

6. Installa Apigee Ingress Manager:

   1. Prova:

      helm upgrade ingress-manager apigee-ingress-manager/ \
        --install \
        --namespace APIGEE_NAMESPACE \
        --atomic \
        -f overrides.yaml \
        --dry-run=server
      

   2. Installa il grafico:

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

   3. Verifica che sia in funzione 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           16s
      

7. Installa l'organizzazione Apigee. Se hai impostato la variabile di ambiente $ORG_NAME nella shell, puoi utilizzarla nei comandi seguenti:

   1. Prova:

      helm upgrade $ORG_NAME apigee-org/ \
        --install \
        --namespace APIGEE_NAMESPACE \
        --atomic \
        -f overrides.yaml \
        --dry-run=server
      

   2. Installa il grafico:

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

   3. Verifica che sia attivo e funzionante controllando lo stato dell'organizzazione corrispondente:

      kubectl -n APIGEE_NAMESPACE get apigeeorg
      

      NAME                      STATE     AGE
      my-project-123abcd        running   4m18s
      

   4. Concedi agli account di servizio Kubernetes con ambito organizzazione l'accesso per rappresentare gli account di servizio IAM associati.
      1. Elenca gli indirizzi email dei service account IAM utilizzati dai componenti apigee-mart, apigee-udca e apigee-watcher:

         Produzione

         gcloud iam service-accounts list --project PROJECT_ID | grep "apigee-mart\|apigee-udca\|apigee-watcher"

         L'output dovrebbe essere simile al seguente:

         apigee-mart      [e-mail]      False
         apigee-udca      [e-mail]      False
         apigee-watcher   [e-mail]   False
         

         Se utilizzi la monetizzazione per Apigee Hybrid, recupera anche l'indirizzo email del account di servizio apigee-mint-task-scheduler.

         gcloud iam service-accounts list --project PROJECT_ID | grep "apigee-mint-task-scheduler"

         L'output dovrebbe essere simile al seguente:

         apigee-mint-task-scheduler   [e-mail]   False
         

         Non di produzione

         gcloud iam service-accounts list --project PROJECT_ID | grep "apigee-non-prod"

         L'output dovrebbe essere simile al seguente:

         apigee-non-prod     [e-mail]         False
                           

      2. Elenca i service account Kubernetes con ambito organizzazione:

         kubectl get serviceaccount -n APIGEE_NAMESPACE | grep "apigee-connect-agent\|apigee-mart\|apigee-udca\|apigee-watcher"

         L'output dovrebbe essere simile al seguente:

         apigee-connect-agent-my-project-123abcd         0   1h4m
         apigee-mart-my-project-123abcd                  0   1h4m
         apigee-mint-task-scheduler-my-project-123abcd   0   1h3m
         apigee-udca-my-project-123abcd                  0   1h2m
         apigee-watcher-my-project-123abcd               0   1h1m
                       

      3. Utilizza i seguenti comandi per concedere agli account di servizio Kubernetes con ambito organizzazione l'accesso per rappresentare gli account di servizio IAM associati nel seguente modo:

         Produzione

         Connetti l'agente KSA:il account di servizio Kubernetes apigee-connect-agent-ORG_NAME-ORG_HASH_ID al account di servizio IAM apigee-mart.

         Codice

         gcloud iam service-accounts add-iam-policy-binding \
           APIGEE_MART_SA_EMAIL \
             --member="principal://iam.googleapis.com/projects/PROJECT_NUMBER/locations/global/workloadIdentityPools/POOL_ID/subject/MAPPED_SUBJECT" \
             --role=roles/iam.workloadIdentityUser

         Esempio

         gcloud iam service-accounts add-iam-policy-binding \
           [e-mail] \
             --member="principal://iam.googleapis.com/projects/1234567890/locations/global/workloadIdentityPools/my-pool/subject/system:serviceaccount:apigee:apigee-connect-agent-my-org-123abcd" \
             --role=roles/iam.workloadIdentityUser

         MART KSA: account di servizio Kubernetes a account di servizio IAM apigee-mart-ORG_NAME-ORG_HASH_ID.apigee-mart L'agente MART e l'agente Connect utilizzano lo stesso account di servizio IAM.

         Codice

         gcloud iam service-accounts add-iam-policy-binding \
           APIGEE_MART_SA_EMAIL \
             --member="principal://iam.googleapis.com/projects/PROJECT_NUMBER/locations/global/workloadIdentityPools/POOL_ID/subject/MAPPED_SUBJECT" \
             --role=roles/iam.workloadIdentityUser

         Esempio

         gcloud iam service-accounts add-iam-policy-binding \
           [e-mail] \
             --member="principal://iam.googleapis.com/projects/1234567890/locations/global/workloadIdentityPools/my-pool/subject/system:serviceaccount:apigee:apigee-mart-my-org-123abcd" \
             --role=roles/iam.workloadIdentityUser

         Utilità di pianificazione delle attività Mint KSA: (se utilizzi Monetizzazione per Apigee Hybrid)

         apigee-mint-task-scheduler-ORG_NAME-ORG_HASH_ID account di servizio Kubernetes al account di servizio IAM.apigee-mint-task-scheduler

         Codice

         gcloud iam service-accounts add-iam-policy-binding \
           APIGEE_MINT_TASK_SCHEDULER_SA_EMAIL \
             --member="principal://iam.googleapis.com/projects/PROJECT_NUMBER/locations/global/workloadIdentityPools/POOL_ID/subject/MAPPED_SUBJECT" \
             --role=roles/iam.workloadIdentityUser

         Esempio

         gcloud iam service-accounts add-iam-policy-binding \
           [e-mail] \
             --member="principal://iam.googleapis.com/projects/1234567890/locations/global/workloadIdentityPools/my-pool/subject/system:serviceaccount:apigee:apigee-mint-task-scheduler-my-org-123abcd" \
             --role=roles/iam.workloadIdentityUser

         KSA UDCA con ambito organizzazione:account di servizio Kubernetes apigee-udca-ORG_NAME-ORG_HASH_ID al account di servizio IAM apigee-udca.

         Codice

         gcloud iam service-accounts add-iam-policy-binding \
           APIGEE_UDCA_SA_EMAIL \
             --member="principal://iam.googleapis.com/projects/PROJECT_NUMBER/locations/global/workloadIdentityPools/POOL_ID/subject/MAPPED_SUBJECT" \
             --role=roles/iam.workloadIdentityUser

         Esempio

         gcloud iam service-accounts add-iam-policy-binding \
           [e-mail] \
             --member="principal://iam.googleapis.com/projects/1234567890/locations/global/workloadIdentityPools/my-pool/subject/system:serviceaccount:apigee:apigee-udca-my-org-123abcd" \
             --role=roles/iam.workloadIdentityUser

         Watcher KSA: apigee-watcher-ORG_NAME-ORG_HASH_ID account di servizio Kubernetes a apigee-watcher account di servizio IAM.

         Codice

         gcloud iam service-accounts add-iam-policy-binding \
           APIGEE_WATCHER_SA_EMAIL \
             --member="principal://iam.googleapis.com/projects/PROJECT_NUMBER/locations/global/workloadIdentityPools/POOL_ID/subject/MAPPED_SUBJECT" \
             --role=roles/iam.workloadIdentityUser

         Esempio

         gcloud iam service-accounts add-iam-policy-binding \
           [e-mail] \
             --member="principal://iam.googleapis.com/projects/1234567890/locations/global/workloadIdentityPools/my-pool/subject/system:serviceaccount:apigee:apigee-watcher-my-org-123abcd" \
             --role=roles/iam.workloadIdentityUser

         Non di produzione

         Connetti l'agente KSA:il account di servizio Kubernetes apigee-connect-agent-ORG_NAME-ORG_HASH_ID al account di servizio IAM apigee-non-prod.

         Codice

         gcloud iam service-accounts add-iam-policy-binding \
           NON_PROD_IAM_SA_EMAIL \
             --member="principal://iam.googleapis.com/projects/PROJECT_NUMBER/locations/global/workloadIdentityPools/POOL_ID/subject/MAPPED_SUBJECT" \
             --role=roles/iam.workloadIdentityUser

         Esempio

         gcloud iam service-accounts add-iam-policy-binding \
           [e-mail] \
             --member="principal://iam.googleapis.com/projects/1234567890/locations/global/workloadIdentityPools/my-pool/subject/system:serviceaccount:apigee:apigee-connect-agent-my-org-123abcd" \
             --role=roles/iam.workloadIdentityUser

         MART KSA: account di servizio Kubernetes a account di servizio IAM apigee-mart-ORG_NAME-ORG_HASH_ID.apigee-non-prod

         Codice

         gcloud iam service-accounts add-iam-policy-binding \
           NON_PROD_IAM_SA_EMAIL \
             --member="principal://iam.googleapis.com/projects/PROJECT_NUMBER/locations/global/workloadIdentityPools/POOL_ID/subject/MAPPED_SUBJECT" \
             --role=roles/iam.workloadIdentityUser

         Esempio

         gcloud iam service-accounts add-iam-policy-binding \
           [e-mail] \
             --member="principal://iam.googleapis.com/projects/1234567890/locations/global/workloadIdentityPools/my-pool/subject/system:serviceaccount:apigee:apigee-mart-my-org-123abcd" \
             --role=roles/iam.workloadIdentityUser

         Utilità di pianificazione delle attività Mint KSA: (se utilizzi Monetizzazione per Apigee Hybrid)

         apigee-mint-task-scheduler-ORG_NAME-UUIORG_HASH_IDD account di servizio Kubernetes al account di servizio IAM.apigee-non-prod

         Codice

         gcloud iam service-accounts add-iam-policy-binding \
           NON_PROD_IAM_SA_EMAIL \
             --member="principal://iam.googleapis.com/projects/PROJECT_NUMBER/locations/global/workloadIdentityPools/POOL_ID/subject/MAPPED_SUBJECT" \
             --role=roles/iam.workloadIdentityUser

         Esempio

         gcloud iam service-accounts add-iam-policy-binding \
           [e-mail] \
             --member="principal://iam.googleapis.com/projects/1234567890/locations/global/workloadIdentityPools/my-pool/subject/system:serviceaccount:apigee:apigee-mint-task-scheduler-my-org-123abcd" \
             --role=roles/iam.workloadIdentityUser

         KSA UDCA con ambito organizzazione:account di servizio Kubernetes apigee-udca-ORG_NAME-ORG_HASH_ID al account di servizio IAM apigee-non-prod.

         Codice

         gcloud iam service-accounts add-iam-policy-binding \
           NON_PROD_IAM_SA_EMAIL \
             --member="principal://iam.googleapis.com/projects/PROJECT_NUMBER/locations/global/workloadIdentityPools/POOL_ID/subject/MAPPED_SUBJECT" \
             --role=roles/iam.workloadIdentityUser

         Esempio

         gcloud iam service-accounts add-iam-policy-binding \
           [e-mail] \
             --member="principal://iam.googleapis.com/projects/1234567890/locations/global/workloadIdentityPools/my-pool/subject/system:serviceaccount:apigee:apigee-udca-my-org-123abcd" \
             --role=roles/iam.workloadIdentityUser

         Watcher KSA: apigee-watcher-ORG_NAME-ORG_HASH_ID account di servizio Kubernetes a apigee-non-prod account di servizio IAM.

         Codice

         gcloud iam service-accounts add-iam-policy-binding \
           NON_PROD_IAM_SA_EMAIL \
             --member="principal://iam.googleapis.com/projects/PROJECT_NUMBER/locations/global/workloadIdentityPools/POOL_ID/subject/MAPPED_SUBJECT" \
             --role=roles/iam.workloadIdentityUser

         Esempio

         gcloud iam service-accounts add-iam-policy-binding \
           [e-mail] \
             --member="principal://iam.googleapis.com/projects/1234567890/locations/global/workloadIdentityPools/my-pool/subject/system:serviceaccount:apigee:apigee-watcher-my-org-123abcd" \
             --role=roles/iam.workloadIdentityUser

8. Installa l'ambiente.

   Devi installare un ambiente alla volta. Specifica l'ambiente con --set env=ENV_NAME. Se hai impostato la variabile di ambiente $ENV_NAME nella shell, puoi utilizzarla nei comandi seguenti:

   1. Prova:

      helm upgrade ENV_RELEASE_NAME apigee-env/ \
        --install \
        --namespace APIGEE_NAMESPACE \
        --atomic \
        --set env=$ENV_NAME \
        -f overrides.yaml \
        --dry-run=server
      

      ENV_RELEASE_NAME è un nome utilizzato per tenere traccia dell'installazione e degli 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 il tuo ambiente ha lo stesso nome del tuo 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.

   2. Installa il grafico:

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

   3. Verifica che sia attivo e funzionante controllando lo stato dell'ambiente corrispondente:

      kubectl -n APIGEE_NAMESPACE get apigeeenv
      

      NAME                       STATE     AGE   GATEWAYTYPE
      apigee-my-project-my-env   running   3m1s
      

   4. Concedi agli account di servizio Kubernetes con ambito ambiente l'accesso per rappresentare gli account di servizio IAM associati.
      1. Elenca l'indirizzo email dei service account IAM utilizzati dai componenti apigee-runtime, apigee-synchronizer e apigee-udca:

         Produzione

         gcloud iam service-accounts list --project PROJECT_ID | grep "apigee-runtime\|apigee-synchronizer\|apigee-udca"

         Non di produzione

         gcloud iam service-accounts list --project PROJECT_ID | grep "apigee-non-prod"

         gcloud iam service-accounts list --project PROJECT_ID | grep "apigee-mart\|apigee-udca\|apigee-watcher"

         L'output dovrebbe essere simile al seguente:

         Produzione

         apigee-runtime         [e-mail]         False
         apigee-synchronizer    [e-mail]      False
         apigee-udca            [e-mail]         False
                           

         Non di produzione

         apigee-non-prod     [e-mail]         False
                           

      2. Elenca i service account Kubernetes con ambito ambiente:

         kubectl get serviceaccount -n APIGEE_NAMESPACE | grep "apigee-runtime\|apigee-synchronizer\|apigee-udca"

         L'output dovrebbe essere simile al seguente:

         apigee-runtime-my-project--my-env-cdef123          0   19m
         apigee-synchronizer-my-project-my-env-cdef123      0   17m
         apigee-udca-my-project-123abcd                     0   1h29m
         apigee-udca-my-project-my-env-cdef123              0   22m
                       

         Nota:potresti visualizzare account di servizio Kubernetes apigee-udca con ambito organizzazione e con ambito ambiente. In questo passaggio, concedi l'accesso al service account apigee-udca con ambito ambiente.
      3. Utilizza questo comando per concedere ai service account Kubernetes con ambito ambiente l'accesso per rappresentare i service account IAM associati nel seguente modo:

         Produzione

         Runtime KSA: apigee-runtime-PROJECT_ID-ENV_NAME-ENV_HASH_ID-sa KSA to apigee-runtime Google IAM SA

         Codice

         gcloud iam service-accounts add-iam-policy-binding \
           RUNTIME_IAM_SA_EMAIL \
             --member="principal://iam.googleapis.com/projects/PROJECT_NUMBER/locations/global/workloadIdentityPools/POOL_ID/subject/MAPPED_SUBJECT" \
             --role=roles/iam.workloadIdentityUser

         Esempio

         gcloud iam service-accounts add-iam-policy-binding \
           [e-mail] \
             --member="principal://iam.googleapis.com/projects/1234567890/locations/global/workloadIdentityPools/my-pool/subject/system:serviceaccount:apigee:apigee-runtime-my-project-my-env-cdef123" \
             --role=roles/iam.workloadIdentityUser

         Synchronizer KSA: apigee-synchronizer-PROJECT_ID-ENV_NAME-ENV_HASH_ID-sa KSA to apigee-synchronizer Google IAM SA

         Codice

         gcloud iam service-accounts add-iam-policy-binding \
           SYNCHRONIZER_IAM_SA_EMAIL \
             --member="principal://iam.googleapis.com/projects/PROJECT_NUMBER/locations/global/workloadIdentityPools/POOL_ID/subject/MAPPED_SUBJECT" \
             --role=roles/iam.workloadIdentityUser

         Esempio

         gcloud iam service-accounts add-iam-policy-binding \
           [e-mail] \
             --member="principal://iam.googleapis.com/projects/1234567890/locations/global/workloadIdentityPools/my-pool/subject/system:serviceaccount:apigee:apigee-synchronizer-my-project-my-env-cdef123" \
             --role=roles/iam.workloadIdentityUser

         UDCA KSA: apigee-udca-PROJECT_ID-ENV_NAME-ENV_HASH_ID-sa KSA to apigee-udca Google IAM SA

         Codice

         gcloud iam service-accounts add-iam-policy-binding \
           UDCA_IAM_SA_EMAIL \
             --member="principal://iam.googleapis.com/projects/PROJECT_NUMBER/locations/global/workloadIdentityPools/POOL_ID/subject/MAPPED_SUBJECT" \
             --role=roles/iam.workloadIdentityUser

         Esempio

         gcloud iam service-accounts add-iam-policy-binding \
           [e-mail] \
             --member="principal://iam.googleapis.com/projects/1234567890/locations/global/workloadIdentityPools/my-pool/subject/system:serviceaccount:apigee:apigee-udca-my-project-my-env-cdef123" \
             --role=roles/iam.workloadIdentityUser

         Non di produzione

         Runtime KSA: apigee-runtime-PROJECT_ID-ENV_NAME-ENV_HASH_ID-sa KSA to apigee-non-prod Google IAM SA

         Codice

         gcloud iam service-accounts add-iam-policy-binding \
           NON_PROD_IAM_SA_EMAIL \
             --member="principal://iam.googleapis.com/projects/PROJECT_NUMBER/locations/global/workloadIdentityPools/POOL_ID/subject/MAPPED_SUBJECT" \
             --role=roles/iam.workloadIdentityUser

         Esempio

         gcloud iam service-accounts add-iam-policy-binding \
           [e-mail] \
             --member="principal://iam.googleapis.com/projects/1234567890/locations/global/workloadIdentityPools/my-pool/subject/system:serviceaccount:apigee:apigee-runtime-my-project-my-env-cdef123" \
             --role=roles/iam.workloadIdentityUser

         Non di produzione

         Synchronizer KSA: apigee-synchronizer-PROJECT_ID-ENV_NAME-ENV_HASH_ID-sa KSA to apigee-non-prod Google IAM SA

         Codice

         gcloud iam service-accounts add-iam-policy-binding \
           NON_PROD_IAM_SA_EMAIL \
             --member="principal://iam.googleapis.com/projects/PROJECT_NUMBER/locations/global/workloadIdentityPools/POOL_ID/subject/MAPPED_SUBJECT" \
             --role=roles/iam.workloadIdentityUser

         Esempio

         gcloud iam service-accounts add-iam-policy-binding \
           [e-mail] \
             --member="principal://iam.googleapis.com/projects/1234567890/locations/global/workloadIdentityPools/my-pool/subject/system:serviceaccount:apigee:apigee-synchronizer-my-project-my-env-cdef123" \
             --role=roles/iam.workloadIdentityUser

         Non di produzione

         UDCA KSA: apigee-udca-PROJECT_ID-ENV_NAME-ENV_HASH_ID-sa KSA to apigee-non-prod Google IAM SA

         Codice

         gcloud iam service-accounts add-iam-policy-binding \
           NON_PROD_IAM_SA_EMAIL \
             --member="principal://iam.googleapis.com/projects/PROJECT_NUMBER/locations/global/workloadIdentityPools/POOL_ID/subject/MAPPED_SUBJECT" \
             --role=roles/iam.workloadIdentityUser

         Esempio

         gcloud iam service-accounts add-iam-policy-binding \
           [e-mail] \
             --member="principal://iam.googleapis.com/projects/1234567890/locations/global/workloadIdentityPools/my-pool/subject/system:serviceaccount:apigee:apigee-udca-my-project-my-env-cdef123" \
             --role=roles/iam.workloadIdentityUser

9. Installa i gruppi di ambienti (virtualhosts).
   1. Devi installare un gruppo di ambienti (virtualhost) alla volta. Specifica il gruppo di ambienti con --set envgroup=ENV_GROUP. Se hai impostato la variabile di ambiente $ENV_GROUP nella shell, puoi utilizzarla nei comandi seguenti. Ripeti i seguenti comandi per ogni gruppo di ambienti menzionato nel file overrides.yaml:

      Prova:

      helm upgrade ENV_GROUP_RELEASE_NAME apigee-virtualhost/ \
        --install \
        --namespace APIGEE_NAMESPACE \
        --atomic \
        --set envgroup=$ENV_GROUP \
        -f overrides.yaml \
        --dry-run=server
      

      ENV_GROUP_RELEASE_NAME è un nome utilizzato per tenere traccia dell'installazione e degli upgrade del grafico apigee-virtualhosts. Questo nome deve essere univoco rispetto agli altri nomi delle release Helm nell'installazione. Di solito è uguale a ENV_GROUP. Tuttavia, se il gruppo di ambienti ha lo stesso nome di un ambiente nell'installazione, devi utilizzare nomi di release diversi per il gruppo di ambienti e l'ambiente, ad esempio dev-envgroup-release e dev-env-release. Per saperne di più sulle release in Helm, consulta la sezione Tre concetti importanti nella documentazione di Helm.

   2. Installa il grafico:

      helm upgrade ENV_GROUP_RELEASE_NAME apigee-virtualhost/ \
        --install \
        --namespace APIGEE_NAMESPACE \
        --atomic \
        --set envgroup=$ENV_GROUP \
        -f overrides.yaml
      

      Nota: ENV_GROUP deve essere univoco all'interno dello spazio dei nomi apigee. Ad esempio, se hai un ambiente prod e un gruppo di ambienti, devi impostare questo nome su prod-envgroup. Il nome del gruppo di ambienti successivo deve comunque essere prod.
   3. Controlla lo stato di ApigeeRoute (AR).

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

      kubectl -n APIGEE_NAMESPACE get arc
      

      NAME                                STATE   AGE
      apigee-org1-dev-egroup                       2m
      

      kubectl -n APIGEE_NAMESPACE get ar
      

      NAME                                                        STATE     AGE
      apigee-ingressgateway-internal-chaining-my-project-123abcd   running   19m
      my-project-myenvgroup-000-321dcba                            running   2m30s
      

Congratulazioni!

Hai installato e configurato correttamente il piano di runtime di Apigee hybrid.

Passaggio successivo

Nel passaggio successivo, configurerai il gateway di ingresso Apigee e implementerai un proxy per testare l'installazione.

(AVANTI) Passaggio 1: esponi l'ingresso Apigee 2