Ativar o Workload Identity com o Apigee hybrid

Está a ver a versão 1.10 da documentação do Apigee híbrido. This version is end of life. You should upgrade to a newer version. Para mais informações, consulte Versões suportadas.

Version 1.10 

Versões com suporte:

• v1.15 (mais recente)                        
• v1.14                        
• v1.13                         
• Lista de versões com suporte

Versões sem suporte:

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

Este tópico explica como ativar o Workload Identity para o Apigee hybrid.

Nota: o Apigee Hybrid v.1.10 só suporta a federação de identidades de cargas de trabalho no GKE.

Vista geral

O Workload Identity é uma forma de as aplicações em execução no GKE (Google Kubernetes Engine) acederem aos serviços do Google Cloud. Para ver descrições gerais do Workload Identity, consulte:

• Apresentamos o Workload Identity: melhor autenticação para as suas aplicações do GKE
• Usar o Workload Identity

Uma conta de serviço da IAM do Google Cloud é uma identidade que uma aplicação pode usar para fazer pedidos às APIs Google. Estas contas de serviço são denominadas contas de serviço Google (GSA) no documento. Para mais informações sobre as ASGs, consulte o artigo Contas de serviço.

Em separado, o Kubernetes também tem o conceito de contas de serviço. Uma conta de serviço fornece uma identidade para processos executados num pod. As contas de serviço do Kubernetes são recursos do Kubernetes, enquanto as contas de serviço Google são específicas do Google Cloud. Para ver informações sobre contas de serviço do Kubernetes, consulte o artigo Configure contas de serviço para pods na documentação do Kubernetes.

Com o Apigee hybrid 1.4 e posterior, o Apigee cria e usa uma conta de serviço do Kubernetes para cada tipo de componente. A ativação do Workload Identity permite que os componentes híbridos interajam com as contas de serviço do Kubernetes.

Contas de serviço Google no Apigee Hybrid sem o Workload Identity

Sem usar a Workload Identity, tem de associar as contas de serviço Google a cada componente no ficheiro overrides.yaml com uma referência a um ficheiro de certificado ou um segredo do Kubernetes. Por exemplo:

• Ficheiros de certificado:

  watcher:
    serviceAccountPath: ./apigee-org/my-hybrid-project-apigee-watcher.json

  Consulte:

  cassandra.backup.serviceAccountPath cassandra.restore.serviceAccountPath connectAgent.serviceAccountPath diagnostic.serviceAccountPath envs[].serviceAccountPaths.runtime envs[].serviceAccountPaths.synchronizer envs[].serviceAccountPaths.udca

  logger.serviceAccountPath mart.serviceAccountPath metrics.serviceAccountPath synchronizer.serviceAccountPath udca.serviceAccountPath watcher.serviceAccountPath

• Segredo do Kubernetes:

  watcher:
    serviceAccountRef: my-watcher-k8s-secret

  Consulte:

  cassandra.backup.serviceAccountRef cassandra.restore.serviceAccountRef connectAgent.serviceAccountRef diagnostic.serviceAccountRef envs[].serviceAccountRefs.runtime envs[].serviceAccountRefs.synchronizer envs[].serviceAccountRefs.udca

  logger.serviceAccountRef mart.serviceAccountRef metrics.serviceAccountRef synchronizer.serviceAccountRef udca.serviceAccountRef watcher.serviceAccountRef

Variáveis de ambiente usadas nestes procedimentos

Estes procedimentos usam as seguintes variáveis de ambiente. Defina estes valores na shell de comandos ou substitua-os nos exemplos de código pelos valores reais:

• PROJECT_ID: o ID do seu projeto do Google Cloud.
• ORG_NAME: o nome da sua organização do Apigee.
• ENV_NAME: o nome do ambiente Apigee.
• NAMESPACE: o nome do seu espaço de nomes da Apigee. Normalmente, esta ação demora apigee.
• CLUSTER_NAME: o nome do cluster.
• CLUSTER_LOCATION: a região ou a zona do seu cluster, por exemplo: us-west1.
• APIGEECTL_HOME: o diretório onde instalou o apigeectl.
• HYBRID_FILES: o diretório de ficheiros híbridos, por exemplo, hybrid-base-directory/hybrid-files.

Verifique as variáveis de ambiente:

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

Inicialize qualquer uma das variáveis de que precisa:

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

