Como ativar a Identidade da carga de trabalho com a apigeectl

Você está visualizando a versão 1.11 da documentação da Apigee híbrida. Para mais informações, consulte Versões compatíveis.

Version 1.11 

Versões com suporte:

• v1.13 (mais recente)                        
• v1.12                         
• v1.11
• Lista de versões com suporte

Versões sem suporte:

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

Neste tópico, explicamos como ativar a Identidade da carga de trabalho para a Apigee híbrida usando apigeectl.

Se você estiver usando gráficos do Helm para instalar e gerenciar a Apigee híbrida, consulte Como ativar a Identidade da carga de trabalho com gráficos do Helm.

Observação: a Apigee híbrida v.1.11 só é compatível com a federação de identidade da carga de trabalho no GKE.

Visão geral

A Identidade da carga de trabalho é uma maneira de aplicativos em execução no GKE (Google Kubernetes Engine) acessarem os serviços do Google Cloud. Para visões gerais da Identidade da carga de trabalho, consulte:

• Introdução à Identidade da carga de trabalho: autenticação aprimorada para seus aplicativos do GKE
• Como usar a Identidade da carga de trabalho

Uma conta de serviço do Google Cloud IAM é uma identidade que um aplicativo pode usar para fazer solicitações às APIs do Google. Essas contas de serviço são chamadas de GSA (Contas de serviço do Google) no documento. Para mais informações sobre os GSAs, consulte Contas de serviço.

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

Com a Apigee híbrida 1.4 e posterior, a Apigee cria e usa uma conta de serviço do Kubernetes para cada tipo de componente. A ativação da Identidade da carga de trabalho permite que os componentes híbridos se conectem com as contas de serviço do Kubernetes.

Contas de serviço do Google na Apigee híbrida sem a Identidade da carga de trabalho

Sem usar a Identidade da carga de trabalho, é preciso vincular as contas de serviço do Google a cada componente no arquivo overrides.yaml com uma referência a um arquivo de certificado ou a um secret do Kubernetes. Por exemplo:

• Arquivos específicos:

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

  Veja estes tópicos:

  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

• Secret do Kubernetes:

  watcher:
    serviceAccountRef: my-watcher-k8s-secret

  Veja estes tópicos:

  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

Esses procedimentos usam as seguintes variáveis de ambiente. Elas podem ser definidas no shell de comando ou substituídas nas amostras de código por valores reais:

• APIGEECTL_HOME: o diretório em que você instalou apigeectl.
• CLUSTER_LOCATION: a região ou zona do cluster. Por exemplo: us-west1.
• ENV_NAME: nome do ambiente da Apigee.
• HYBRID_FILES: o diretório de arquivos híbridos. Por exemplo, hybrid-base-directory/hybrid-files.
• ORG_NAME: o nome da organização da Apigee.
• PROJECT_ID: o ID do projeto do Google Cloud.
• NAMESPACE: seu namespace da Apigee (geralmente "apigee").

Verifique as variáveis de ambiente:

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

Inicialize uma das variáveis necessárias:

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

Identidade da carga de trabalho e arquivos de chave da conta de serviço

Ao executar a Apigee híbrida no GKE, a prática padrão é criar e fazer o download de chaves privadas (arquivos .json) para cada uma das contas de serviço. Ao usar a Identidade da carga de trabalho, você não precisa fazer o download de chaves privadas de contas de serviço e adicioná-las a Clusters do GKE.

Se você fez o download de arquivos de chave de conta de serviço como parte da instalação da Apigee híbrida, é possível excluí-los depois de ativar a Identidade da carga de trabalho. Na maioria das instalações, elas residem no diretório hybrid-base-directory/hybrid-files/service-accounts/.

Ativar a Identidade da carga de trabalho para a Apigee híbrida

Para começar, siga as instruções em Como se preparar para ativar a Identidade da carga de trabalho para atualizar pools de nós e inicializar variáveis antes de ativar a Identidade da carga de trabalho.

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 instalação da Apigee híbrida.

Prepare-se para ativar a Identidade da carga de trabalho.

Antes de iniciar o processo de instalação, siga as etapas nesta seção.

1. Defina o projeto como o projeto que você está modificando:

   gcloud config set project $PROJECT_ID

2. Receba as credenciais de gcloud do cluster em que você está ativando a Identidade da carga de trabalho com o seguinte comando:

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

   Observação: se você criou um cluster zonal em vez de um cluster regional, consiga as credenciais com este comando:

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

3. Verifique se a Identidade da carga de trabalho está ativada no cluster do GKE que executa a Apigee com o seguinte comando:

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

   Observação: para clusters zonais, use:

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

   A resposta incluirá algo semelhante ao seguinte:

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

   Se necessário, ative a Identidade da carga de trabalho no cluster. Esta operação pode levar até 30 minutos.

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

   Observação: se você criou um cluster zonal em vez de um cluster regional, use o argumento --zone em vez de --region, como no comando a seguir:

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

   Para mais informações, consulte Ativar a Identidade da carga de trabalho.

