Esta página foi traduzida pela API Cloud Translation.

Como ativar a federação de identidade da carga de trabalho no AKS e no EKS
Mantenha tudo organizado com as coleções Salve e categorize o conteúdo com base nas suas preferências.

Neste tópico, explicamos como ativar a Federação de identidade da carga de trabalho para instalações da Apigee híbrida nas plataformas AKS e EKS.

Para instalações no GKE, siga as instruções em Como ativar a Identidade da carga de trabalho no GKE.

Visão geral

A federação de identidade da carga de trabalho permite que aplicativos em execução fora do Google Cloud representem uma conta de serviço do Google Cloud Platform usando credenciais de um provedor de identidade externo.

O uso da federação de identidade da carga de trabalho pode ajudar a melhorar a segurança, permitindo que os aplicativos usem os mecanismos de autenticação fornecidos pelo ambiente externo e possam substituir as chaves da conta de serviço.

Para ter uma visão geral, consulte Práticas recomendadas para usar a federação de identidade da carga de trabalho.

Observação: o componente apigee-logger não é compatível com a federação de identidade da carga de trabalho. Consulte o problema conhecido.

Configurar a federação de identidade da carga de trabalho

Para usar a federação de identidade da carga de trabalho com a Apigee híbrida, primeiro configure o cluster e, em seguida, aplique o recurso à instalação da Apigee híbrida.

Antes de começar

Estas instruções presumem que você já tenha configurado a instalação híbrida da Apigee. As contas de serviço do IAM e do Kubernetes são criadas durante a instalação inicial. Consulte O quadro geral para ter uma visão geral da instalação da Apigee híbrida.

Para instalações no AKS, verifique se você ativou o emissor do OpenID Connect (OIDC). Ative esse recurso para que a federação de identidade da carga de trabalho possa acessar os metadados do OpenID Connect e o conjunto de chaves da Web JSON (JWKS) do cluster.

Configure seu cluster para usar a federação de identidade da carga de trabalho.

Verifique se a configuração gcloud atual está definida como o ID do projeto do Google Cloud com o comando a seguir:
```
gcloud config get project
```

Se necessário, defina a configuração atual da gcloud:

gcloud config set project PROJECT_ID

Ative a API Security Token Service:
Verifique se a API Security Token Service está ativada com o seguinte comando:
```
gcloud services list --enabled --project PROJECT_ID | grep sts.googleapis.com
```
Se a API não estiver ativada:
Console

Enable the Security Token Service API.
Enable the API
Linha de comando

Ative a API com este comando:
```
gcloud services enable sts.googleapis.com --project PROJECT_ID
```
Crie o pool de identidade e o provedor da carga de trabalho.
Funções exigidas
Para receber as permissões necessárias para configurar a federação de identidade da carga de trabalho, peça ao administrador para conceder a você os seguintes papéis do IAM no projeto:
- Administrador de pool de Identidade da carga de trabalho (roles/iam.workloadIdentityPoolAdmin)
- Administrador da conta de serviço (roles/iam.serviceAccountAdmin)
Para mais informações sobre a concessão de papéis, consulte Gerenciar o acesso a projetos, pastas e organizações.

Também é possível conseguir as permissões necessárias por meio de papéis personalizados ou de outros papéis predefinidos.
Como alternativa, o papel básico de Proprietário do IAM (roles/owner) também inclui permissões para configurar a federação de identidade. Não conceda papéis básicos em um ambiente de produção, mas é possível fazer isso em um ambiente de desenvolvimento ou teste.
Para criar um pool de identidades e um provedor de carga de trabalho, faça o seguinte:
1. Determine o URL do emissor do cluster do AKS:
  AKS
  az aks show -n NAME -g RESOURCE_GROUP --query "oidcIssuerProfile.issuerUrl" -otsv
  Substitua:
  - NAME: o nome do cluster.
  - RESOURCE_GROUP: o grupo de recursos do cluster.
  O comando gera o URL do emissor. Você precisa do URL do emissor em uma das etapas a seguir.
  
  Se o comando não retornar um URL do emissor, verifique se você ativou o recurso emissor do OIDC.
  EKS
  aws eks describe-cluster --name NAME --query "cluster.identity.oidc.issuer" --output text
  Substitua NAME pelo nome do cluster.
  
  O comando gera o URL do emissor. Você precisa do URL do emissor em uma das etapas a seguir.
  Outros Kubernetes
  1. Conecte-se ao cluster do Kubernetes e use o "kubectl" para determinar o URL do emissor do cluster:
    kubectl get --raw /.well-known/openid-configuration | jq -r .issuer
    
    Você precisa do URL do emissor em uma das etapas a seguir.