Workload Identity e ficheiros de chaves de contas de serviço

Quando executa o Apigee hybrid no GKE, a prática padrão é criar e transferir chaves privadas (ficheiros .json) para cada uma das contas de serviço. Quando usa o Workload Identity, não precisa de transferir chaves privadas de contas de serviço e adicioná-las a clusters do GKE.

Se transferiu ficheiros de chaves de contas de serviço como parte da instalação do Apigee Hybrid, pode eliminá-los depois de ativar a Identidade de carga de trabalho. Na maioria das instalações, residem no diretório hybrid-base-directory/hybrid-files/service-accounts/.

Ative o Workload Identity para o Apigee Hybrid

Para começar, siga as instruções em Prepare-se para ativar o Workload Identity para atualizar os node pools e inicializar as variáveis antes de ativar o Workload Identity.

Em seguida, siga as instruções em Definir workloadIdentityEnabled: true e criar contas de serviço para ativar a identidade da carga de trabalho na sua instalação híbrida do Apigee.

Prepare-se para ativar o Workload Identity

Antes de iniciar o processo de instalação, siga os passos desta secção.

1. Defina o projeto para o projeto que está a modificar:

   gcloud config set project $PROJECT_ID

2. Obtenha as credenciais gcloud do cluster no qual está a ativar o Workload Identity com o seguinte comando:

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

   Nota: se criou um cluster zonal em vez de um cluster regional, obtenha as credenciais com o seguinte comando:

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

3. Verifique se o Workload Identity está ativado para o cluster do GKE que executa o Apigee com o seguinte comando:

   gcloud container clusters describe $CLUSTER_NAME --region $CLUSTER_LOCATION --project $PROJECT_ID

   Nota: para clusters zonais, use:

   gcloud container clusters describe $CLUSTER_NAME --zone $CLUSTER_LOCATION --project $PROJECT_ID

   O resultado deve incluir algo como o seguinte:

   …
     …
     status: RUNNING
     subnetwork: default
     workloadIdentityConfig:
       workloadPool: my-project-id.svc.id.goog

   Se necessário, ative o Workload Identity no cluster. Esta operação pode demorar até 30 minutos:

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

   Nota: se criou um cluster zonal em vez de um cluster regional, use o argumento --zone em vez de --region, como no comando seguinte:

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

   Para mais informações, consulte o artigo Ative a identidade de carga de trabalho.

4. Certifique-se de que o Workload Identity está ativado em cada conjunto de nós.
   1. Apresente uma lista dos seus conjuntos de nós com o seguinte comando:

      gcloud container node-pools list \
        --cluster $CLUSTER_NAME \
        --region $CLUSTER_LOCATION \
        --project $PROJECT_ID

      O resultado deve ter um aspeto semelhante ao seguinte:

        NAME            MACHINE_TYPE   DISK_SIZE_GB  NODE_VERSION
        apigee-runtime  e2-standard-4  100           1.23.12-gke.100
        apigee-data     e2-standard-4  100           1.23.12-gke.100

   2. Certifique-se de que o Workload Identity está ativado por conjunto de nós através do seguinte comando para cada conjunto de nós:

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

      Onde NODE_POOL_NAME é o nome de cada conjunto de nós.

Valide ou crie contas de serviço Google

As contas de serviço Google são criadas para muitos componentes híbridos do Apigee durante a instalação. Use este procedimento para validar as contas de serviço Google e criar as que forem necessárias.

