Passaggio 8: installa il runtime di hybrid

Attualmente stai visualizzando la versione 1.9 della documentazione di Apigee hybrid. This version is end of life. You should upgrade to a newer version. Per ulteriori informazioni, consulta Versioni supportate.

Version 1.9 (unsupported)

   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                                         

Applica la configurazione al cluster.

Per installare Apigee hybrid nel cluster:

1. Assicurati di trovarti nella directory hybrid-base-directory/hybrid-files.

   cd $HYBRID_FILES

   Nota:poiché il file di override specifica i file del account di servizio utilizzando percorsi relativi alla directory hybrid-base-directory/hybrid-files, devi eseguire i comandi dall'interno di questa directory.
2. Verifica che kubectl sia impostato sul contesto corretto utilizzando il seguente comando. Il contesto attuale deve essere impostato sul cluster in cui stai eseguendo il deployment di Apigee hybrid.

   kubectl config current-context

   Il risultato deve includere il nome del cluster in cui stai eseguendo il deployment di Apigee Hybrid. Ad esempio, su GKE, il nome del contesto è in genere nel formato gke_project-id_cluster-location_cluster-name, come in:

   gke_my-project_us-central1_my-cluster

   Se il nome del cluster nel contesto non corrisponde, il seguente comando recupererà le credenziali gcloud del cluster e imposterà il contesto kubectl:

   Cluster a livello di regione

   gcloud container clusters get-credentials $CLUSTER_NAME \
   --region $CLUSTER_LOCATION \
   --project $PROJECT_ID

   Cluster di zona

   gcloud container clusters get-credentials $CLUSTER_NAME \
   --zone $CLUSTER_LOCATION \
   --project $PROJECT_ID

3. Solo per le piattaforme Anthos on bare metal, AWS su GKE, EKS e GKE on-prem, verifica che la variabile KUBECONFIG sia impostata utilizzando il seguente comando:

   echo ${KUBECONFIG}

4. Esegui l'inizializzazione di un dry run. L'esecuzione di una prova generale consente di verificare la presenza di errori prima che vengano apportate modifiche al cluster. Esegui il comando init con il flag --dry-run come segue:

   ${APIGEECTL_HOME}/apigeectl init -f overrides/overrides.yaml --dry-run=client

5. Se non sono presenti errori, esegui il comando init come segue:

   ${APIGEECTL_HOME}/apigeectl init -f overrides/overrides.yaml

   Il comando init installa Apigee deployment services, Apigee Deployment Controller e Apigee Admission Webhook.

6. Per controllare lo stato del deployment, puoi utilizzare i seguenti comandi:

   ${APIGEECTL_HOME}/apigeectl check-ready -f overrides/overrides.yaml

   kubectl get pods -n apigee-system

   kubectl get pods -n apigee

   Quando i pod sono pronti, vai al passaggio successivo.

7. Esegui un'installazione dry run. Esegui il comando apply con il flag --dry-run.

   ${APIGEECTL_HOME}/apigeectl apply -f overrides/overrides.yaml --dry-run=client

8. Se non ci sono errori, puoi applicare i componenti di runtime specifici di Apigee al cluster con il seguente comando:

   ${APIGEECTL_HOME}/apigeectl apply -f overrides/overrides.yaml

9. Per controllare lo stato del deployment, esegui questo comando:

   ${APIGEECTL_HOME}/apigeectl check-ready -f overrides/overrides.yaml

   Ripeti questo passaggio finché tutti i pod non sono pronti. L'avvio dei pod potrebbe richiedere diversi minuti.

   Nota:se configuri il file di override in modo da utilizzare Workload Identity su GKE, potresti visualizzare un errore che indica che apigeeenvironment non è in esecuzione. Continua con i passaggi della sezione successiva. check-ready mostrerà l'ambiente Apigee in esecuzione dopo aver completato i passaggi per attivare Workload Identity.

GKE con Workload Identity

Nota:Apigee hybrid v.1.9 supporta solo la federazione delle identità per i carichi di lavoro su GKE.

Se utilizzi Workload Identity su GKE, segui queste istruzioni per associare i service account Kubernetes creati da apigeectl ai service account Google che hai creato nel passaggio 4: crea service account e credenziali.

Queste procedure utilizzano le seguenti variabili di ambiente. Imposta questi valori nella shell dei comandi o sostituiscili negli esempi di codice con i valori effettivi:

• APIGEECTL_HOME: la directory in cui hai installato apigeectl.
• CLUSTER_LOCATION: la regione o la zona del tuo cluster, ad esempio: us-west1.
• CLUSTER_LOCATION: il nome del cluster.
• ENV_NAME: il nome dell'ambiente Apigee.
• NAMESPACE: il tuo spazio dei nomi Apigee. Per impostazione predefinita, apigee.
• HYBRID_FILES: la directory dei file ibridi, ad esempio hybrid-base-directory/hybrid-files.
• ORG_NAME: il nome della tua organizzazione Apigee.
• PROJECT_ID: l'ID del tuo progetto Google Cloud.

Verifica le variabili di ambiente:

echo $APIGEECTL_HOME
echo $CLUSTER_LOCATION
echo $ENV_NAME
echo $HYBRID_FILES
echo $NAMESPACE
echo $ORG_NAME
echo $PROJECT_ID

Inizializza le variabili che ti servono:

export APIGEECTL_HOME=hybrid-base-directory/apigeectl
export CLUSTER_LOCATION=my-cluster-location
export ENV_NAME=my-environment-name
export HYBRID_FILES=hybrid-base-directory/hybrid-files
export NAMESPACE=apigee
export ORG_NAME=$PROJECT_ID
export PROJECT_ID=my-project-id