2. Opcional:se o emissor do OIDC não for acessível publicamente, faça o download do conjunto de chaves da Web JSON (JWKS) do cluster:
  Observação:esta etapa requer acesso do kubectl ao cluster.
  
  Dica:ao usar o arquivo JWKS, você vai precisar fazer upload de um novo arquivo JWKS sempre que rotacionar as chaves de assinatura do cluster.
```
kubectl get --raw /openid/v1/jwks > cluster-jwks.json
```
  Para verificar se o provedor OIDC está disponível publicamente, você precisa acessar o URL do provedor com um comando CURL e receber uma resposta 200.
3. Crie um novo pool de identidades de carga de trabalho:
```
gcloud iam workload-identity-pools create POOL_ID \
  --location="global" \
  --description="DESCRIPTION" \
  --display-name="DISPLAY_NAME"
            
```
  Substitua:
  - POOL_ID: o ID exclusivo do pool.
  - DISPLAY_NAME: (opcional) o nome do pool.
  - DESCRIPTION: (opcional) uma descrição do pool escolhido. Essa descrição aparece quando você concede acesso às identidades do pool.
  Exemplo:
```
gcloud iam workload-identity-pools create my-wi-pool --display-name="My workload pool" --description="My workload pool description"
```
4. Adicione o cluster como um provedor de pool de identidade da carga de trabalho. Escolha o comando para criar o provedor, dependendo se o emissor OIDC é público ou não público:
  Acessível publicamente
  
  Se o emissor do OIDC for acessível publicamente, crie o provedor com o seguinte comando:
  gcloud iam workload-identity-pools providers create-oidc WORKLOAD_PROVIDER_ID \ --location="global" \ --workload-identity-pool="POOL_ID" \ --issuer-uri="ISSUER" \ --attribute-mapping="google.subject=assertion.sub"
  Não é acessível ao público
  
  Se o emissor do OIDC não estiver acessível publicamente, crie o provedor com este comando:
  gcloud iam workload-identity-pools providers create-oidc WORKLOAD_PROVIDER_ID \ --location="global" \ --workload-identity-pool="POOL_ID" \ --issuer-uri="ISSUER" \ --jwks-file="cluster-jwks.json" \ --attribute-mapping="google.subject=assertion.sub"
  Observação:se você alternar as chaves, será necessário fazer upload dos novos JWKs a cada rotação.
  O comando não valida o JWKS do cluster. Se o JWKS estiver incorreto ou tiver expirado, as tentativas de autenticação subsequentes poderão falhar com uma mensagem de erro Error connecting to the given credential's issuer.
  Substitua:
  - WORKLOAD_PROVIDER_ID: um ID de provedor do pool de Identidade da carga de trabalho exclusivo de sua escolha.
  - POOL_ID: o ID do pool de Identidade da carga de trabalho que você criou anteriormente.
  - ISSUER: use o URL do emissor que você determinou anteriormente para o URI do emissor .
  attribute-mapping="google.subject=assertion.sub" mapeia o sujeito do Kubernetes para o sujeito do IAM.

Criar os arquivos de configuração de credenciais

Para implantar uma carga de trabalho do Kubernetes que possa acessar recursos Google Cloud , primeiro é necessário criar um arquivo de configuração de credenciais para cada conta de serviço do IAM:

Liste as contas de serviço do IAM (também chamadas de "contas de serviço do Google") com o seguinte comando:
```
gcloud iam service-accounts list --project PROJECT_ID
```
Observação:provavelmente você já criou as contas de serviço do IAM (também chamadas de "contas de serviço do Google") durante a instalação inicial do híbrido da Apigee com a ferramenta create-service-account. Consulte Sobre contas de serviço para conferir uma lista das contas de serviço do IAM necessárias para a Apigee híbrida. Consulte a Etapa 4: criar contas de serviço para ver o procedimento do guia de instalação para criar as contas de serviço do IAM.

Você precisa criar os arquivos de configuração de credenciais para as seguintes contas de serviço do IAM:
Prod.

Para ambientes de produção:
```
DISPLAY NAME         EMAIL                                                      DISABLED
apigee-cassandra     apigee-cassandra@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"
```
Anote qual conta de serviço personalizada corresponde a cada SA do IAM listado na lista anterior.

