Ativar a Workload Identity Federation no AKS e no EKS

Este tópico explica como ativar a Workload Identity Federation para instalações híbridas do Apigee nas plataformas AKS e EKS.

Para instalações no GKE, siga as instruções em Ativar a Federação do Workload Identity para o GKE no GKE.

Vista geral

A Workload Identity Federation permite que as aplicações executadas fora do Google Cloud se façam passar por uma conta de serviço da Google Cloud Platform através da utilização de credenciais de um fornecedor de identidade externo.

A utilização da Workload Identity Federation pode ajudar a melhorar a segurança, permitindo que as aplicações usem os mecanismos de autenticação fornecidos pelo ambiente externo, e pode ajudar a substituir as chaves de contas de serviço.

Para uma vista geral, consulte o artigo Práticas recomendadas para usar a Workload Identity Federation.

Configure a Workload Identity Federation

Para usar a Workload Identity Federation com o Apigee hybrid, primeiro configure o cluster e, em seguida, aplique a funcionalidade à instalação do Apigee hybrid.

Antes de começar

Estas instruções pressupõem que já configurou a instalação híbrida do Apigee. As contas de serviço da IAM e as contas de serviço do Kubernetes são criadas durante a instalação inicial. Consulte o artigo O panorama geral para ver uma vista geral da instalação do Apigee hybrid.

Para instalações no AKS, certifique-se de que ativou o emissor do OpenID Connect (OIDC). Tem de ativar esta funcionalidade para que a Workload Identity Federation possa aceder aos metadados do OpenID Connect e ao conjunto de chaves Web JSON (JWKS) para o cluster.

Configure o cluster para usar a Workload Identity Federation.

  1. Verifique se a configuração gcloud atual está definida para o ID do projeto do Google Cloud com o seguinte comando: 
    gcloud config get project

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

    gcloud config set project PROJECT_ID
  2. 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:

    Consola

    Enable the Security Token Service API.

    Roles required to enable APIs

    To enable APIs, you need the Service Usage Admin IAM role (roles/serviceusage.serviceUsageAdmin), which contains the serviceusage.services.enable permission. Learn how to grant roles.

    Enable the API

    Linha de comandos

    Ative a API com o seguinte comando: 

    gcloud services enable sts.googleapis.com --project PROJECT_ID
  3. Crie o Workload Identity Pool e o fornecedor.

    Funções necessárias

    Para receber as autorizações de que precisa para configurar a Workload Identity Federation, peça ao seu administrador para lhe conceder as seguintes funções de IAM no projeto:

    Para mais informações sobre a atribuição de funções, consulte o artigo Faça a gestão do acesso a projetos, pastas e organizações.

    Também pode conseguir as autorizações necessárias através de funções personalizadas ou outras funções predefinidas.

    Em alternativa, a função básica de proprietário da IAM (roles/owner) também inclui autorizações para configurar a federação de identidades. Não deve conceder funções básicas num ambiente de produção, mas pode concedê-las num ambiente de desenvolvimento ou teste.

    Para criar um Workload Identity Pool e um fornecedor, faça o seguinte:

    1. Determine o URL do emissor do seu cluster do AKS:

      AKS

      az aks show -n NAME -g RESOURCE_GROUP --query "oidcIssuerProfile.issuerUrl" -otsv

      Substitua o seguinte:

      • NAME: o nome do cluster.
      • RESOURCE_GROUP: o grupo de recursos do cluster.

      O comando produz o URL do emissor. Vai precisar do URL do emissor num dos seguintes passos.

      Se o comando não devolver um URL do emissor, verifique se ativou a funcionalidade emissor OIDC.

      EKS

      aws eks describe-cluster --name NAME --query "cluster.identity.oidc.issuer" --output text

      Substitua NAME pelo nome do cluster.

      O comando produz o URL do emissor. Precisa do URL do emissor num dos seguintes passos.

      Outro Kubernetes

      Ligue-se ao cluster do Kubernetes e use `kubectl` para determinar o URL do emissor do cluster:

      kubectl get --raw /.well-known/openid-configuration | jq -r .issuer

      Precisa do URL do emissor num dos seguintes passos.

    2. Opcional: se o emissor de OIDC não estiver acessível publicamente, transfira o conjunto de chaves Web JSON (JWKS) do cluster: 
      kubectl get --raw /openid/v1/jwks > cluster-jwks.json

      Para verificar se o seu fornecedor de OIDC está disponível publicamente, deve conseguir aceder ao URL do fornecedor com um comando CURL e receber uma resposta 200.

    3. Crie um novo Workload Identity Pool: 
      gcloud iam workload-identity-pools create POOL_ID \
  --location="global" \
  --description="DESCRIPTION" \
  --display-name="DISPLAY_NAME"

      Substitua o seguinte:

      • POOL_ID: o ID exclusivo do conjunto.
      • DISPLAY_NAME: (Opcional) O nome do conjunto.
      • DESCRIPTION: (Opcional) Uma descrição do conjunto que escolhe. Esta descrição é apresentada quando concede acesso a identidades agrupadas.

      Por 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 fornecedor do Workload Identity Pool. Escolha o comando para criar o fornecedor consoante o emissor de OIDC seja acessível publicamente ou não acessível publicamente:

      Acessível publicamente

      Se o emissor de OIDC for acessível publicamente, crie o fornecedor 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 publicamente

      Se o emissor OIDC não for acessível publicamente, crie o fornecedor 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" \
  --jwks-file="cluster-jwks.json" \
  --attribute-mapping="google.subject=assertion.sub"

      Substitua o seguinte:

      • WORKLOAD_PROVIDER_ID: um ID do fornecedor do Workload Identity Pool exclusivo à sua escolha.
      • POOL_ID: O ID do Workload Identity Pool que criou anteriormente.
      • ISSUER: use o URL do emissor que determinou anteriormente para o URI do emissor .

      attribute-mapping="google.subject=assertion.sub" mapeia o assunto do Kubernetes para o assunto do IAM.