1. (Facoltativo) Elimina i file delle chiavi del account di servizio.

   Quando esegui Apigee Hybrid su GKE, la prassi standard è creare e scaricare chiavi private (file .json) per ciascuno dei service account. Quando utilizzi Workload Identity, non devi scaricare le chiavi private del account di servizio e aggiungerle ai cluster GKE.

   Puoi eliminare i file delle chiavi con il seguente comando:

   rm $HYBRID_FILES/service-accounts/*.json

2. Verifica che la configurazione gcloud corrente sia impostata sull'ID progetto Google Cloud con il seguente comando:

   gcloud config get project

Se necessario, imposta la configurazione gcloud attuale:

gcloud config set project $PROJECT_ID

3. Crea il account di servizio Kubernetes apigee-cassandra-restore.

   Quando hai applicato la configurazione eseguendo apigeectl apply, il comando ha creato la maggior parte dei service account Kubernetes necessari per Workload Identity.

   Per creare il account di servizio Kubernetes apigee-cassandra-restore, esegui apigeectl apply con il flag --restore:

   $APIGEECTL_HOME/apigeectl apply -f $HYBRID_FILES/overrides/overrides.yaml --restore

4. Verifica che Workload Identity sia abilitato per il tuo cluster GKE. Quando hai creato il cluster nel passaggio 1: crea un cluster, il passaggio 6 consisteva nell'abilitare Workload Identity. Puoi verificare se Workload Identity è abilitata eseguendo il seguente comando:

   Cluster a livello di regione

   gcloud container clusters describe $CLUSTER_NAME \
     --region $CLUSTER_LOCATION \
     --project $PROJECT_ID \
     --flatten 'workloadIdentityConfig'

   Cluster di zona

   gcloud container clusters describe $CLUSTER_NAME \
     --zone $CLUSTER_LOCATION \
     --project $PROJECT_ID \
     --flatten 'workloadIdentityConfig'

   Se Workload Identity è abilitato per il cluster, l'output dovrebbe essere simile al seguente:

     ---
     workloadPool: PROJECT_ID.svc.id.goog

   Se nei risultati visualizzi null, esegui questo comando per abilitare Workload Identity per il cluster:

   Cluster a livello di regione

   gcloud container clusters update $CLUSTER_NAME \
     --workload-pool=$PROJECT_ID.svc.id.goog \
     --project $PROJECT_ID \
     --region $CLUSTER_LOCATION

   Cluster di zona

   gcloud container clusters update  $CLUSTER_NAME \
     --workload-pool=$PROJECT_ID.svc.id.goog \
     --zone $CLUSTER_LOCATION \
     --project $PROJECT_ID

5. Verifica che Workload Identity sia abilitato nei pool di nodi con i seguenti comandi:

   Cluster a livello di regione

   gcloud container node-pools describe apigee-data \
     --cluster $CLUSTER_NAME \
     --region $CLUSTER_LOCATION \
     --project $PROJECT_ID \
     --flatten "config:"

   gcloud container node-pools describe apigee-runtime \
     --cluster $CLUSTER_NAME \
     --region $CLUSTER_LOCATION \
     --project $PROJECT_ID \
     --flatten "config:"

   Cluster di zona

   gcloud container node-pools describe apigee-data \
     --cluster $CLUSTER_NAME \
     --zone $CLUSTER_LOCATION \
     --project $PROJECT_ID \
     --flatten "config:"

   gcloud container node-pools describe apigee-runtime \
     --cluster $CLUSTER_NAME \
     --zone $CLUSTER_LOCATION \
     --project $PROJECT_ID \
     --flatten "config:"

   L'output dovrebbe essere simile a questo:

   ---
   diskSizeGb: 100
   diskType: pd-standard
   ...
   workloadMetadataConfig:
     mode: GKE_METADATA
       

   Se l'output non contiene una riga per workloadMetadataConfig:, abilita Workload Identity per ogni pool di nodi con i seguenti comandi. Questa operazione può richiedere fino a 30 minuti:

   Cluster a livello di regione

   gcloud container node-pools update NODE_POOL_NAME \
     --cluster=$CLUSTER_NAME \
     --region $CLUSTER_LOCATION \
     --project $PROJECT_ID \
     --workload-metadata=GKE_METADATA

   Cluster di zona

   gcloud container node-pools update NODE_POOL_NAME \
     --cluster=$CLUSTER_NAME \
     --zone $CLUSTER_LOCATION \
     --project $PROJECT_ID \
     --workload-metadata=GKE_METADATA

   dove NODE_POOL_NAME è il nome di ogni pool di nodi. Nella maggior parte delle installazioni di Apigee Hybrid, i due pool di nodi predefiniti sono denominati apigee-data e apigee-runtime.

6. Controlla i nomi dei service account Google per il tuo progetto con il seguente comando:

   gcloud iam service-accounts list --project $PROJECT_ID

   L'output dovrebbe essere simile a questo:

   Non di produzione

   Per gli ambienti non di produzione:

   DISPLAY NAME         EMAIL                                                      DISABLED
   apigee-non-prod      apigee-non-prod@my_project_id.iam.gserviceaccount.com      False
   

   Prod

   Per gli ambienti non di produzione:

   DISPLAY NAME         EMAIL                                                      DISABLED
   apigee-cassandra     apigee-cassandra@my_project_id.iam.gserviceaccount.com     False
   apigee-logger        apigee-logger@my_project_id.iam.gserviceaccount.com        False
   apigee-mart          apigee-mart@my_project_id.iam.gserviceaccount.com          False
   apigee-metrics       apigee-metrics@my_project_id.iam.gserviceaccount.com       False
   apigee-runtime       apigee-runtime@my_project_id.iam.gserviceaccount.com       False
   apigee-synchronizer  apigee-synchronizer@my_project_id.iam.gserviceaccount.com  False
   apigee-udca          apigee-udca@my_project_id.iam.gserviceaccount.com          False
   apigee-watcher       apigee-watcher@my_project_id.iam.gserviceaccount.com       False
   

   Suggerimento:se hai nomi personalizzati per i tuoi service account che non corrispondono facilmente ai nomi dei componenti Apigee, puoi determinare il ruolo di ogni account di servizio controllando i ruoli assegnati e confrontandoli con i ruoli consigliati in Informazioni sui service account.

   Utilizza questo comando per controllare i ruoli assegnati a un account di servizio:

   gcloud projects get-iam-policy ${PROJECT_ID}  \
     --flatten="bindings[].members" \
     --format='table(bindings.role)' \
     --filter="SERVICE_ACCOUNT_NAME"

7. Verifica i service account con il seguente comando:

   kubectl get sa -n $NAMESPACE

   L'output dovrebbe essere simile al seguente. I service account Kubernetes in grassetto sono quelli che dovrai annotare con i tuoi service account Google:

   NAME                                                         SECRETS   AGE
   apigee-cassandra-backup                                      1         11m
   apigee-cassandra-restore                                     1         11m
   apigee-cassandra-schema-setup-my-project-id-123abcd-sa       1         11m
   apigee-cassandra-schema-val-my-project-id-123abcd            1         11m
   apigee-cassandra-user-setup-my-project-id-123abcd-sa         1         11m
   apigee-connect-agent-my-project-id-123abcd-sa                1         11m
   apigee-datastore-default-sa                                  1         11m
   apigee-ingressgateway                                        1         11m
   apigee-ingressgateway-my-project-id-123abcd                  1         11m
   apigee-ingressgateway-manager                                1         11m
   apigee-init                                                  1         11m
   apigee-mart-my-project-id-123abcd-sa                         1         11m
   apigee-metrics-sa                                            1         11m
   apigee-mint-task-scheduler-my-project-id-123abcd-sa          1         11m
   apigee-redis-default-sa                                      1         11m
   apigee-redis-envoy-default-sa                                1         11m
   apigee-runtime-my-project-id-env-name-234bcde-sa             1         11m
   apigee-synchronizer-my-project-id-env-name-234bcde-sa        1         11m
   apigee-udca-my-project-id-123abcd-sa                         1         11m
   apigee-udca-my-project-id-env-name-234bcde-sa                1         11m
   apigee-watcher-my-project-id-123abcd-sa                      1         11m
   default                                                      1         11m
       

8. Per ogni componente Apigee, annota i service account Kubernetes corrispondenti con il account di servizio Google per il componente.
   IMPORTANTE:se i nomi dei account di servizio non corrispondono a quelli predefiniti creati da create-service-account, sostituisci il nomaccount di serviziont rosso con il nome corretto deaccount di serviziont per il componente nei seguenti comandi. Ad esempio, se il tuo account di servizio Cassandra si chiama my-cassandra-accnt-1, sostituisci apigee-cassandra con questo nome nel comando.

   I seguenti passaggi utilizzano due variabili di ambiente. Reimposterai i valori di queste variabili prima di ogni insieme di comandi:

   • GSA_NAME: il nome di un account di servizio Google. Si tratta degli account di servizio che hai creato con lo strumento create-service-account nel passaggio 4: crea service account.
   • KSA_NAME: il nome di un account di servizio Kubernetes. Questi sono gli account che hai elencato sopra con il comando kubectl get sa -n $NAMESPACE, ad esempio: apigee-cassandra-schema-setup-hybrid-example-project-123abcd-sa.
   Suggerimento: se viene visualizzato un errore che indica che il account di servizio "NON È STATO TROVATO", prova a eseguire gcloud init per impostare la configurazione corrente sull'ID progetto Google Cloud e sulla posizione del cluster corretti.
• Cassandra

  Il componente Cassandra ha sei service account Kubernetes associati:

  • apigee-cassandra-backup
  • apigee-cassandra-restore
  • apigee-cassandra-schema-setup
  • apigee-cassandra-schema-val (val = convalida)
  • apigee-cassandra-user-setup
  • apigee-datastore-default

  Non di produzione

  I seguenti passaggi utilizzano due variabili di ambiente. Reimposterai i valori di queste variabili prima di ogni insieme di comandi:

  • GSA_NAME: il nome di un account di servizio Google. Si tratta degli account di servizio che hai creato con lo strumento create-service-account nel passaggio 4: crea service account.
  • KSA_NAME: il nome di un account di servizio Kubernetes. Questi sono gli account che hai elencato sopra con il comando kubectl get sa -n $NAMESPACE.

  apigee-cassandra-backup Service account Kubernetes

  1. Definisci le variabili di ambiente KSA_NAME e GSA_NAME:

     GSA_NAME="apigee-non-prod"
     KSA_NAME="apigee-cassandra-backup"

  2. Associa il ruolo IAM:

     gcloud iam service-accounts add-iam-policy-binding \
       --role roles/iam.workloadIdentityUser \
       --member "serviceAccount:$PROJECT_ID.svc.id.goog[$NAMESPACE/$KSA_NAME]" \
       $GSA_NAME@$PROJECT_ID.iam.gserviceaccount.com \
       --project $PROJECT_ID

  3. Annota il account di servizio:

     kubectl annotate serviceaccount \
       --namespace $NAMESPACE $KSA_NAME iam.gke.io/gcp-service-account=$GSA_NAME@$PROJECT_ID.iam.gserviceaccount.com

  4. Verifica l'annotazione:

     kubectl describe serviceaccount \
       --namespace $NAMESPACE $KSA_NAME

     L'output dovrebbe contenere una riga che descrive l'annotazione, simile a questa:

     Annotations:         iam.gke.io/gcp-service-account: [e-mail]

  apigee-cassandra-restore Service account Kubernetes

  1. Ridefinisci la variabile di ambiente KSA_NAME:

     KSA_NAME="apigee-cassandra-restore"

  2. Associa il ruolo IAM:

     gcloud iam service-accounts add-iam-policy-binding \
       --role roles/iam.workloadIdentityUser \
       --member "serviceAccount:$PROJECT_ID.svc.id.goog[$NAMESPACE/$KSA_NAME]" \
       $GSA_NAME@$PROJECT_ID.iam.gserviceaccount.com \
       --project $PROJECT_ID

  3. Annota il account di servizio:

     kubectl annotate serviceaccount \
       --namespace $NAMESPACE $KSA_NAME iam.gke.io/gcp-service-account=$GSA_NAME@$PROJECT_ID.iam.gserviceaccount.com

  4. Verifica l'annotazione:

     kubectl describe serviceaccount \
       --namespace $NAMESPACE $KSA_NAME

  apigee-cassandra-schema-setup Service account Kubernetes

  1. Ridefinisci la variabile di ambiente KSA_NAME:

     KSA_NAME="apigee-cassandra-schema-setup-service-account-name-sa"

     ad esempio: apigee-cassandra-schema-setup-hybrid-example-project-123abcd-sa.
  2. Associa il ruolo IAM:

     gcloud iam service-accounts add-iam-policy-binding \
       --role roles/iam.workloadIdentityUser \
       --member "serviceAccount:$PROJECT_ID.svc.id.goog[$NAMESPACE/$KSA_NAME]" \
       $GSA_NAME@$PROJECT_ID.iam.gserviceaccount.com \
       --project $PROJECT_ID

  3. Annota il account di servizio:

     kubectl annotate serviceaccount \
       --namespace $NAMESPACE $KSA_NAME iam.gke.io/gcp-service-account=$GSA_NAME@$PROJECT_ID.iam.gserviceaccount.com

  4. Verifica l'annotazione:

     kubectl describe serviceaccount \
       --namespace $NAMESPACE $KSA_NAME

  apigee-cassandra-schema-val Service account Kubernetes

  1. Ridefinisci la variabile di ambiente KSA_NAME:

     KSA_NAME="apigee-cassandra-schema-val-service-account-name"

     ad esempio: apigee-cassandra-schema-val-hybrid-example-project-123abcd.
  2. Associa il ruolo IAM:

     gcloud iam service-accounts add-iam-policy-binding \
       --role roles/iam.workloadIdentityUser \
       --member "serviceAccount:$PROJECT_ID.svc.id.goog[$NAMESPACE/$KSA_NAME]" \
       $GSA_NAME@$PROJECT_ID.iam.gserviceaccount.com \
       --project $PROJECT_ID

  3. Annota il account di servizio:

     kubectl annotate serviceaccount \
       --namespace $NAMESPACE $KSA_NAME iam.gke.io/gcp-service-account=$GSA_NAME@$PROJECT_ID.iam.gserviceaccount.com

  4. Verifica l'annotazione:

     kubectl describe serviceaccount \
       --namespace $NAMESPACE $KSA_NAME

  apigee-cassandra-user-setup Service account Kubernetes

  1. Ridefinisci la variabile di ambiente KSA_NAME:

     KSA_NAME="apigee-cassandra-user-setup-service-account-name-sa"

     ad esempio: apigee-cassandra-user-setup-hybrid-example-project-123abcd-sa.
  2. Associa il ruolo IAM:

     gcloud iam service-accounts add-iam-policy-binding \
       --role roles/iam.workloadIdentityUser \
       --member "serviceAccount:$PROJECT_ID.svc.id.goog[$NAMESPACE/$KSA_NAME]" \
       $GSA_NAME@$PROJECT_ID.iam.gserviceaccount.com \
       --project $PROJECT_ID

  3. Annota il account di servizio:

     kubectl annotate serviceaccount \
       --namespace $NAMESPACE $KSA_NAME iam.gke.io/gcp-service-account=$GSA_NAME@$PROJECT_ID.iam.gserviceaccount.com

  4. Verifica l'annotazione:

     kubectl describe serviceaccount \
       --namespace $NAMESPACE $KSA_NAME

  apigee-datastore-default-sa Service account Kubernetes

  1. Ridefinisci la variabile di ambiente KSA_NAME:

     KSA_NAME="apigee-datastore-default-sa"

  2. Associa il ruolo IAM:

     gcloud iam service-accounts add-iam-policy-binding \
       --role roles/iam.workloadIdentityUser \
       --member "serviceAccount:$PROJECT_ID.svc.id.goog[$NAMESPACE/$KSA_NAME]" \
       $GSA_NAME@$PROJECT_ID.iam.gserviceaccount.com \
       --project $PROJECT_ID

  3. Annota il account di servizio:

     kubectl annotate serviceaccount \
       --namespace $NAMESPACE $KSA_NAME iam.gke.io/gcp-service-account=$GSA_NAME@$PROJECT_ID.iam.gserviceaccount.com

  4. Verifica l'annotazione:

     kubectl describe serviceaccount \
       --namespace $NAMESPACE $KSA_NAME

  Prod

  apigee-cassandra-backup Service account Kubernetes

  1. Definisci le variabili di ambiente KSA_NAME e GSA_NAME:

     GSA_NAME="apigee-cassandra"
     KSA_NAME="apigee-cassandra-backup"

  2. Associa il ruolo IAM:

     gcloud iam service-accounts add-iam-policy-binding \
       --role roles/iam.workloadIdentityUser \
       --member "serviceAccount:$PROJECT_ID.svc.id.goog[$NAMESPACE/$KSA_NAME]" \
       $GSA_NAME@$PROJECT_ID.iam.gserviceaccount.com \
       --project $PROJECT_ID

  3. Annota il account di servizio:

     kubectl annotate serviceaccount \
       --namespace $NAMESPACE $KSA_NAME iam.gke.io/gcp-service-account=$GSA_NAME@$PROJECT_ID.iam.gserviceaccount.com

  4. Verifica l'annotazione:

     kubectl describe serviceaccount \
       --namespace $NAMESPACE $KSA_NAME

  L'output dovrebbe contenere una riga che descrive l'annotazione, simile a questa:

  Annotations:         iam.gke.io/gcp-service-account: [e-mail]

  5. Verifica l'annotazione:

     kubectl describe serviceaccount \
       --namespace $NAMESPACE $KSA_NAME

  apigee-cassandra-restore Service account Kubernetes

  1. Ridefinisci la variabile di ambiente KSA_NAME:

     KSA_NAME="apigee-cassandra-restore"

  2. Associa il ruolo IAM:

     gcloud iam service-accounts add-iam-policy-binding \
       --role roles/iam.workloadIdentityUser \
       --member "serviceAccount:$PROJECT_ID.svc.id.goog[$NAMESPACE/$KSA_NAME]" \
       $GSA_NAME@$PROJECT_ID.iam.gserviceaccount.com \
       --project $PROJECT_ID

  3. Annota il account di servizio:

     kubectl annotate serviceaccount \
       --namespace $NAMESPACE $KSA_NAME iam.gke.io/gcp-service-account=$GSA_NAME@$PROJECT_ID.iam.gserviceaccount.com

  apigee-cassandra-schema-setup Service account Kubernetes

  1. Ridefinisci la variabile di ambiente KSA_NAME:

     KSA_NAME="apigee-cassandra-schema-setup-service-account-name-sa"

     ad esempio: apigee-cassandra-schema-setup-hybrid-example-project-123abcd-sa.

  Associa il ruolo IAM:

  gcloud iam service-accounts add-iam-policy-binding \
    --role roles/iam.workloadIdentityUser \
    --member "serviceAccount:$PROJECT_ID.svc.id.goog[$NAMESPACE/$KSA_NAME]" \
    $GSA_NAME@$PROJECT_ID.iam.gserviceaccount.com \
    --project $PROJECT_ID

  2. Annota il account di servizio:

     kubectl annotate serviceaccount \
       --namespace $NAMESPACE $KSA_NAME iam.gke.io/gcp-service-account=$GSA_NAME@$PROJECT_ID.iam.gserviceaccount.com

  3. Verifica l'annotazione:

     kubectl describe serviceaccount \
       --namespace $NAMESPACE $KSA_NAME

  apigee-cassandra-schema-val Service account Kubernetes

  1. Ridefinisci la variabile di ambiente KSA_NAME:

     KSA_NAME="apigee-cassandra-schema-val-service-account-name"

     ad esempio: apigee-cassandra-schema-val-hybrid-example-project-123abcd.
  2. Associa il ruolo IAM:

     gcloud iam service-accounts add-iam-policy-binding \
       --role roles/iam.workloadIdentityUser \
       --member "serviceAccount:$PROJECT_ID.svc.id.goog[$NAMESPACE/$KSA_NAME]" \
       $GSA_NAME@$PROJECT_ID.iam.gserviceaccount.com \
       --project $PROJECT_ID

  3. Annota il account di servizio:

     kubectl annotate serviceaccount \
       --namespace $NAMESPACE $KSA_NAME iam.gke.io/gcp-service-account=$GSA_NAME@$PROJECT_ID.iam.gserviceaccount.com

  4. Verifica l'annotazione:

     kubectl describe serviceaccount \
       --namespace $NAMESPACE $KSA_NAME

  apigee-cassandra-user-setup Service account Kubernetes

  1. Ridefinisci la variabile di ambiente KSA_NAME:

     KSA_NAME="apigee-cassandra-user-setup-service-account-name-sa"

     ad esempio: apigee-cassandra-user-setup-hybrid-example-project-123abcd-sa.
  2. Associa il ruolo IAM:

     gcloud iam service-accounts add-iam-policy-binding \
       --role roles/iam.workloadIdentityUser \
       --member "serviceAccount:$PROJECT_ID.svc.id.goog[$NAMESPACE/$KSA_NAME]" \
       $GSA_NAME@$PROJECT_ID.iam.gserviceaccount.com \
       --project $PROJECT_ID

  3. Annota il account di servizio:

     kubectl annotate serviceaccount \
       --namespace $NAMESPACE $KSA_NAME iam.gke.io/gcp-service-account=$GSA_NAME@$PROJECT_ID.iam.gserviceaccount.com

  4. Verifica l'annotazione:

     kubectl describe serviceaccount \
       --namespace $NAMESPACE $KSA_NAME

  apigee-datastore-default-sa Service account Kubernetes

  1. Ridefinisci la variabile di ambiente KSA_NAME:

     KSA_NAME="apigee-datastore-default-sa"

  2. Associa il ruolo IAM:

     gcloud iam service-accounts add-iam-policy-binding \
       --role roles/iam.workloadIdentityUser \
       --member "serviceAccount:$PROJECT_ID.svc.id.goog[$NAMESPACE/$KSA_NAME]" \
       $GSA_NAME@$PROJECT_ID.iam.gserviceaccount.com \
       --project $PROJECT_ID

  3. Annota il account di servizio:

     kubectl annotate serviceaccount \
       --namespace $NAMESPACE $KSA_NAME iam.gke.io/gcp-service-account=$GSA_NAME@$PROJECT_ID.iam.gserviceaccount.com

  4. Verifica l'annotazione:

     kubectl describe serviceaccount \
       --namespace $NAMESPACE $KSA_NAME

• Apigee Connect

  Non di produzione

  1. Definisci la variabile di ambiente KSA_NAME:

     KSA_NAME="apigee-connect-agent-service-account-name-sa"

     ad esempio: apigee-connect-agent-hybrid-example-project-123abcd-sa.
  2. Associa il ruolo IAM:

     gcloud iam service-accounts add-iam-policy-binding \
       --role roles/iam.workloadIdentityUser \
       --member "serviceAccount:$PROJECT_ID.svc.id.goog[$NAMESPACE/$KSA_NAME]" \
       $GSA_NAME@$PROJECT_ID.iam.gserviceaccount.com \
       --project $PROJECT_ID

  3. Annota il account di servizio:

     kubectl annotate serviceaccount \
       --namespace $NAMESPACE $KSA_NAME iam.gke.io/gcp-service-account=$GSA_NAME@$PROJECT_ID.iam.gserviceaccount.com

  4. Verifica l'annotazione:

     kubectl describe serviceaccount \
       --namespace $NAMESPACE $KSA_NAME

  Prod

  1. Definisci le variabili di ambiente KSA_NAME e GSA_NAME:

     GSA_NAME="apigee-mart"
     KSA_NAME="apigee-connect-agent-service-account-name-sa"

     ad esempio: apigee-connect-agent-hybrid-example-project-123abcd-sa.
  2. Associa il ruolo IAM:

     gcloud iam service-accounts add-iam-policy-binding \
       --role roles/iam.workloadIdentityUser \
       --member "serviceAccount:$PROJECT_ID.svc.id.goog[$NAMESPACE/$KSA_NAME]" \
       $GSA_NAME@$PROJECT_ID.iam.gserviceaccount.com \
       --project $PROJECT_ID

  3. Annota il account di servizio:

     kubectl annotate serviceaccount \
       --namespace $NAMESPACE $KSA_NAME iam.gke.io/gcp-service-account=$GSA_NAME@$PROJECT_ID.iam.gserviceaccount.com

  4. Verifica l'annotazione:

     kubectl describe serviceaccount \
       --namespace $NAMESPACE $KSA_NAME

• MART

  Non di produzione

  1. Definisci la variabile di ambiente KSA_NAME:

     KSA_NAME="apigee-mart-service-account-name-sa"

     ad esempio: apigee-mart-hybrid-example-project-123abcd-sa.
  2. Associa il ruolo IAM:

     gcloud iam service-accounts add-iam-policy-binding \
       --role roles/iam.workloadIdentityUser \
       --member "serviceAccount:$PROJECT_ID.svc.id.goog[$NAMESPACE/$KSA_NAME]" \
       $GSA_NAME@$PROJECT_ID.iam.gserviceaccount.com \
       --project $PROJECT_ID

  3. Annota il account di servizio:

     kubectl annotate serviceaccount \
       --namespace $NAMESPACE $KSA_NAME iam.gke.io/gcp-service-account=$GSA_NAME@$PROJECT_ID.iam.gserviceaccount.com

  4. Verifica l'annotazione:

     kubectl describe serviceaccount \
       --namespace $NAMESPACE $KSA_NAME

  Prod

  1. Definisci le variabili di ambiente KSA_NAME e GSA_NAME:

     GSA_NAME="apigee-mart"
     KSA_NAME="apigee-mart-service-account-name-sa"

     ad esempio: apigee-mart-hybrid-example-project-123abcd-sa.
  2. Associa il ruolo IAM:

     gcloud iam service-accounts add-iam-policy-binding \
       --role roles/iam.workloadIdentityUser \
       --member "serviceAccount:$PROJECT_ID.svc.id.goog[$NAMESPACE/$KSA_NAME]" \
       $GSA_NAME@$PROJECT_ID.iam.gserviceaccount.com \
       --project $PROJECT_ID

  3. Annota il account di servizio:

     kubectl annotate serviceaccount \
       --namespace $NAMESPACE $KSA_NAME iam.gke.io/gcp-service-account=$GSA_NAME@$PROJECT_ID.iam.gserviceaccount.com

  4. Verifica l'annotazione:

     kubectl describe serviceaccount \
       --namespace $NAMESPACE $KSA_NAME

• Metriche Apigee

  Non di produzione

  1. Definisci le variabili di ambiente KSA_NAME:

     KSA_NAME="apigee-metrics-sa"

  2. Associa il ruolo IAM:

     gcloud iam service-accounts add-iam-policy-binding \
       --role roles/iam.workloadIdentityUser \
       --member "serviceAccount:$PROJECT_ID.svc.id.goog[$NAMESPACE/$KSA_NAME]" \
       $GSA_NAME@$PROJECT_ID.iam.gserviceaccount.com \
       --project $PROJECT_ID

  3. Annota il account di servizio:

     kubectl annotate serviceaccount \
       --namespace $NAMESPACE $KSA_NAME iam.gke.io/gcp-service-account=$GSA_NAME@$PROJECT_ID.iam.gserviceaccount.com

  4. Verifica l'annotazione:

     kubectl describe serviceaccount \
       --namespace $NAMESPACE $KSA_NAME

  Prod

  1. Definisci le variabili di ambiente KSA_NAME e GSA_NAME:

     GSA_NAME="apigee-metrics"
     KSA_NAME="apigee-metrics-sa"

  2. Associa il ruolo IAM:

     gcloud iam service-accounts add-iam-policy-binding \
     --role roles/iam.workloadIdentityUser \
     --member "serviceAccount:$PROJECT_ID.svc.id.goog[$NAMESPACE/$KSA_NAME]" \
     $GSA_NAME@$PROJECT_ID.iam.gserviceaccount.com \
     --project $PROJECT_ID

  3. Annota il account di servizio:

     kubectl annotate serviceaccount \
     --namespace $NAMESPACE $KSA_NAME iam.gke.io/gcp-service-account=$GSA_NAME@$PROJECT_ID.iam.gserviceaccount.com

  4. Verifica l'annotazione:

     kubectl describe serviceaccount \
       --namespace $NAMESPACE $KSA_NAME

• UDCA (a livello di organizzazione)

  UDCA viene implementato sia a livello di organizzazione che di ambiente. Pertanto, esistono due service account Kubernetes separati per UDCA, uno per ogni ambito. Puoi distinguerli in base al nome dell'account. L'account con ambito ambiente include il nome dell'ambiente nel nome dell'account di servizio. Ad esempio:

  • A livello di organizzazione: apigee-udca-my-project-id-123abcd-sa dove my-project-id è l'ID progetto.
  • A livello di ambiente: apigee-udca-my-project-id-my-env-234bcde-sa dove my-env è il nome dell'ambiente.

  Non di produzione

  1. Definisci le variabili di ambiente KSA_NAME:

     KSA_NAME="apigee-udca-service-account-name-sa"

     ad esempio: apigee-udca-hybrid-example-project-123abcd-sa.
  2. Associa il ruolo IAM:

       gcloud iam service-accounts add-iam-policy-binding \
         --role roles/iam.workloadIdentityUser \
         --member "serviceAccount:$PROJECT_ID.svc.id.goog[$NAMESPACE/$KSA_NAME]" \
         $GSA_NAME@$PROJECT_ID.iam.gserviceaccount.com \
         --project $PROJECT_ID

  3. Annota il account di servizio:

       kubectl annotate serviceaccount \
         --namespace $NAMESPACE $KSA_NAME iam.gke.io/gcp-service-account=$GSA_NAME@$PROJECT_ID.iam.gserviceaccount.com

  4. Verifica l'annotazione:

     kubectl describe serviceaccount \
       --namespace $NAMESPACE $KSA_NAME

  Prod

  1. Definisci le variabili di ambiente KSA_NAME e GSA_NAME:

     GSA_NAME="apigee-udca"
     KSA_NAME="apigee-udca-service-account-name-sa"

     ad esempio: apigee-udca-hybrid-example-project-123abcd-sa.
  2. Associa il ruolo IAM:

     gcloud iam service-accounts add-iam-policy-binding \
       --role roles/iam.workloadIdentityUser \
       --member "serviceAccount:$PROJECT_ID.svc.id.goog[$NAMESPACE/$KSA_NAME]" \
       $GSA_NAME@$PROJECT_ID.iam.gserviceaccount.com \
       --project $PROJECT_ID

  3. Annota il account di servizio:

     kubectl annotate serviceaccount \
       --namespace $NAMESPACE $KSA_NAME iam.gke.io/gcp-service-account=$GSA_NAME@$PROJECT_ID.iam.gserviceaccount.com

  4. Verifica l'annotazione:

     kubectl describe serviceaccount \
       --namespace $NAMESPACE $KSA_NAME

• Apigee Watcher

  Non di produzione

  1. Definisci le variabili di ambiente KSA_NAME:

     KSA_NAME="apigee-watcher-service-account-name-sa"

     ad esempio: apigee-watcher-hybrid-example-project-123abcd-sa.
  2. Associa il ruolo IAM:

     gcloud iam service-accounts add-iam-policy-binding \
       --role roles/iam.workloadIdentityUser \
       --member "serviceAccount:$PROJECT_ID.svc.id.goog[$NAMESPACE/$KSA_NAME]" \
       $GSA_NAME@$PROJECT_ID.iam.gserviceaccount.com \
       --project $PROJECT_ID

  3. Annota il account di servizio:

     kubectl annotate serviceaccount \
       --namespace $NAMESPACE $KSA_NAME iam.gke.io/gcp-service-account=$GSA_NAME@$PROJECT_ID.iam.gserviceaccount.com

  4. Verifica l'annotazione:

     kubectl describe serviceaccount \
       --namespace $NAMESPACE $KSA_NAME

  Prod

  1. Definisci le variabili di ambiente KSA_NAME e GSA_NAME:

     GSA_NAME="apigee-watcher"
     KSA_NAME="apigee-watcher-service-account-name-sa"

     ad esempio: apigee-watcher-hybrid-example-project-123abcd-sa.
  2. Associa il ruolo IAM:

     gcloud iam service-accounts add-iam-policy-binding \
       --role roles/iam.workloadIdentityUser \
       --member "serviceAccount:$PROJECT_ID.svc.id.goog[$NAMESPACE/$KSA_NAME]" \
       $GSA_NAME@$PROJECT_ID.iam.gserviceaccount.com \
       --project $PROJECT_ID

  3. Annota il account di servizio:

     kubectl annotate serviceaccount \
       --namespace $NAMESPACE $KSA_NAME iam.gke.io/gcp-service-account=$GSA_NAME@$PROJECT_ID.iam.gserviceaccount.com

  4. Verifica l'annotazione:

     kubectl describe serviceaccount \
       --namespace $NAMESPACE $KSA_NAME

• Runtime

  Non di produzione

  1. Definisci le variabili di ambiente KSA_NAME:

     KSA_NAME="apigee-runtime-env-level-service-account-name-sa"

     ad esempio: apigee-runtime-hybrid-example-project-example-env-234bcde-sa.
  2. Associa il ruolo IAM:

     gcloud iam service-accounts add-iam-policy-binding \
       --role roles/iam.workloadIdentityUser \
       --member "serviceAccount:$PROJECT_ID.svc.id.goog[$NAMESPACE/$KSA_NAME]" \
       $GSA_NAME@$PROJECT_ID.iam.gserviceaccount.com \
       --project $PROJECT_ID

  3. Annota il account di servizio:

     kubectl annotate serviceaccount \
       --namespace $NAMESPACE $KSA_NAME iam.gke.io/gcp-service-account=$GSA_NAME@$PROJECT_ID.iam.gserviceaccount.com

  4. Verifica l'annotazione:

     kubectl describe serviceaccount \
       --namespace $NAMESPACE $KSA_NAME

  Prod

  1. Definisci le variabili di ambiente KSA_NAME e GSA_NAME:

     GSA_NAME="apigee-runtime"
     KSA_NAME="apigee-runtime-env-level-service-account-name-sa"

     ad esempio: apigee-runtime-hybrid-example-project-example-env-234bcde-sa.
  2. Associa il ruolo IAM:

     gcloud iam service-accounts add-iam-policy-binding \
       --role roles/iam.workloadIdentityUser \
       --member "serviceAccount:$PROJECT_ID.svc.id.goog[$NAMESPACE/$KSA_NAME]" \
       $GSA_NAME@$PROJECT_ID.iam.gserviceaccount.com \
       --project $PROJECT_ID

  3. Annota il account di servizio:

     kubectl annotate serviceaccount \
       --namespace $NAMESPACE $KSA_NAME iam.gke.io/gcp-service-account=$GSA_NAME@$PROJECT_ID.iam.gserviceaccount.com

  4. Verifica l'annotazione:

     kubectl describe serviceaccount \
       --namespace $NAMESPACE $KSA_NAME

• Synchronizer

  Non di produzione

  1. Definisci le variabili di ambiente KSA_NAME:

     KSA_NAME="apigee-synchronizer-env-level-service-account-name-sa"

     ad esempio: apigee-synchronizer-hybrid-example-project-example-env-234bcde-sa.
  2. Associa il ruolo IAM:

     gcloud iam service-accounts add-iam-policy-binding \
       --role roles/iam.workloadIdentityUser \
       --member "serviceAccount:$PROJECT_ID.svc.id.goog[$NAMESPACE/$KSA_NAME]" \
       $GSA_NAME@$PROJECT_ID.iam.gserviceaccount.com \
       --project $PROJECT_ID

  3. Annota il account di servizio:

     kubectl annotate serviceaccount \
       --namespace $NAMESPACE $KSA_NAME iam.gke.io/gcp-service-account=$GSA_NAME@$PROJECT_ID.iam.gserviceaccount.com

  4. Verifica l'annotazione:

     kubectl describe serviceaccount \
       --namespace $NAMESPACE $KSA_NAME

  Prod

  1. Definisci le variabili di ambiente KSA_NAME e GSA_NAME:

     GSA_NAME="apigee-synchronizer"
     KSA_NAME="apigee-synchronizer-env-level-service-account-name-sa"

     ad esempio: apigee-synchronizer-hybrid-example-project-example-env-234bcde-sa.
  2. Associa il ruolo IAM:

     gcloud iam service-accounts add-iam-policy-binding \
       --role roles/iam.workloadIdentityUser \
       --member "serviceAccount:$PROJECT_ID.svc.id.goog[$NAMESPACE/$KSA_NAME]" \
       $GSA_NAME@$PROJECT_ID.iam.gserviceaccount.com \
       --project $PROJECT_ID

  3. Annota il account di servizio:

     kubectl annotate serviceaccount \
       --namespace $NAMESPACE $KSA_NAME iam.gke.io/gcp-service-account=$GSA_NAME@$PROJECT_ID.iam.gserviceaccount.com

  4. Verifica l'annotazione:

     kubectl describe serviceaccount \
       --namespace $NAMESPACE $KSA_NAME

• UDCA (a livello di ambiente)

  Non di produzione

  1. Definisci le variabili di ambiente KSA_NAME:

     KSA_NAME="apigee-udca-env-level-service-account-name-sa"

     ad esempio: apigee-udca-hybrid-example-project-example-env-234bcde-sa.
  2. Associa il ruolo IAM:

     gcloud iam service-accounts add-iam-policy-binding \
       --role roles/iam.workloadIdentityUser \
       --member "serviceAccount:$PROJECT_ID.svc.id.goog[$NAMESPACE/$KSA_NAME]" \
       $GSA_NAME@$PROJECT_ID.iam.gserviceaccount.com \
       --project $PROJECT_ID

  3. Annota il account di servizio:

     kubectl annotate serviceaccount \
       --namespace $NAMESPACE $KSA_NAME iam.gke.io/gcp-service-account=$GSA_NAME@$PROJECT_ID.iam.gserviceaccount.com

  4. Verifica l'annotazione:

     kubectl describe serviceaccount \
       --namespace $NAMESPACE $KSA_NAME

  Prod

  1. Definisci le variabili di ambiente KSA_NAME e GSA_NAME:

     GSA_NAME="apigee-udca"
     KSA_NAME="apigee-udca-env-level-service-account-name-sa"

     ad esempio: apigee-udca-hybrid-example-project-example-env-234bcde-sa.
  2. Associa il ruolo IAM:

     gcloud iam service-accounts add-iam-policy-binding \
       --role roles/iam.workloadIdentityUser \
       --member "serviceAccount:$PROJECT_ID.svc.id.goog[$NAMESPACE/$KSA_NAME]" \
       $GSA_NAME@$PROJECT_ID.iam.gserviceaccount.com \
       --project $PROJECT_ID

  3. Annota il account di servizio:

     kubectl annotate serviceaccount \
       --namespace $NAMESPACE $KSA_NAME iam.gke.io/gcp-service-account=$GSA_NAME@$PROJECT_ID.iam.gserviceaccount.com

  4. Verifica l'annotazione:

     kubectl describe serviceaccount \
       --namespace $NAMESPACE $KSA_NAME

9. (Facoltativo) Puoi visualizzare lo stato dei tuoi service account Kubernetes nella pagina Kubernetes: Panoramica dei workload in Google Cloud console.

   Vai a Carichi di lavoro

   Nota: potresti visualizzare uno stato di errore per gli account di servizio apigee-cassandra-backup e apigee-cassandra-restore. 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, consulta la panoramica del backup di Cassandra.
10. Per controllare di nuovo lo stato del deployment con apigeectl check-ready:

    ${APIGEECTL_HOME}/apigeectl check-ready -f ${HYBRID_FILES}/overrides/overrides.yaml

Congratulazioni!

Hai installato e configurato correttamente il piano di runtime di Apigee hybrid. Nel passaggio successivo, configurerai il gateway in entrata Apigee.

1 2 3 4 5 6 7 8 (AVANTI) Passaggio 9: esponi l'ingresso Apigee 10