4. Verifique se a Identidade da carga de trabalho está ativada em cada pool de nós.
   1. Liste os pools de nós com o seguinte comando:

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

      A resposta será semelhante a esta:

        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. Verifique se a Identidade da carga de trabalho está ativada por pool de nós usando o seguinte comando para cada pool de nós:

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

      Em que NODE_POOL_NAME é o nome de cada pool de nós.

Verificar ou criar contas de serviço do Google

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

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

   gcloud iam service-accounts list --project $PROJECT_ID

   A resposta será semelhante a esta:

   Prod.

   Para ambientes de 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
   

   Sem produção

   Para ambientes de produção:

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

   Dica: se você tiver nomes personalizados para suas contas de serviço que não sejam fáceis de corresponder com os nomes dos componentes da Apigee, é possível determinar o papel das contas de serviço verificando os papéis atribuídos a elas e comparando os papéis com aqueles recomendados em Sobre contas de serviço.

   Use o comando a seguir para verificar os papéis atribuídos 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 você precisar criar as contas de serviço do Google para seu projeto, poderá usar dois métodos:

   • Use a ferramenta create-service-account incluída na Apigee no diretório apigeectl/tools/. Essa ferramenta cria todas as contas de serviço com um único comando ou permite criá-las individualmente.
     create-service-account gera arquivos de chave para cada conta de serviço e faz o download deles. Com a Identidade da carga de trabalho, esses arquivos de chave não serão necessários. Se você estiver preocupado com a segurança desses arquivos de chave, convém excluí-los. Como alternativa, é possível usar gcloud para criar as contas de serviço e atribuir os papéis apropriados a elas.
   • 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 os papéis apropriados a cada conta de serviço. Esse método requer a criação de cada conta de serviço individualmente, mas permite que você evite fazer o download dos arquivos de chave.

   create-service-account

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

   Prod.

   Para ambientes de produção:

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

   Esse comando criará as seguintes contas de serviço:

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

   Sem produção

   Para ambientes de produção:

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

   Esse comando criará uma única conta de serviço, apigee-non-prod, com todos os papéis atribuídos necessários para gerenciar todos os componentes da Apigee.

   gcloud

   Crie as contas de serviço a seguir e atribua papéis a elas.

   Dica: se quiser usar nomes personalizados, mude o nome da conta de serviço vermelha no exemplo de código para o nome que você quer usar.

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

      Crie a conta:

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

      Atribua o papel:

      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, papel : roles/logging.logWriter

      Crie a conta:

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

      Atribua o papel:

      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, papel : roles/apigeeconnect.Agent

      Crie a conta:

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

      Atribua o papel:

      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, papel : roles/monitoring.metricWriter

      Crie a conta:

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

      Atribua o papel:

      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, role: nenhum papel atribuído.

      Crie a conta:

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

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

      Crie a conta:

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

      Atribua o papel:

      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, papel : roles/apigee.analyticsAgent

      Crie a conta:

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

      Atribua o papel:

      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, papel : roles/apigee.runtimeAgent

      Crie a conta:

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

      Atribua o papel:

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

Definir workloadIdentityEnabled: true e criar contas de serviço

apigeectl cria contas de serviço do Kubernetes para cada componente da Apigee híbrida quando você define workloadIdentityEnabled: true no arquivo de substituição e aplica as alterações.

1. Adicione a linha destacada abaixo para o arquivo overrides.yaml, na estrofe gcp: Isso ativa a Identidade da carga de trabalho para a instalação e aciona apigeectl para criar as contas de serviço do Kubernetes quando você aplica a configuração:

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

2. Adicione as linhas destacada abaixo para o arquivo overrides.yaml, na estrofe cassandra: Isso aciona a criação da conta de serviço do Kubernetes apigee-cassandra-backup:

   cassandra:
     ...
     backup:
       enabled: true

3. Aplique as mudanças com apigeectl usando o flag --restore:

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

   Observação: a sinalização --restore aciona a criação da conta de serviço apigee-cassandra-restore do Kubernetes.
4. Verifique as contas de serviço com o seguinte comando:

   kubectl get sa -n $NAMESPACE

   A saída será semelhante a esta: As contas de serviço do Kubernetes em negrito são as que você precisará anotar com as contas de serviço do 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 do Google

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

Componentes no nível da organização

Você terá apenas uma instância de cada conta de serviço do Kubernetes para a organização da Apigee.

Componente	Conta de serviço do Kubernetes	Conta de serviço do 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 (nível organizacional)	apigee-udca-my-project-id-num-id1-sa	apigee-udca
Watcher	apigee-watcher-my-project-id-num-id1-sa	apigee-watcher

Componentes no nível do ambiente

Você vai ter uma instância de cada conta de serviço do Kubernetes para cada ambiente da Apigee.