Crie os ficheiros de configuração de credenciais

Para implementar uma carga de trabalho do Kubernetes que possa aceder a Google Cloud recursos, primeiro tem de criar um ficheiro de configuração de credenciais para cada conta de serviço do IAM:

  1. Liste as contas de serviço do IAM (também denominadas "contas de serviço Google") com o seguinte comando: 
    gcloud iam service-accounts list --project PROJECT_ID

    Tem de criar os ficheiros 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

    Se estiver a usar a rentabilização para o Apigee hybrid na versão v1.15.1 e posterior, também tem de criar o ficheiro de configuração de credenciais para a conta de serviço apigee-mint-task-scheduler.

    DISPLAY NAME                 EMAIL                                                              DISABLED
...
apigee-mint-task-scheduler   apigee-mint-task-scheduler@my_project_id.iam.gserviceaccount.com   False
...

    Não prod

    Para ambientes de não produção:

    DISPLAY NAME         EMAIL                                                      DISABLED
apigee-non-prod      apigee-non-prod@my-project.iam.gserviceaccount.com      False
  2. Crie um ficheiro de configuração de credenciais para cada conta de serviço do IAM na lista anterior. Precisa destes ficheiros de configuração de credenciais para configurar o Apigee Hybrid de modo a usar a Workload Identity Federation:

    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/run/service-account/token \
  --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/run/service-account/token \
  --credential-source-type=text \
  --output-file=apigee-cassandra-credential-configuration.json

    Onde:

    • PROJECT_NUMBER: o número do projeto que contém o Workload Identity Pool. Tem de ser o número do projeto e não o ID do projeto.
    • POOL_ID: o ID do Workload Identity Pool
    • WORKLOAD_PROVIDER_ID: o ID do fornecedor do Workload Identity Pool
    • SERVICE_ACCOUNT_EMAIL: endereço de email da conta de serviço, se configurou a sua conta de serviço do Kubernetes para usar a representação da conta de serviço do IAM.

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

    • Onde obter credenciais externas
    • Que Workload Identity Pool e fornecedor usar
    • Que conta de serviço usar como identidade

