Passaggio 9: installazione del runtime di hybrid

Applica la configurazione al cluster

Per installare Apigee hybrid nel cluster:

  1. Assicurati di essere nella directory hybrid-base-directory/hybrid-files. 
    cd $HYBRID_FILES
  2. Verifica che kubectl sia impostato sul contesto corretto utilizzando il seguente comando. Il contesto corrente deve essere impostato sul cluster in cui esegui 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 zonali

    gcloud container clusters get-credentials $CLUSTER_NAME \
--zone $CLUSTER_LOCATION \
--project $PROJECT_ID
  3. Solo per le piattaforme Anthos on bare metal, AWS on GKE, EKS e GKE on prem, verifica che la variabile KUBECONFIG sia impostata utilizzando il seguente comando: 
    echo ${KUBECONFIG}
  4. Esegui un'inizializzazione di simulazione. Eseguire una prova simulata ti consente di verificare la presenza di eventuali errori prima di apportare 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 i servizi di deployment Apigee 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 una simulazione dell'installazione. 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 il comando seguente: 
    ${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.

GKE con Workload Identity

Per le installazioni ibride di Apigee su GKE, Google Cloud offre un'opzione chiamata Workload Identity per autenticare i componenti di runtime ibrida.

Account di servizio Google Cloud e account di servizio Kubernetes

Un account di servizio Google Cloud è un tipo speciale di account che può essere utilizzato per effettuare chiamate API autorizzate autenticandosi come l'account di servizio stesso. Agli account di servizio Google Cloud possono essere assegnati ruoli e autorizzazioni simili a quelli di un singolo utente. Quando un'applicazione si autentica come account di servizio, ha accesso a tutte le risorse a cui l'account di servizio ha l'autorizzazione di accesso. Per saperne di più sugli account di servizio Google Cloud, consulta Panoramica degli account di servizio.

Hai creato account di servizio Google Cloud per la tua installazione ibrida di Apigee nel passaggio 4: crea gli account di servizio. Apigee utilizza questi account di servizio per autenticare i componenti ibride.

Gli account di servizio Kubernetes sono simili agli account di servizio Google Cloud. Un account di servizio Kubernetes fornisce un'identità per i processi in esecuzione in un pod e consente di autenticarsi al server API in modo simile a un utente. Per scoprire di più sugli account di servizio Kubernetes, consulta Configurare gli account di servizio per i pod.

Lo strumento apigeectl ha creato la maggior parte degli account di servizio Kubernetes necessari per Apigee Hybrid quando hai eseguito apigeectl apply nella procedura precedente.

Quando configuri Workload Identity su GKE, associ gli account di servizio Google Cloud agli account di servizio Kubernetes nel cluster Kubernetes. In questo modo, gli account di servizio Kubernetes possono rubare l'identità degli account di servizio Google Cloud e utilizzare i relativi ruoli e le relative autorizzazioni assegnate per autenticarsi con i componenti ibride.

Segui queste istruzioni per configurare Workload Identity per il tuo progetto.

Preparativi per la configurazione dell'identità del carico di lavoro

Queste procedure utilizzano le seguenti variabili di ambiente. Verifica che siano definiti e definisci quelli che non lo sono:

echo $APIGEECTL_HOME
echo $CLUSTER_LOCATION
echo $ENV_NAME
echo $HYBRID_FILES
echo $NAMESPACE
echo $PROJECT_ID
echo $ORG_NAME
  1. Verifica che la configurazione gcloud corrente sia impostata sull'ID progetto Google Cloud con il seguente comando: 
    gcloud config get project

    2. Se necessario, imposta la configurazione attuale di gcloud:

    gcloud config set project $PROJECT_ID
  2. Crea l'account di servizio Kubernetes apigee-cassandra-restore.

    Quando hai applicato la configurazione eseguendo apigeectl apply, il comando ha creato la maggior parte degli account di servizio Kubernetes necessari per l'identità del carico di lavoro.

    Per creare l'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
  3. Verifica che Workload Identity sia abilitato per il tuo cluster GKE. Quando hai creato il cluster nel passaggio 1: crea un cluster, il passaggio 11 era Abilita Workload Identity. Puoi verificare se Workload Identity è abilitato eseguendo il seguente comando:

    Cluster a livello di regione

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

    Cluster zonali

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

    L'output dovrebbe avere l'aspetto seguente: 

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

    Se nei risultati viene visualizzato null, esegui il seguente comando per attivare 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 zonali

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

  4. Abilita Workload Identity per ogni pool di nodi con i seguenti comandi. Questa operazione può richiedere fino a 30 minuti per ogni nodo:

    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 zonali

    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.

  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 zonali

    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 avere il seguente aspetto:

    ---
diskSizeGb: 100
diskType: pd-standard
...
workloadMetadataConfig:
  mode: GKE_METADATA
  6. Ottieni un elenco dei nomi degli account di servizio Google Cloud per il tuo progetto. Ti serviranno questi nomi per associare gli account di servizio Kubernetes per configurare Workload Identity. Per le installazioni non di produzione, deve essere presente un solo account di servizio Google. Per le installazioni di produzione, devono essere otto.

    Utilizza il seguente comando per ottenere l'elenco dei nomi:

    gcloud iam service-accounts list --project $PROJECT_ID

    L'output dovrebbe avere il seguente aspetto:

    Non prod

    Per gli ambienti non di produzione:

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

    Produzione

    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
  7. Visualizza un elenco dei nomi degli account di servizio Kubernetes. Ti servirà questo elenco di nomi per associarlo ai tuoi account di servizio Google Cloud in un secondo momento in questa procedura. Utilizza il seguente comando: 
    kubectl get sa -n $NAMESPACE

    L'output dovrebbe essere simile al seguente. Gli account di servizio Kubernetes in grassetto sono quelli che dovrai associare ai tuoi account di servizio Google Cloud: 

    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

Configurare l'identità del carico di lavoro

Per attivare l'identità del carico di lavoro per l'installazione ibrida:

  1. Per ogni componente Apigee, annota gli account di servizio Kubernetes corrispondenti con l'account di servizio Google per il componente.

    I passaggi seguenti utilizzano due variabili di ambiente. Reimposta i valori di queste variabili prima di ogni serie 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 gli account di servizio.
    • KSA_NAME: il nome di un account di servizio Kubernetes. Si tratta degli account elencati sopra con il comando kubectl get sa -n $NAMESPACE, ad esempio:apigee-cassandra-schema-setup-hybrid-example-project-123abcd-sa.
    • Cassandra

      Configura Workload Identity per il componente Cassandra.

      Il componente Cassandra ha sei account di servizio 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 prod

      Configura l'account di servizio Kubernetes apigee-cassandra-backup

      1. Definisci le variabili di ambiente KSA_NAME e GSA_NAME: 
        GSA_NAME="apigee-non-prod"
KSA_NAME="apigee-cassandra-backup"
      2. Collega 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. Aggiungi un'annotazione all'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 descriva l'annotazione, simile alla seguente:

        Annotations:         iam.gke.io/gcp-service-account: apigee-non-prod@my-project-id.iam.gserviceaccount.com

      Configura l'account di servizio Kubernetes apigee-cassandra-restore

      1. Ridefinisci la variabile di ambiente KSA_NAME:

        KSA_NAME="apigee-cassandra-restore"
      2. Collega 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. Aggiungi un'annotazione all'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

      Configura l'account di servizio Kubernetes apigee-cassandra-schema-setup

      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. Collega 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. Aggiungi un'annotazione all'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

      Configura l'account di servizio Kubernetes apigee-cassandra-schema-val

      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. Collega 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. Aggiungi un'annotazione all'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

      Configura l'account di servizio Kubernetes apigee-cassandra-user-setup

      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. Collega 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. Aggiungi un'annotazione all'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

      Configura l'account di servizio Kubernetes apigee-datastore-default-sa

      1. Ridefinisci la variabile di ambiente KSA_NAME:

        KSA_NAME="apigee-datastore-default-sa"
      2. Collega 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. Aggiungi un'annotazione all'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

      Produzione

      Configura l'account di servizio Kubernetes apigee-cassandra-backup

      1. Definisci le variabili di ambiente KSA_NAME e GSA_NAME: 
        GSA_NAME="apigee-cassandra"
KSA_NAME="apigee-cassandra-backup"
      2. Collega 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. Aggiungi un'annotazione all'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

        5. L'output dovrebbe contenere una riga che descriva l'annotazione, simile alla seguente:

        Annotations:         iam.gke.io/gcp-service-account: apigee-cassandra@my-project-id.iam.gserviceaccount.com
      5. Verifica l'annotazione: 
        kubectl describe serviceaccount \
  --namespace $NAMESPACE $KSA_NAME

      Configura l'account di servizio Kubernetes apigee-cassandra-restore

      1. Ridefinisci la variabile di ambiente KSA_NAME:

        KSA_NAME="apigee-cassandra-restore"
      2. Collega 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. Aggiungi un'annotazione all'account di servizio: 
        kubectl annotate serviceaccount \
  --namespace $NAMESPACE $KSA_NAME iam.gke.io/gcp-service-account=$GSA_NAME@$PROJECT_ID.iam.gserviceaccount.com

      Configura l'account di servizio Kubernetes apigee-cassandra-schema-setup

      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. Collega 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. Aggiungi un'annotazione all'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

      Configura l'account di servizio Kubernetes apigee-cassandra-schema-val

      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. Collega 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. Aggiungi un'annotazione all'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

      Configura l'account di servizio Kubernetes apigee-cassandra-user-setup

      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. Collega 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. Aggiungi un'annotazione all'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

      Configura l'account di servizio Kubernetes apigee-datastore-default-sa

      1. Ridefinisci la variabile di ambiente KSA_NAME:

        KSA_NAME="apigee-datastore-default-sa"
      2. Collega 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. Aggiungi un'annotazione all'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

      Configura Workload Identity per il componente Apigee Connect.

      Non prod

      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. Collega 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. Aggiungi un'annotazione all'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

      Produzione

      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. Collega 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. Aggiungi un'annotazione all'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

      Configura Workload Identity per il componente MART.

      Non prod

      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. Collega 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. Aggiungi un'annotazione all'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

      Produzione

      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. Collega 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. Aggiungi un'annotazione all'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 di Apigee

      Configura Workload Identity per il componente delle metriche di Apigee.

      Non prod

      1. Definisci le variabili di ambiente KSA_NAME:

        KSA_NAME="apigee-metrics-sa"
      2. Collega 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. Aggiungi un'annotazione all'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

      Produzione

      1. Definisci le variabili di ambiente KSA_NAME e GSA_NAME:

        GSA_NAME="apigee-metrics"
KSA_NAME="apigee-metrics-sa"
      2. Collega 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. Aggiungi un'annotazione all'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)

      Configura Workload Identity per il componente UDCA a livello di organizzazione.

      L'accesso a più dati aziendali è implementato sia a livello di organizzazione che di ambiente. Pertanto, esistono due account di servizio Kubernetes separati per UDCA, uno per ogni ambito. Puoi distinguerli dal nome dell'account. L'account 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 del nome.
      • Env-level: apigee-udca-my-project-id-my-env-234bcde-sa dove my-env è il nome dell'ambiente.

      Non prod

      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. Collega 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. Aggiungi un'annotazione all'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

      Produzione

      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. Collega 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. Aggiungi un'annotazione all'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

      Configura Workload Identity per il componente Apigee Watcher.

      Non prod

      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. Collega 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. Aggiungi un'annotazione all'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

      Produzione

      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. Collega 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. Aggiungi un'annotazione all'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
    • Tempo di esecuzione

      Configura Workload Identity per il componente Apigee Runtime.

      Non prod

      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. Collega 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. Aggiungi un'annotazione all'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

      Produzione

      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. Collega 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. Aggiungi un'annotazione all'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

      Configura Workload Identity per il componente Synchronizer.

      Non prod

      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. Collega 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. Aggiungi un'annotazione all'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

      Produzione

      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. Collega 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. Aggiungi un'annotazione all'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)

      Configura Workload Identity per il componente UDCA a livello di ambiente.

      Non prod

      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. Collega 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. Aggiungi un'annotazione all'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

      Produzione

      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. Collega 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. Aggiungi un'annotazione all'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
  2. (Facoltativo) Elimina eventuali file delle chiavi dell'account di servizio scaricati.

    Se hai creato gli account di servizio Google con lo strumento create-service-account, è possibile che siano state create chiavi degli account di servizio e scaricati i file delle chiavi .json. Quando utilizzi Workload Identity su GKE, non hai bisogno di questi file di chiavi.

    Puoi eliminare i file delle chiavi con il seguente comando:

    rm $HYBRID_FILES/service-accounts/*.json

Verifica l'identità del carico di lavoro

  1. (Facoltativo) Puoi visualizzare lo stato dei tuoi account di servizio Kubernetes nella pagina Kubernetes: Panoramica dei carichi di lavoro nella Google Cloud Console.

    Vai a Carichi di lavoro

  2. Per controllare di nuovo lo stato del deployment con apigeectl check-ready: 
    ${APIGEECTL_HOME}/apigeectl check-ready -f ${HYBRID_FILES}/overrides/overrides.yaml
1 2 3 4 5 6 7 8 9 (AVANTI) Passaggio 10: esponi l'ingresso Apigee 11