1. Verifique os nomes das contas de serviço Google para o seu projeto com o seguinte comando:

   gcloud iam service-accounts list --project $PROJECT_ID

   O resultado deve ter um aspeto semelhante ao seguinte:

   Prod

   Para ambientes de não produção:

   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
   

   Não prod

   Para ambientes de não produção:

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

   Sugestão: se tiver nomes personalizados para as suas contas de serviço que não correspondam facilmente aos nomes dos componentes do Apigee, pode determinar a função de cada conta de serviço verificando as funções atribuídas à mesma e comparando-as com as funções recomendadas no artigo Acerca das contas de serviço.

   Use o seguinte comando para verificar as funções atribuídas a uma conta de serviço:

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

   Se precisar de criar as contas de serviço Google para o seu projeto, existem dois métodos que pode usar:

   • Use a ferramenta create-service-account incluída no apigee no diretório apigeectl/tools/. Esta ferramenta pode criar todas as contas de serviço com um único comando ou permitir que as crie individualmente.
     create-service-account gera ficheiros de chaves para cada conta de serviço e transfere-os. Se usar a identidade de carga de trabalho, não precisa destes ficheiros de chaves. Se tiver preocupações acerca da segurança destes ficheiros de chaves, recomendamos que os elimine. Em alternativa, pode usar gcloud para criar as contas de serviço e atribuir-lhes as funções adequadas.
   • Use o comando gcloud iam service-accounts create para criar as contas de serviço uma de cada vez e o comando gcloud projects add-iam-policy-binding para atribuir as funções adequadas a cada conta de serviço. Este método requer que crie cada conta de serviço individualmente, mas permite-lhe evitar a transferência dos ficheiros de chaves.

   create-service-account

   Use o seguinte comando para criar uma conta de serviço Google por componente:

   Prod

   Para ambientes de não produção:

   $APIGEECTL_HOME/tools/create-service-account --env prod --dir $APIGEECTL_HOME/../service-accounts

   Este comando cria as seguintes contas de serviço:

   • apigee-cassandra
   • apigee-logger
   • apigee-mart
   • apigee-metrics
   • apigee-runtime
   • apigee-synchronizer
   • apigee-udca
   • apigee-watcher

   Não prod

   Para ambientes de não produção:

   $APIGEECTL_HOME/tools/create-service-account --env non-prod --dir $APIGEECTL_HOME/../service-accounts

   Este comando cria uma única conta de serviço, apigee-non-prod, com todas as funções atribuídas necessárias para gerir todos os componentes do Apigee.

   gcloud

   Crie as seguintes contas de serviço e atribua-lhes funções.

   Sugestão: se quiser usar nomes personalizados, altere o nome da conta de serviço vermelho no exemplo de código para o nome que quer usar.

   1. Conta de serviço: apigee-cassandra, função: roles/storage.objectAdmin

      Crie a conta:

      gcloud iam service-accounts create apigee-cassandra \
        --display-name="apigee-cassandra" \
        --project $PROJECT_ID
                  

      Atribua a função:

      gcloud projects add-iam-policy-binding $PROJECT_ID \
        --member="serviceAccount:apigee-cassandra@$PROJECT_ID.iam.gserviceaccount.com" \
        --role="roles/storage.objectAdmin"
                  

   2. Conta de serviço: apigee-logger, função: roles/logging.logWriter

      Crie a conta:

      gcloud iam service-accounts create apigee-logger \
        --display-name="apigee-logger" \
        --project $PROJECT_ID
                  

      Atribua a função:

      gcloud projects add-iam-policy-binding $PROJECT_ID \
        --member="serviceAccount:apigee-logger@$PROJECT_ID.iam.gserviceaccount.com" \
        --role="roles/logging.logWriter"
                  

   3. Conta de serviço: apigee-mart, função: roles/apigeeconnect.Agent

      Crie a conta:

      gcloud iam service-accounts create apigee-mart \
        --display-name="apigee-mart" \
        --project $PROJECT_ID
                  

      Atribua a função:

      gcloud projects add-iam-policy-binding $PROJECT_ID \
        --member="serviceAccount:apigee-mart@$PROJECT_ID.iam.gserviceaccount.com" \
        --role="roles/apigeeconnect.Agent"
                  

   4. Conta de serviço: apigee-metrics, função: roles/monitoring.metricWriter

      Crie a conta:

      gcloud iam service-accounts create apigee-metrics \
        --display-name="apigee-metrics" \
        --project $PROJECT_ID
                  

      Atribua a função:

      gcloud projects add-iam-policy-binding $PROJECT_ID \
        --member="serviceAccount:apigee-metrics@$PROJECT_ID.iam.gserviceaccount.com" \
        --role="roles/monitoring.metricWriter"
                  

   5. Conta de serviço: apigee-runtime, função: nenhuma função atribuída.

      Crie a conta:

      gcloud iam service-accounts create apigee-runtime \
        --display-name="apigee-runtime" \
        --project $PROJECT_ID
                  

   6. Conta de serviço: apigee-synchronizer, função: roles/apigee.synchronizerManager

      Crie a conta:

      gcloud iam service-accounts create apigee-synchronizer \
        --display-name="apigee-synchronizer" \
        --project $PROJECT_ID
                  

      Atribua a função:

      gcloud projects add-iam-policy-binding $PROJECT_ID \
        --member="serviceAccount:apigee-synchronizer@$PROJECT_ID.iam.gserviceaccount.com" \
        --role="roles/apigee.synchronizerManager"
                  

   7. Conta de serviço: apigee-udca, função: roles/apigee.analyticsAgent

      Crie a conta:

      gcloud iam service-accounts create apigee-udca \
        --display-name="apigee-udca" \
        --project $PROJECT_ID
                  

      Atribua a função:

      gcloud projects add-iam-policy-binding $PROJECT_ID \
        --member="serviceAccount:apigee-udca@$PROJECT_ID.iam.gserviceaccount.com" \
        --role="roles/apigee.analyticsAgent"
                  

   8. Conta de serviço: apigee-watcher, função: roles/apigee.runtimeAgent

      Crie a conta:

      gcloud iam service-accounts create apigee-watcher \
        --display-name="apigee-watcher" \
        --project $PROJECT_ID
                  

      Atribua a função:

      gcloud projects add-iam-policy-binding $PROJECT_ID \
        --member="serviceAccount:apigee-watcher@$PROJECT_ID.iam.gserviceaccount.com" \
        --role="roles/apigee.runtimeAgent"
                  