Crie um arquivo de configuração de credenciais para cada conta de serviço do IAM na lista anterior. Você vai precisar desses arquivos de configuração de credenciais para configurar a Apigee híbrida para usar a federação de identidade da carga de trabalho:

Código

gcloud iam workload-identity-pools create-cred-config \
  projects/PROJECT_NUMBER/locations/global/workloadIdentityPools/POOL_ID/providers/WORKLOAD_PROVIDER_ID \
  --service-account=SERVICE_ACCOUNT_EMAIL \
  --credential-source-file=/var/
  --credential-source-type=text \
  --output-file=SERVICE_ACCOUNT_NAME-credential-configuration.json

Exemplo

gcloud iam workload-identity-pools create-cred-config \
  projects/123123123123/locations/global/workloadIdentityPools/my-wi-pool/providers/my-wi-provider \
  --service-account=apigee-cassandra@myhybridporg.iam.gserviceaccount.com \
  --credential-source-file=/var/
  --credential-source-type=text \
  --output-file=apigee-cassandra-credential-configuration.json

Em que:

PROJECT_NUMBER: o número do projeto que contém o pool de Identidade da carga de trabalho. Esse deve ser o número do projeto, não o ID.
POOL_ID: o ID do pool de identidades da carga de trabalho
WORKLOAD_PROVIDER_ID: o ID do provedor do pool de identidades da carga de trabalho
SERVICE_ACCOUNT_EMAIL: endereço de e-mail da conta de serviço, se você configurou a conta de serviço do Kubernetes para usar a identidade temporária de conta de serviço do IAM.

Importante:credential-source-type precisa ser definido como text.

Observação:não crie um arquivo de configuração de credencial para a conta de serviço apigee-logger.

O arquivo de configuração de credenciais permite que as [bibliotecas de cliente do Cloud](/apis/docs/cloud-client-libraries), a CLI gcloud e o Terraform determinem o seguinte:

De onde receber credenciais externas
Qual pool de identidades de carga de trabalho e provedor usar
Qual conta de serviço representar

Configurar a Apigee híbrida para usar a federação de identidade da carga de trabalho

Copie ou mova cada arquivo de saída (SERVICE_ACCOUNT_NAME-credential-configuration.json) para os diretórios de gráficos a seguir (ou subdiretórios deles). Estes foram os arquivos criados na etapa Criar os arquivos de configuração de credenciais.

Prod.

Conta de serviço	Diretório de gráficos do Apigee Helm
`apigee-cassandra`	`apigee-datastore/`
`apigee-mart`	`apigee-org/`
`apigee-metrics`	`apigee-telemetry/`
`apigee-runtime`	`apigee-env/`
`apigee-synchronizer`	`apigee-env/`
`apigee-udca`	`apigee-org/` `apigee-env/`
`apigee-watcher`	`apigee-org/`

Sem produção

Conta de serviço	Gráfico do Apigee Helm
`apigee-non-prod`	`apigee-datastore/` `apigee-telemetry/` `apigee-org/` `apigee-env/`

Faça as seguintes alterações globais no arquivo de substituições do cluster:

Código

gcp:
  workloadIdentity:
    enabled: false # must be set to false to use Workload Identity Federation
  federatedWorkloadIdentity:
    enabled: true
    audience: "AUDIENCE"
    credentialSourceFile: "/var/run/service-account/token"

Exemplo

gcp:
  workloadIdentity:
    enabled: false
  federatedWorkloadIdentity:
    enabled: true
    audience: "//iam.googleapis.com/projects/123123123123/locations/global/workloadIdentityPools/my-wi-pool/providers/my-wi-provider"
    credentialSourceFile: "/var/run/service-account/token"

Onde: AUDIENCE é o público-alvo permitido do provedor de identidade da carga de trabalho. Para encontrar o valor, pesquise o termo audience: em qualquer um dos arquivos de configuração de credenciais. O valor do público-alvo é o mesmo em cada arquivo de configuração de credencial.

Por exemplo, no seguinte arquivo de amostra apigee-udca-credential-configuration.json:

