Como ativar a Identidade da carga de trabalho com a apigeectl

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.

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:

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

Defina o projeto como o projeto que você está modificando:
```
gcloud config set project $PROJECT_ID
```
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}
```

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.

Verifique se a Identidade da carga de trabalho está ativada em cada pool de nós.

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

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.

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 que não sejam 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 que não sejam 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.

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"

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"

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"

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"

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

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"

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"

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.

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
```
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
```
Aplique as mudanças com apigeectl usando o flag --restore:
```
$APIGEECTL_HOME/apigeectl apply -f overrides/overrides.yaml --restore
```
Observação: a flag --restore aciona a criação da conta de serviço do apigee-cassandra-restore do Kubernetes.

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;

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

Defina as variáveis de ambiente KSA_NAME e GSA_NAME:

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

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

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

Redefina a variável de ambiente KSA_NAME:
```
KSA_NAME="apigee-cassandra-restore"
```

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

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

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

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

Redefina a variável de ambiente KSA_NAME:

KSA_NAME="apigee-cassandra-schema-val-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

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

Redefina a variável de ambiente KSA_NAME:

KSA_NAME="apigee-cassandra-user-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

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

Redefina a variável de ambiente KSA_NAME:
```
KSA_NAME="apigee-datastore-default-sa"
```

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

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

Defina as variáveis de ambiente KSA_NAME e GSA_NAME:

GSA_NAME="apigee-non-prod"
KSA_NAME="apigee-connect-agent-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

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

Redefina a variável de ambiente KSA_NAME:
```
KSA_NAME="apigee-cassandra-restore"
```

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

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

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

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

Redefina a variável de ambiente KSA_NAME:

KSA_NAME="apigee-cassandra-schema-val-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

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

Redefina a variável de ambiente KSA_NAME:

KSA_NAME="apigee-cassandra-user-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

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

Redefina a variável de ambiente KSA_NAME:
```
KSA_NAME="apigee-datastore-default-sa"
```

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

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.

Defina as variáveis de ambiente KSA_NAME e GSA_NAME:

GSA_NAME="apigee-mart"
KSA_NAME="apigee-connect-agent-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

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

Defina a variável de ambiente KSA_NAME:

KSA_NAME="apigee-connect-agent-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

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.

Defina as variáveis de ambiente KSA_NAME e GSA_NAME:

GSA_NAME="apigee-mart"
KSA_NAME="apigee-mart-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

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

Defina a variável de ambiente KSA_NAME:

KSA_NAME="apigee-mart-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

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.

Defina as variáveis de ambiente KSA_NAME e GSA_NAME:

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

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

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

Defina a variável de ambiente KSA_NAME:
```
KSA_NAME="apigee-metrics-sa"
```

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

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.

Defina as variáveis de ambiente KSA_NAME e GSA_NAME:

GSA_NAME="apigee-udca"
KSA_NAME="apigee-udca-org-level-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

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

Defina as variáveis de ambiente KSA_NAME:

KSA_NAME="apigee-udca-org-level-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

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.

Defina as variáveis de ambiente KSA_NAME e GSA_NAME:

GSA_NAME="apigee-watcher"
KSA_NAME="apigee-watcher-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

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

Defina a variável de ambiente KSA_NAME:

KSA_NAME="apigee-watcher-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

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.

Defina as variáveis de ambiente KSA_NAME e GSA_NAME:

GSA_NAME="apigee-runtime"
KSA_NAME="apigee-runtime-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

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

Defina a variável de ambiente KSA_NAME:

KSA_NAME="apigee-runtime-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

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.

Defina as variáveis de ambiente KSA_NAME e GSA_NAME:

GSA_NAME="apigee-synchronizer"
KSA_NAME="apigee-synchronizer-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

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

Defina a variável de ambiente KSA_NAME:

KSA_NAME="apigee-synchronizer-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

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.

Defina as variáveis de ambiente KSA_NAME e GSA_NAME:

GSA_NAME="apigee-udca"
KSA_NAME="apigee-udca-env-level-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

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

Defina a variável de ambiente KSA_NAME:

KSA_NAME="apigee-udca-env-level-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

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

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

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}')
```

Verifique os registros:

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

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

Como ativar a Identidade da carga de trabalho com a apigeectl

Visão geral

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

Variáveis de ambiente usadas nestes procedimentos

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

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

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

Verificar ou criar contas de serviço do Google

Prod.

Sem produção

create-service-account

Prod.

Sem produção

gcloud

Definir workloadIdentityEnabled: true e criar contas de serviço

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

Componentes no nível da organização

Componentes no nível do ambiente

Componentes no nível da organização

Prod.

Sem produção

Prod.

Sem produção

Prod.

Sem produção

Prod.

Sem produção

Prod.

Sem produção

Prod.

Sem produção

Prod.

Sem produção

Prod.

Sem produção

Prod.

Sem produção

`create-service-account`

`gcloud`

Definir `workloadIdentityEnabled: true` e criar contas de serviço