Defina workloadIdentityEnabled: true e crie contas de serviço

apigeectl cria contas de serviço do Kubernetes para cada componente híbrido do Apigee quando define workloadIdentityEnabled: true no ficheiro de substituições e aplica as alterações.

1. Adicione a linha a negrito abaixo ao seu ficheiro overrides.yaml na secção gcp. Isto ativa a identidade da carga de trabalho para a sua instalação e aciona o apigeectl para criar as contas de serviço do Kubernetes quando aplica a configuração:

   gcp:
     projectID: "my-project-id"
     name: "my-project-id"
     region: "analytics-region"
     workloadIdentityEnabled: true

2. Adicione as linhas a negrito abaixo ao seu ficheiro overrides.yaml na secção cassandra. Isto aciona a criação da conta de serviço do Kubernetes:apigee-cassandra-backup

   cassandra:
     ...
     backup:
       enabled: true

3. Aplique as alterações com apigeectl com a flag --restore:

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

   Nota: a flag --restore aciona a criação da conta de serviço do apigee-cassandra-restoreKubernetes
   .
4. Valide as contas de serviço com o seguinte comando:

   kubectl get sa -n $NAMESPACE

   O resultado deve ter um aspeto semelhante ao seguinte. As contas de serviço do Kubernetes em negrito são as que tem de anotar com as suas contas de serviço 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
       

Anotar as contas de serviço do Kubernetes com as contas de serviço Google

Para cada componente do Apigee, anote as contas de serviço do Kubernetes correspondentes com a conta de serviço Google para o componente.

Componentes ao nível da organização

Só tem uma instância de cada conta de serviço do Kubernetes para a sua organização do Apigee.

Componente	Conta de serviço do Kubernetes	Conta de serviço Google
Cassandra	apigee-cassandra-backup	apigee-cassandra
	apigee-cassandra-restore	apigee-cassandra
	apigee-cassandra-schema-setup-my-project-id-num-id1-sa	apigee-cassandra
	apigee-cassandra-schema-val-my-project-id-num-id1	apigee-cassandra
	apigee-cassandra-user-setup-my-project-id-num-id1-sa	apigee-cassandra
	apigee-datastore-default-sa	apigee-cassandra
Apigee Connect	apigee-connect-agent-my-project-id-num-id1-sa	apigee-mart
MART	apigee-mart-my-project-id-num-id1-sa	apigee-mart
Métricas	apigee-metrics-sa	apigee-metrics
UDCA (org-level)	apigee-udca-my-project-id-num-id1-sa	apigee-udca
Watcher	apigee-watcher-my-project-id-num-id1-sa	apigee-watcher

Componentes ao nível do ambiente

Tem uma instância de cada conta de serviço do Kubernetes para cada ambiente do Apigee.