Componente	Conta de serviço do Kubernetes	Conta de serviço do Google
Ambiente de execução da Apigee: -	apigee-runtime-my-project-id-env-name-num-id2-sa	apigee-runtime
Sincronizador	apigee-synchronizer-my-project-id-env-name-num-id2-sa	apigee-synchronizer
UDCA (nível do ambiente)	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 padrão criados por create-service-account, nos comandos a seguir substitua o nome em vermelho da conta de serviço pelo nome da conta serviço correta do componente. Por exemplo, se o nome da conta de serviço do Cassandra for my-cassandra-accnt-1, substitua apigee-cassandra por esse nome no comando.

Nos comandos a seguir, use os nomes de conta de serviço do Kubernetes retornados 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, você vai:

• vincular a conta de serviço do Kubernetes e a conta de serviço principal do Google ao papel do IAM roles/iam.workloadIdentityUser;
• anotar a conta de serviço do Kubernetes com a conta de serviço do Google;

1. vincular os papéis e anotar as contas de serviço.

   Componentes no nível da organização

   Anotar contas de serviço do Kubernetes para os componentes no nível da organização. É necessário fazer isso uma vez para cada componente na organização da 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. Vincule o papel do 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. Anote 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. Vincule o papel do 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. Anote 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 variável de ambiente KSA_NAME:

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

        Vincule o papel do 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. Anote 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 variável de ambiente KSA_NAME:

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

     2. Vincule o papel do 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. Anote 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 variável de ambiente KSA_NAME:

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

     2. Vincule o papel do 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. Anote 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 variável de ambiente KSA_NAME:

        KSA_NAME="apigee-datastore-default-sa"

     2. Vincule o papel do 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. Anote 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

     Sem produção

     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. Vincule o papel do 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. Anote 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 variável de ambiente KSA_NAME:

        KSA_NAME="apigee-cassandra-restore"

     2. Vincule o papel do 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. Anote 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 variável de ambiente KSA_NAME:

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

     2. Vincule o papel do 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. Anote 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 variável de ambiente KSA_NAME:

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

     2. Vincule o papel do 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. Anote 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 variável de ambiente KSA_NAME:

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

     2. Vincule o papel do 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. Anote 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 variável de ambiente KSA_NAME:

        KSA_NAME="apigee-datastore-default-sa"

     2. Vincule o papel do 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. Anote 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. Vincule o papel do 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. Anote 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

     Sem produção

     1. Defina a variável de ambiente KSA_NAME:

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

     2. Vincule o papel do 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. Anote 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. Vincule o papel do 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. Anote 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

     Sem produção

     1. Defina a variável de ambiente KSA_NAME:

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

     2. Vincule o papel do 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. Anote 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. Vincule o papel do 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. Anote 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

     Sem produção

     1. Defina a variável de ambiente KSA_NAME:

        KSA_NAME="apigee-metrics-sa"

     2. Vincule o papel do 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. Anote 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 (nível organizacional)

     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. Vincule o papel do 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. Anote 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

     Sem produção

     1. Defina as variáveis de ambiente KSA_NAME:

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

     2. Vincule o papel do 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. Anote 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. Vincule o papel do 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. Anote 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

     Sem produção

     1. Defina a variável de ambiente KSA_NAME:

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

     2. Vincule o papel do 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. Anote 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:

   • Ambiente 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. Vincule o papel do 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. Anote 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

     Sem produção

     1. Defina a variável de ambiente KSA_NAME:

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

     2. Vincule o papel do 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. Anote 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. Vincule o papel do 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. Anote 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

     Sem produção

     1. Defina a variável de ambiente KSA_NAME:

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

     2. Vincule o papel do 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. Anote 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 (nível do ambiente)

     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. Vincule o papel do 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. Anote 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

     Sem produção

     1. Defina a variável de ambiente KSA_NAME:

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

     2. Vincule o papel do 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. Anote 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 as etapas funcionaram:

   gcloud config set project $PROJECT_ID
   

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

   Caso o prompt de comando não seja exibido, pressione Enter.

   Se as etapas tiverem sido executadas corretamente, você verá uma resposta como esta:

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

3. Se estiver fazendo upgrade de uma instalação anterior, limpe os secrets que continham chaves privadas de conta de serviço:

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

4. Verifique os registros:

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

5. (Opcional) Veja o status das suas contas de serviço do Kubernetes na página Kubernetes: visão geral das cargas de trabalho no console do Google Cloud.

   Acesse "Cargas de trabalho"

   Observação: talvez você veja um status de erro das contas de serviço apigee-cassandra-backup e apigee-cassandra-restore. Isso ocorre porque, no momento, você não está executando backup ou restauração, e esses processos ainda não foram totalmente configurados. Para mais informações sobre o backup e a restauração do Cassandra, consulte a visão geral de backup do feedbackCassandra.