{
  "universe_domain": "googleapis.com",
  "type": "external_account:,"
  "audience": "//iam.googleapis.com/projects/123123123123/locations/global/workloadIdentityPools/my-wi-pool/providers/my-wi-provider",
  "subject_token_type": "urn:ietf:params:oauth: token-type:jwt",
  "token_url": "https://sts.googleapis.com/v1/token",
  "service
  "impersonation_url": "https://iamcredentials.googleapis.com/v1/projects/-/serviceAccounts/apigee-udca@myhybridproject.iam.gserviceaccount.com:generateAccessToken",
  "credential_source": {
    "file": "/var/run/service-account/token",
    "format": {
      "type": "text"
    }
  }
}

O valor do público-alvo é //iam.googleapis.com/projects/123123123123/locations/global/workloadIdentityPools/my-wi-pool/providers/my-wi-provider.

Configure as substituições para cada componente usando a federação de identidade da carga de trabalho. Selecione as instruções para arquivos de certificado, secrets do Kubernetes ou Vault, conforme apropriado para sua instalação.

Arquivo de certificação

Substitua o valor de serviceAccountPath pelo arquivo de origem da credencial da conta de serviço do IAM correspondente. Precisa ser o caminho relativo para o diretório do gráfico. Por exemplo:

envs:
- name: ENVIRONMENT_NAME
  serviceAccountPaths:
    synchronizer: apigee-synchronizer-credential-configuration.json
    runtime: apigee-runtime-credential-configuration.json
    udca: udca-credential-configuration.json

mart:
  serviceAccountPath: mart-credential-configuration.json

connectAgent:
  serviceAccountPath: mart-credential-configuration.json

metrics:
  serviceAccountPath: metrics-credential-configuration.json

udca:
  serviceAccountPath: UDCA_SERVICE_ACCOUNT_FILEPATH

watcher:
  serviceAccountPath: WATCHER_SERVICE_ACCOUNT_FILEPATH

Secret do K8s

Crie um novo secret do Kubernetes usando o arquivo de origem da credencial para cada arquivo de configuração de credencial.

kubectl create secret -n APIGEE_NAMESPACE generic SECRET_NAME --from-file="client_secret.json=CREDENTIAL_CONFIGURATION_FILE"

Exemplo:

kubectl create secret -n apigee generic udca-workoad-identity-secret --from-file="client_secret.json=./apigee-udca-credential-configuration.json"

Substitua o valor de serviceAccountRef pelo novo secret. Por exemplo:
```
udca:
  serviceAccountRef: udca-workoad-identity-secret
```

Vault

Atualize a chave da conta de serviço, SAKEY, para cada conta de serviço no Vault com o arquivo de origem de credenciais correspondente. O procedimento é semelhante para todos os componentes. Por exemplo, para UDCA:

SAKEY=$(cat .apigee-udca-credential-configuration.json); kubectl -n APIGEE_NAMESPACE exec vault-0 -- vault kv patch secret/apigee/orgsakeys udca="$SAKEY"

Consulte Storing service account keys in Hashicorp Vault para mais informações.

Aplique as mudanças a cada componente afetado com o comando helm upgrade:

Se você atualizou as chaves da conta de serviço do Vault, atualize o gráfico apigee-operator.

helm upgrade operator apigee-operator/ \
  --namespace APIGEE_NAMESPACE \
  --atomic \
  -f overrides.yaml

Atualize o restante dos gráficos afetados na seguinte ordem:

helm upgrade datastore apigee-datastore/ \
  --namespace APIGEE_NAMESPACE \
  --atomic \
  -f overrides.yaml

helm upgrade telemetry apigee-telemetry/ \
  --namespace APIGEE_NAMESPACE \
  --atomic \
  -f overrides.yaml

helm upgrade $ORG_NAME apigee-org/ \
  --namespace APIGEE_NAMESPACE \
  --atomic \
  -f overrides.yaml

Atualize o gráfico apigee-env para cada ambiente, substituindo $ENV_RELEASE_NAME e ENV_NAME todas as vezes:

helm upgrade $ENV_RELEASE_NAME apigee-env/ \
  --namespace APIGEE_NAMESPACE \
  --atomic \
  --set env=$ENV_NAME \
  -f overrides.yaml

Consulte a referência da Apigee híbrida Helm para ver uma lista de componentes e os gráficos correspondentes.

Conceder o acesso às contas de serviço do Kubernetes

Liste as contas de serviço do Kubernetes com o seguinte comando:
```
kubectl get sa -n APIGEE_NAMESPACE
```
Observação:os gráficos híbridos da Apigee criaram as contas de serviço do Kubernetes necessárias para cada componente quando você executou os comandos helm upgrade.

