Passaggio 8: installa il runtime ibrido

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 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 on GKE, EKS e GKE on prem, verifica che la variabile KUBECONFIG sia impostata utilizzando il seguente comando:
    echo ${KUBECONFIG}
  4. Esegui un'inizializzazione dry run. Eseguire una prova consente di verificare la presenza di eventuali errori prima vengono 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 il deployment Apigee di deployment 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.

GKE con Workload Identity

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

Queste procedure utilizzano le seguenti variabili di ambiente. Impostali 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 cluster, ad esempio: us-west1.
  • CLUSTER_LOCATION: il nome del cluster.
  • ENV_NAME: nome dell'ambiente Apigee.
  • NAMESPACE: lo 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 necessarie:

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 dell'account di servizio.

    Quando si esegue Apigee hybrid su GKE, la prassi standard è creare e scaricare (.json file) per ciascuno degli account di servizio. Quando utilizzi Workload Identity, non è necessario scaricare le chiavi private degli 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 corrisponda al tuo ID progetto Google Cloud con il seguente comando:
    gcloud config get project
  3. Se necessario, imposta l'attuale configurazione di gcloud:

    gcloud config set project $PROJECT_ID
  4. 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
  5. Verifica che Workload Identity sia abilitato per il tuo cluster GKE. Quando hai creato il cluster nel passaggio 1: creazione di un cluster, il passaggio 6 era Abilita Workload Identity. Puoi verificare se Workload Identity è abilitato eseguendo questo 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'

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

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

    Se invece vedi null nei risultati, esegui questo comando per abilitare Workload Identity per il tuo 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
  6. Verifica che Workload Identity sia abilitato sui tuoi 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 al seguente:

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

  7. Controlla i nomi degli account di servizio Google per il tuo progetto con il seguente comando:
    gcloud iam service-accounts list --project $PROJECT_ID

    L'output dovrebbe avere il seguente aspetto:

    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
    

    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
    
  8. Verifica gli account di servizio con 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 annotare con i tuoi account di servizio 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
        
  9. 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. I valori di questi elementi verranno reimpostati 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 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

      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 di produzione

      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.

      apigee-cassandra-backup Account di servizio 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. 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 a:

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

      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. 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-cassandra-schema-setup Account di servizio 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. 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-cassandra-schema-val Account di servizio Kubernetes

      1. Ridefinisci la KSA_NAMEvariabile di ambiente:

        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. 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-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. 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-datastore-default-sa Account di servizio 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. 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

      apigee-cassandra-backup Account di servizio 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. 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 a:

        Annotations:         iam.gke.io/gcp-service-account: apigee-cassandra@my-project-id.iam.gserviceaccount.com
      6. 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. 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

      apigee-cassandra-schema-setup Service account Kubernetes

      1. Ridefinisci la KSA_NAMEvariabile di ambiente:

        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

      apigee-cassandra-schema-val Account di servizio 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. 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-cassandra-user-setup Service account Kubernetes

      1. Ridefinisci la KSA_NAMEvariabile di ambiente:

        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. 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-datastore-default-sa Account di servizio 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. 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

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

      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. 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. 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. 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 Apigee

      Non di produzione

      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. 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 l'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)

      L'UDCA viene implementata in ambiti sia a livello di organizzazione che di ambiente. Pertanto, esistono due account di servizio Kubernetes separati per UDCA, uno per ogni ambito. Puoi puoi distinguerli dal nome dell'account. L'account con ambito env include l'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 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. 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. 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. 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

      Non prod

      1. Definisci le KSA_NAMEvariabili di ambiente:

        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

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

      Non di produzione

      1. Definisci le KSA_NAMEvariabili di ambiente:

        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. 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. 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)

      Non di produzione

      1. Definisci le KSA_NAMEvariabili di ambiente:

        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. 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. 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. 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
  10. (Facoltativo) Puoi visualizzare lo stato dei tuoi account di servizio Kubernetes nella pagina Kubernetes: Panoramica dei carichi di lavoro della console Google Cloud.

    Vai a Carichi di lavoro

  11. 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 (SUCCESSIVO) Passaggio 9: espone il traffico Apigee in entrata 10