Configure o Apigee Hybrid para usar a Workload Identity Federation

  1. Copie ou mova cada ficheiro de saída (SERVICE_ACCOUNT_NAME-credential-configuration.json) para os seguintes diretórios de gráficos (ou subdiretórios dos mesmos). Estes foram os ficheiros que criou no passo Crie os ficheiros de configuração de credenciais.

    Prod

    Conta de serviço Diretório do gráfico Helm do Apigee
    apigee-cassandra apigee-datastore/
    apigee-mart apigee-org/
    apigee-metrics apigee-telemetry/
    apigee-mint-task-scheduler
    (Se estiver a usar a rentabilização para o Apigee Hybrid)    		 apigee-org/
    apigee-runtime apigee-env/
    apigee-synchronizer apigee-env/
    apigee-udca apigee-org/
    apigee-env/
    apigee-watcher apigee-org/

    Não prod

    Conta de serviço Gráfico Helm do Apigee
    apigee-non-prod apigee-datastore/
    apigee-telemetry/
    apigee-org/
    apigee-env/
  2. Faça as seguintes alterações globais ao ficheiro 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 fornecedor de Workload Identity. Pode encontrar o valor pesquisando qualquer um dos ficheiros de configuração de credenciais pelo termo audience: . O valor do público-alvo é o mesmo em cada ficheiro de configuração de credenciais.

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

    {
  "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@my-project.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.

  3. Configure as substituições para cada componente através da Workload Identity Federation. Selecione as instruções para ficheiros JSON, segredos do Kubernetes ou Vault, conforme adequado para a sua instalação.

    Ficheiro de certificação

    Substitua o valor de serviceAccountPath pelo ficheiro de origem das credenciais da conta de serviço do IAM correspondente. Este tem de ser o caminho relativo ao 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: apigee-udca-credential-configuration.json

mart:
  serviceAccountPath: apigee-mart-credential-configuration.json

connectAgent:
  serviceAccountPath: apigee-mart-credential-configuration.json

metrics:
  serviceAccountPath: apigee-metrics-credential-configuration.json

mintTaskScheduler: # Required for Monetization for Apigee hybrid (v1.15.1 and later)
  serviceAccountPath: apigee-mint-task-scheduler-credential-configuration.json

udca:
  serviceAccountPath: apigee-udca-credential-configuration.json

watcher:
  serviceAccountPath: apigee-watcher-credential-configuration.json

    Segredo do K8s

    1. Crie um novo segredo do Kubernetes com o ficheiro de origem das credenciais para cada ficheiro de configuração das credenciais. 
      kubectl create secret -n APIGEE_NAMESPACE generic SECRET_NAME --from-file="client_secret.json=CREDENTIAL_CONFIGURATION_FILE"

      Por exemplo:

      kubectl create secret -n apigee generic udca-workload-identity-secret --from-file="client_secret.json=./apigee-udca-credential-configuration.json"
    2. Substitua o valor de serviceAccountRef pelo novo segredo. Por exemplo: 
      udca:
  serviceAccountRef: udca-workload-identity-secret

    Vault

    Atualize a chave da conta de serviço SAKEY para cada conta de serviço no Vault com o ficheiro de origem das 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.
  4. Aplique as alterações a cada componente afetado com o comando helm upgrade:

    Se 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 os restantes tops afetados pela 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 de cada vez: 

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

    Consulte a referência do Helm do Apigee hybrid para ver uma lista de componentes e os respetivos gráficos.

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

  1. Liste as contas de serviço do Kubernetes com o seguinte comando: 
    kubectl get sa -n APIGEE_NAMESPACE
  2. Conceda às contas de serviço do Kubernetes acesso para usar a identidade das contas de serviço do IAM associadas, conforme mostrado na tabela seguinte. A tabela mostra os nomes das contas de serviço da IAM do Apigee predefinidas. Se estiver a usar nomes de contas de serviço personalizados, 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 ao 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-mint-task-scheduler-ORG_NAME-ORG_HASH_ID
    (Se estiver a usar a rentabilização para o Apigee Hybrid)    		 apigee-mint-task-scheduler
    apigee-udca-ORG_NAME-ORG_HASH_ID apigee-udca
    apigee-watcher-ORG_NAME-ORG_HASH_ID apigee-watcher
    Contas de serviço do Kubernetes ao 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
    Cópia de segurança e restauro do Cassandra (se ativado)
    apigee-cassandra-backup-sa apigee-cassandra
    apigee-cassandra-restore-sa apigee-cassandra

    Onde:

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

    Por exemplo:

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

    Conceda a cada conta de serviço do Kubernetes acesso para usar a identidade da conta de serviço do IAM adequada 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

    Onde:

    • IAM_SA_NAME: o nome da conta de serviço.
    • PROJECT_ID: o ID do projeto associado à organização do Apigee.
    • PROJECT_NUMBER: o número do projeto do projeto onde criou o Workload Identity Pool.
    • POOL_ID: o ID do Workload Identity Pool.
    • MAPPED_SUBJECT: a ServiceAccount do Kubernetes da reivindicação no seu token de ID que mapeou para google.subject. Por exemplo, se mapeou google.subject=assertions.sub e o seu token de ID contiver "sub": "system:serviceaccount:default:my-kubernetes-serviceaccount", então MAPPED_SUBJECT é system:serviceaccount:default:my-kubernetes-serviceaccount.

Para mais informações sobre a federação de identidades da carga de trabalho e as práticas recomendadas, consulte o artigo Práticas recomendadas para usar a federação de identidades da carga de trabalho.