Componente	Conta de serviço do Kubernetes	Conta de serviço Google
Apigee Runtime	apigee-runtime-my-project-id-env-name-num-id2-sa	apigee-runtime
Synchronizer	apigee-synchronizer-my-project-id-env-name-num-id2-sa	apigee-synchronizer
UDCA (env-level)	apigee-udca-my-project-id-env-name-num-id2-sa	apigee-udca

IMPORTANTE: se os nomes das contas de serviço não corresponderem aos nomes predefinidos criados pela create-service-account, nos comandos seguintes, substitua o nome da conta de serviço vermelho pelo nome da conta de serviço correto para o componente. Por exemplo, se a sua conta de serviço do Cassandra se chamar my-cassandra-accnt-1, substitua apigee-cassandra por esse nome no comando.

Nos comandos seguintes, use os nomes das contas de serviço do Kubernetes devolvidos pelo comando kubectl get sa -n $NAMESPACE, por exemplo: apigee-cassandra-schema-val-hybrid-example-project-123abcd.

Neste procedimento, para cada conta de serviço do Kubernetes:

• Associe a conta de serviço do Kubernetes e a conta de serviço Google principal à função de roles/iam.workloadIdentityUserIAM.
• Anote a conta de serviço do Kubernetes com a conta de serviço Google.