Importante:você não vai usar todas as contas de serviço do Kubernetes listadas por esse comando.

Conceda às contas de serviço do Kubernetes acesso para personificar as contas de serviço do IAM associadas, conforme mostrado na tabela a seguir. A tabela mostra os nomes das contas de serviço padrão do IAM da Apigee. Se você estiver usando nomes de contas de serviço personalizadas, use as contas de serviço do IAM correspondentes:

Contas de serviço do Kubernetes	Conta de serviço do IAM
Contas de serviço do Kubernetes no nível da organização
`apigee-connect-agent-ORG_NAME-ORG_HASH_ID`	`apigee-mart`
`apigee-mart-ORG_NAME-ORG_HASH_ID`	`apigee-mart`
`apigee-metrics-apigee-telemetry`	`apigee-metrics`
`apigee-open-telemetry-collector-apigee-telemetry`	`apigee-metrics`
`apigee-udca-ORG_NAME-ORG_HASH_ID`	`apigee-udca`
`apigee-watcher-ORG_NAME-ORG_HASH_ID`	`apigee-watcher`
Contas de serviço do Kubernetes no nível do ambiente
`apigee-runtime-ORG_NAME-ENV_NAME-ENV_HASH_ID`	`apigee-runtime`
`apigee-synchronizer-ORG_NAME-ENV_NAME-ENV_HASH_ID`	`apigee-synchronizer`
Backup e restauração do Cassandra (se ativado)
`apigee-cassandra-backup-sa`	`apigee-cassandra`
`apigee-cassandra-restore-sa`	`apigee-cassandra`

Em que:

ORG_NAME: os primeiros 15 caracteres do nome da sua organização.
ORG_HASH_ID: um ID de hash exclusivo do nome completo da organização.
ENV_NAME: os primeiros 15 caracteres do nome do ambiente.
ENV_HASH_ID: um ID de hash exclusivo dos nomes da organização e do ambiente.

Exemplo:

apigee-connect-agent-myhybridorg-123abcd
apigee-runtime-myhybridorg-prodenv-234bcde

Conceda a cada conta de serviço do Kubernetes acesso para personificar a conta de serviço do IAM apropriada com o seguinte comando:

gcloud iam service-accounts add-iam-policy-binding \
  IAM_SA_NAME@PROJECT_ID.iam.gserviceaccount.com \
    --member="principal://iam.googleapis.com/projects/PROJECT_NUMBER/locations/global/workloadIdentityPools/POOL_ID/subject/MAPPED_SUBJECT" \
    --role=roles/iam.workloadIdentityUser

Em que:

IAM_SA_NAME: o nome da conta de serviço.
PROJECT_ID: o ID do projeto associado à organização da Apigee.
PROJECT_NUMBER: o número do projeto em que você criou o pool de identidade da carga de trabalho.
POOL_ID: o ID do pool de identidade da carga de trabalho.
MAPPED_SUBJECT: a ServiceAccount do Kubernetes da reivindicação no token de ID mapeado para google.subject. Por exemplo, se você mapeou google.subject=assertions.sub e o token do ID contém "sub": "system:serviceaccount:default:my-kubernetes-serviceaccount", MAPPED_SUBJECT é system:serviceaccount:default:my-kubernetes-serviceaccount.

Saiba mais sobre a federação de identidade da carga de trabalho e as práticas recomendadas em Práticas recomendadas para usar a federação de identidade da carga de trabalho.

Como ativar a federação de identidade da carga de trabalho no AKS e no EKS Mantenha tudo organizado com as coleções Salve e categorize o conteúdo com base nas suas preferências.

Visão geral

Configurar a federação de identidade da carga de trabalho

Antes de começar

Configure seu cluster para usar a federação de identidade da carga de trabalho.

Console

Linha de comando

Funções exigidas

AKS

EKS

Outros Kubernetes

Acessível publicamente

Não é acessível ao público

Criar os arquivos de configuração de credenciais

Prod.

Sem produção

Código

Exemplo

Configurar a Apigee híbrida para usar a federação de identidade da carga de trabalho

Prod.

Sem produção

Código

Exemplo

Arquivo de certificação

Secret do K8s

Vault

Conceder o acesso às contas de serviço do Kubernetes

Como ativar a federação de identidade da carga de trabalho no AKS e no EKS
Mantenha tudo organizado com as coleções Salve e categorize o conteúdo com base nas suas preferências.