1. Associe as funções e anote as contas de serviço.

   Componentes ao nível da organização

   Anotar contas de serviço do Kubernetes para os componentes ao nível da organização. Tem de o fazer uma vez para cada componente na sua organização do Apigee.

   • Cassandra

     O componente Cassandra tem seis contas de serviço do Kubernetes associadas:

     • apigee-cassandra-backup
     • apigee-cassandra-restore
     • apigee-cassandra-schema-setup
     • apigee-cassandra-schema-val (val = validação)
     • apigee-cassandra-user-setup
     • apigee-datastore-default

     Prod

     apigee-cassandra-backup

     1. Defina as variáveis de ambiente KSA_NAME e GSA_NAME:

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

     2. Associe a função de 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

     3. Anotar a conta de serviço:

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

     apigee-cassandra-restore

     1. Redefina a variável de ambiente KSA_NAME:

        KSA_NAME="apigee-cassandra-restore"

     2. Associe a função de 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

     3. Anotar a conta de serviço:

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

     1. Redefina a KSA_NAMEvariável de ambiente:

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

        Associe a função de 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

     2. Anotar a conta de serviço:

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

     apigee-cassandra-schema-val-service-account-name

     1. Redefina a KSA_NAMEvariável de ambiente:

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

     2. Associe a função de 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

     3. Anotar a conta de serviço:

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

     apigee-cassandra-user-setup-service-account-name

     1. Redefina a KSA_NAMEvariável de ambiente:

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

     2. Associe a função de 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

     3. Anotar a conta de serviço:

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

     apigee-datastore-default-sa

     1. Redefina a KSA_NAMEvariável de ambiente:

        KSA_NAME="apigee-datastore-default-sa"

     2. Associe a função de 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

     3. Anotar a conta de serviço:

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

     Não prod

     apigee-cassandra-backup

     1. Defina as variáveis de ambiente KSA_NAME e GSA_NAME:

        GSA_NAME="apigee-non-prod"
        KSA_NAME="apigee-connect-agent-service-account-name"

     2. Associe a função de 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

     3. Anotar a conta de serviço:

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

     apigee-cassandra-restore

     1. Redefina a KSA_NAMEvariável de ambiente:

        KSA_NAME="apigee-cassandra-restore"

     2. Associe a função de 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

     3. Anotar a conta de serviço:

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

     apigee-cassandra-schema-setup-service-account-name

     1. Redefina a KSA_NAMEvariável de ambiente:

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

     2. Associe a função de 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

     3. Anotar a conta de serviço:

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

     apigee-cassandra-schema-val-service-account-name

     1. Redefina a KSA_NAMEvariável de ambiente:

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

     2. Associe a função de 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

     3. Anotar a conta de serviço:

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

     apigee-cassandra-user-setup-service-account-name

     1. Redefina a KSA_NAMEvariável de ambiente:

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

     2. Associe a função de 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

     3. Anotar a conta de serviço:

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

     apigee-datastore-default-sa

     1. Redefina a KSA_NAMEvariável de ambiente:

        KSA_NAME="apigee-datastore-default-sa"

     2. Associe a função de 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

     3. Anotar a conta de serviço:

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

   • Apigee Connect

     Prod

     1. Defina as variáveis de ambiente KSA_NAME e GSA_NAME:

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

     2. Associe a função de 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

     3. Anotar a conta de serviço:

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

     Não prod

     1. Defina a KSA_NAMEvariável de ambiente:

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

     2. Associe a função de 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

     3. Anotar a conta de serviço:

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

   • MART

     Prod

     1. Defina as variáveis de ambiente KSA_NAME e GSA_NAME:

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

     2. Associe a função de 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

     3. Anotar a conta de serviço:

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

     Não prod

     1. Defina a KSA_NAMEvariável de ambiente:

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

     2. Associe a função de 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

     3. Anotar a conta de serviço:

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

   • Métricas da Apigee

     Prod

     1. Defina as variáveis de ambiente KSA_NAME e GSA_NAME:

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

     2. Associe a função de 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

     3. Anotar a conta de serviço:

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

     Não prod

     1. Defina a KSA_NAMEvariável de ambiente:

        KSA_NAME="apigee-metrics-sa"

     2. Associe a função de 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

     3. Anotar a conta de serviço:

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

   • UDCA (org-level)

     Prod

     1. Defina as variáveis de ambiente KSA_NAME e GSA_NAME:

        GSA_NAME="apigee-udca"
        KSA_NAME="apigee-udca-org-level-service-account-name"

     2. Associe a função de 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

     3. Anotar a conta de serviço:

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

     Não prod

     1. Defina as KSA_NAMEvariáveis de ambiente:

        KSA_NAME="apigee-udca-org-level-service-account-name"

     2. Associe a função de 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

     3. Anotar a conta de serviço:

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

   • Apigee Watcher

     Prod

     1. Defina as variáveis de ambiente KSA_NAME e GSA_NAME:

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

     2. Associe a função de 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

     3. Anotar a conta de serviço:

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

     Não prod

     1. Defina a KSA_NAMEvariável de ambiente:

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

     2. Associe a função de 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

     3. Anotar a conta de serviço:

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

   Para cada ambiente:

   • Tempo de execução

     Prod

     1. Defina as variáveis de ambiente KSA_NAME e GSA_NAME:

        GSA_NAME="apigee-runtime"
        KSA_NAME="apigee-runtime-service-account-name"

     2. Associe a função de 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

     3. Anotar a conta de serviço:

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

     Não prod

     1. Defina a KSA_NAMEvariável de ambiente:

        KSA_NAME="apigee-runtime-service-account-name"

     2. Associe a função de 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

     3. Anotar a conta de serviço:

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

   • Synchronizer

     Prod

     1. Defina as variáveis de ambiente KSA_NAME e GSA_NAME:

        GSA_NAME="apigee-synchronizer"
        KSA_NAME="apigee-synchronizer-service-account-name"

     2. Associe a função de 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

     3. Anotar a conta de serviço:

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

     Não prod

     1. Defina a KSA_NAMEvariável de ambiente:

        KSA_NAME="apigee-synchronizer-service-account-name"

     2. Associe a função de 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

     3. Anotar a conta de serviço:

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

   • UDCA (env-level)

     Prod

     1. Defina as variáveis de ambiente KSA_NAME e GSA_NAME:

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

     2. Associe a função de 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

     3. Anotar a conta de serviço:

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

     Não prod

     1. Defina a KSA_NAMEvariável de ambiente:

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

     2. Associe a função de 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

     3. Anotar a conta de serviço:

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

2. Valide se os passos funcionaram:

   gcloud config set project $PROJECT_ID
   

   Selecione uma conta de serviço do Kubernetes para testar, por exemplo: apigee-cassandra-backup.

   KSA_NAME="kubernetes-service-account-name"
   

   kubectl run --rm -it --image google/cloud-sdk:slim \
     --namespace $NAMESPACE workload-identity-test\
     -- gcloud auth list

   Se não vir uma linha de comandos, experimente premir Enter.

   Se os passos foram executados corretamente, deve ver uma resposta semelhante à seguinte:

                      Credentialed Accounts
   ACTIVE  ACCOUNT
   *       GSA@PROJECT_ID.iam.gserviceaccount.com

3. Se estiver a fazer a atualização a partir de uma instalação anterior, limpe os segredos que continham chaves privadas de contas de serviço:

   kubectl delete secrets -n $NAMESPACE $(k get secrets -n $NAMESPACE | grep svc-account | awk '{print $1}')
   

4. Verifique os registos:

   kubectl logs -n $NAMESPACE -l app=apigee=synchronizer,env=$ENV_NAME,org=$ORG_NAME apigee-synchronizer
   

Atualize uma instalação para usar o Workload Identity

Siga estas instruções para adicionar o Workload Identity a uma instalação híbrida existente.

Segue-se um exemplo que mostra as contas de serviço Google (GSAs) criadas para o Apigee:

gcloud iam service-accounts list --filter "apigee"

DISPLAY NAME       EMAIL                                                  DISABLED
apigee-cassandra   apigee-cassandra@PROJECT_ID.iam.gserviceaccount.com    False
apigee-connect     apigee-connect@PROJECT_ID.iam.gserviceaccount.com      False
apigee-runtime     apigee-runtime@PROJECT_ID.iam.gserviceaccount.com      False
apigee-metrics     apigee-metrics@PROJECT_ID.iam.gserviceaccount.com      False
apigee-mart        apigee-mart@PROJECT_ID.iam.gserviceaccount.com         False
apigee-watcher     apigee-watcher@PROJECT_ID.iam.gserviceaccount.com      False
apigee-sync        apigee-sync@PROJECT_ID.iam.gserviceaccount.com         False
apigee-udca        apigee-udca@$PROJECT_ID.iam.gserviceaccount.com        False

Segue-se um exemplo de contas de serviço do Kubernetes (KSA) criadas para o Apigee:

kubectl get sa -n $NAMESPACE

apigee-cassandra-schema-setup-ORG_NAME-cb84b88-sa             1         xxd
apigee-cassandra-user-setup-ORG_NAME-cb84b88-sa               1         xxd
apigee-connect-agent-ORG_NAME-cb84b88-sa                      1         xxd
apigee-init                                                   1         xxd
apigee-mart-ORG_NAME-cb84b88-sa                               1         xxd
apigee-metrics-apigee-telemetry                               1         xxd
apigee-runtime-ORG_NAME-ENV_NAME-1d0dc5e-sa                   1         xxd
apigee-synchronizer-ORG_NAME-ENV_NAME-1d0dc5e-sa              1         xxd
apigee-udca-ORG_NAME-ENV_NAME-1d0dc5e-sa                      1         xxd
apigee-watcher-ORG_NAME-cb84b88                               1         xxd

Onde: ORG_NAME e ENV_NAME podem ser uma versão abreviada dos nomes da organização e do ambiente.

1. Adicione a função de identidade de carga de trabalho a cada conta de serviço:

   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
   

   Por exemplo, se estivesse a definir as autorizações para o Apigee Synchronizer, executaria o seguinte comando:

   export KSA_NAME=$(kubectl get sa -n apigee -l app=apigee-synchronizer,env=$ENV_NAME,org=$ORG_NAME --output=jsonpath={.items..metadata.name})
   

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

2. Anote cada KSA com os detalhes da GSA:

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

   Por exemplo, se estivesse a definir as autorizações para o Apigee Synchronizer, executaria o seguinte comando:

   export KSA_NAME=$(kubectl get sa -n apigee -l app=apigee-synchronizer,env=$ENV_NAME,org=$ORG_NAME --output=jsonpath={.items..metadata.name})
   

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

3. Valide se os passos funcionaram:

   gcloud config set project $PROJECT_ID
   

     kubectl run --rm -it --image google/cloud-sdk:slim \
       --namespace $NAMESPACE workload-identity-test\
       -- gcloud auth list

   Se não vir uma linha de comandos, experimente premir Enter.

   Se os passos foram executados corretamente, deve ver uma resposta semelhante à seguinte:

                      Credentialed Accounts
   ACTIVE  ACCOUNT
   *       GSA@PROJECT_ID.iam.gserviceaccount.com

4. Se estiver a fazer a atualização a partir de uma instalação anterior, limpe os segredos que continham chaves privadas de contas de serviço:

   kubectl delete secrets -n $NAMESPACE $(k get secrets -n $NAMESPACE | grep svc-account | awk '{print $1}')
   

5. Verifique os registos:

   kubectl logs -n $NAMESPACE -l app=apigee=synchronizer,env=$ENV_NAME,org=$ORG_NAME apigee-synchronizer