Esta página foi traduzida pela API Cloud Translation.

Passo 5: configure a autenticação da conta de serviço

Vista geral

Este passo explica como configurar os métodos de autenticação para as contas de serviço da Google Cloud que criou no passo anterior.

Selecione as instruções para o método de autenticação que quer usar. Consulte os métodos de autenticação de contas de serviço no Apigee hybrid para ver uma vista geral dos diferentes métodos de autenticação.

Segredos do Kubernetes

Contas de serviço

Tem de criar segredos do Kubernetes para as seguintes contas de serviço:

Produção

apigee-cassandra
apigee-logger
apigee-mart
apigee-metrics
apigee-mint-task-scheduler (se estiver a usar a rentabilização para o Apigee Hybrid)
apigee-runtime
apigee-synchronizer
apigee-udca
apigee-watcher

Não prod

apigee-non-prod

Vai fornecer cada um destes segredos durante o passo Crie o ficheiro de substituições.

Este procedimento usa as seguintes variáveis de ambiente opcionais:

$APIGEE_HELM_CHARTS_HOME
$APIGEE_NAMESPACE
$PROJECT_ID

Se não definiu estas variáveis, substitua o valor adequado para cada variável nos exemplos de código.

Crie segredos do Kubernetes

Crie os segredos do Kubernetes para armazenar as chaves da conta de serviço.

O comando kubectl create secret nos seguintes exemplos de código tem a estrutura:

kubectl create secret generic SECRET_NAME \
  --from-file="client_secret.json=PATH_TO_SERVICE_ACCOUNT_KEY" \
  -n $APIGEE_NAMESPACE

Nota: os comandos seguintes pressupõem que transferiu os ficheiros de chaves da conta de serviço para o diretório $APIGEE_HELM_CHARTS_HOME/service-accounts/ no passo 4: crie contas de serviço. Se transferiu as chaves para um diretório diferente, edite os comandos para usar o diretório correto.

Produção

kubectl create secret generic apigee-logger-svc-account \
  --from-file="client_secret.json=$APIGEE_HELM_CHARTS_HOME/service-accounts/$PROJECT_ID-apigee-logger.json" \
  -n $APIGEE_NAMESPACE

kubectl create secret generic apigee-metrics-svc-account \
  --from-file="client_secret.json=$APIGEE_HELM_CHARTS_HOME/service-accounts/$PROJECT_ID-apigee-metrics.json" \
  -n $APIGEE_NAMESPACE

kubectl create secret generic apigee-watcher-svc-account \
  --from-file="client_secret.json=$APIGEE_HELM_CHARTS_HOME/service-accounts/$PROJECT_ID-apigee-watcher.json" \
  -n $APIGEE_NAMESPACE

kubectl create secret generic apigee-udca-svc-account \
  --from-file="client_secret.json=$APIGEE_HELM_CHARTS_HOME/service-accounts/$PROJECT_ID-apigee-udca.json" \
  -n $APIGEE_NAMESPACE
    
kubectl create secret generic apigee-mart-svc-account \
  --from-file="client_secret.json=$APIGEE_HELM_CHARTS_HOME/service-accounts/$PROJECT_ID-apigee-mart.json" \
  -n $APIGEE_NAMESPACE

kubectl create secret generic apigee-synchronizer-svc-account \
  --from-file="client_secret.json=$APIGEE_HELM_CHARTS_HOME/service-accounts/$PROJECT_ID-apigee-synchronizer.json" \
  -n $APIGEE_NAMESPACE

kubectl create secret generic apigee-runtime-svc-account \
  --from-file="client_secret.json=$APIGEE_HELM_CHARTS_HOME/service-accounts/$PROJECT_ID-apigee-runtime.json" \
  -n $APIGEE_NAMESPACE

Se estiver a usar a monetização para o Apigee hybrid, também tem de criar um segredo do Kubernetes para a conta de serviço apigee-mint-task-scheduler:

kubectl create secret generic apigee-mint-task-scheduler-svc-account \
  --from-file="client_secret.json=$APIGEE_HELM_CHARTS_HOME/service-accounts/$PROJECT_ID-apigee-mint-task-scheduler.json" \
  -n APIGEE_NAMESPACE

Não prod

kubectl create secret generic apigee-non-prod-svc-account \
  --from-file="client_secret.json=$APIGEE_HELM_CHARTS_HOME/service-accounts/$PROJECT_ID-apigee-non-prod.json" \
  -n $APIGEE_NAMESPACE

Opcional: pode eliminar os ficheiros JSON da conta de serviço depois de criar os segredos do Kubernetes.

Para mais informações sobre a utilização de segredos do Kubernetes com o Apigee Hybrid, consulte o artigo Armazenar chaves de contas de serviço em segredos do Kubernetes.

Ficheiros JSON

Não são necessários passos adicionais para configurar a autenticação com ficheiros JSON. Prossiga para o Passo 6: crie certificados TLS.

Vault

Configure o armazenamento de segredos da conta de serviço no Vault

Instale o controlador CSI e o fornecedor do Vault

Se ainda não instalou o controlador CSI no cluster através do Helm, siga as instruções em Controlador CSI da Secrets Store: instalação. Para mais informações, consulte o artigo Instalar o fornecedor de CSI do Vault na documentação do Vault.

Consulte as plataformas e versões suportadas do Apigee Hybrid para ver as versões mínimas do controlador CSI suportadas pelo Apigee Hybrid.

Crie segredos, políticas e funções do Vault

Use a IU ou as APIs do Vault para criar segredos e conceder autorizações às contas de serviço do Kubernetes usadas pelo Apigee hybrid para ler esses segredos.

Crie os segredos específicos da organização e do ambiente no seguinte formato:

Chave secreta Dados secretos

Chave secreta	Dados secretos
secret/data/apigee/orgsakeys	{ "cassandraBackup": "*", "cassandraRestore": "", "connectAgent": "", "logger": "", "mart": "", "metrics": "", "mint": "", "udca": "", "watcher": "" } Nota:** `mint` só é necessário se usar a rentabilização para o Apigee Hybrid (v1.15.1 e posterior).
secret/data/apigee/envsakeys-`ENV_NAME`	{ "runtime": "*", "synchronizer": "", "udca": "**". }

secret/data/apigee/orgsakeys

{
    "cassandraBackup": "***",
    "cassandraRestore": "***",
    "connectAgent": "***",
    "logger": "***",
    "mart": "***",
    "metrics": "***",
    "mint": "***",
    "udca": "***",
    "watcher": "***"
}

Nota: mint só é necessário se usar a rentabilização para o Apigee Hybrid (v1.15.1 e posterior).

secret/data/apigee/envsakeys-ENV_NAME

{
    "runtime": "***",
    "synchronizer": "***",
    "udca": "***".
}

Substitua o "***" em cada par pelo conteúdo do ficheiro .json da conta de serviço Google correspondente ao componente do Apigee. O apigee-cassandra-backup e o apigee-cassandra-restore usam a conta de serviço apigee-cassandra. Por exemplo:

{
    "cassandraBackup": "{
        "type": "service_account",
        "project_id": "myhybridorg",
        "private_key_id": "PRIVATE_KEY_ID",
        "private_key": "-----BEGIN PRIVATE KEY-----\nPRIVATE_KEY_TEXT\n-----END PRIVATE KEY-----\n",
        "client_email": "apigee-cassandra@myhybridorg.iam.gserviceaccount.com",
        "client_id": "123456789012345678901",
        "auth_uri": "https://accounts.google.com/o/oauth2/auth",
        "token_uri": "https://oauth2.googleapis.com/token",
        "auth_provider_x509_cert_url": "https://www.googleapis.com/oauth2/v1/certs",
        "client_x509_cert_url": "https://www.googleapis.com/robot/v1/metadata/x509/apigee-cassandra%40myhybridorg.iam.gserviceaccount.com",
        "universe_domain": "googleapis.com"
    }",
    "cassandraRestore":...
...
}

Conceda acesso ao segredo da organização. Crie um ficheiro de texto denominado orgsakeys-auth-policy.txt com o seguinte conteúdo:
```
path "secret/data/apigee/orgsakeys" {
    capabilities = ["read"]
}
```
No Vault, crie uma política que conceda acesso ao segredo da organização:
```
vault policy write apigee-orgsakeys-auth orgsakeys-auth-policy.txt
```
Para cada ambiente, crie um ficheiro de texto denominado envsakeys-ENV_NAME-auth-policy.txt com o seguinte conteúdo:
```
path "secret/data/apigee/envsakeys-ENV_NAME" {
    capabilities = ["read"]
}
```
Repita este passo para cada ambiente.
No Vault, crie uma política que conceda acesso ao segredo do ambiente:
```
vault policy write apigee-envsakeys-ENV_NAME-auth envsakeys-ENV_NAME-auth-policy.txt
```
Repita este passo para cada ambiente.

Crie um script denominado generate-encoded-sas.sh com o seguinte conteúdo:

# generate-encoded-sas.sh

ORG=$APIGEE_ORG            # Apigee organization name
ENVS=$APIGEE_ENV_LIST      # comma separated env names, for example: dev,prod

ORG_SHORT_NAME=$(echo $ORG | head -c 15)
ENCODE=$(echo -n $ORG | shasum -a 256 | head -c 7)
ORG_ENCODE=$(echo "$ORG_SHORT_NAME-$ENCODE")
NAMES=apigee-manager,apigee-cassandra-default,apigee-cassandra-backup-sa,apigee-cassandra-restore-sa,apigee-cassandra-schema-setup-${ORG_ENCODE},apigee-cassandra-schema-val-${ORG_ENCODE},apigee-cassandra-user-setup-${ORG_ENCODE},apigee-mart-${ORG_ENCODE},apigee-mint-task-scheduler-${ORG_ENCODE},apigee-connect-agent-${ORG_ENCODE},apigee-watcher-${ORG_ENCODE},apigee-udca-${ORG_ENCODE},apigee-metrics-apigee-telemetry,apigee-open-telemetry-collector-apigee-telemetry,apigee-logger-apigee-telemetry

for ENV in ${ENVS//,/ }
do
    ENV_SHORT_NAME=$(echo $ENV | head -c 15)
    ENCODE=$(echo -n $ORG:$ENV | shasum -a 256 | head -c 7)
    ENV_ENCODE=$(echo "$ORG_SHORT_NAME-$ENV_SHORT_NAME-$ENCODE")
    NAMES+=,apigee-synchronizer-${ENV_ENCODE},apigee-runtime-${ENV_ENCODE}
done

echo $NAMES

Nota: remova apigee-mint-task-scheduler-${ORG_ENCODE} se não estiver a usar a rentabilização para o Apigee Hybrid.

Execute o script para gerar a lista de nomes de contas de serviço à qual associar a política:

./generate-encoded-sas.sh

O resultado deve ser uma lista de nomes de contas de serviço do Kubernetes separados por vírgulas, semelhante ao seguinte exemplo:

./generate-encoded-sas.sh
apigee-manager,apigee-cassandra-default,apigee-cassandra-backup-sa,
apigee-cassandra-restore-sa,apigee-cassandra-schema-setup-myhybrido
rg-5b044c1,apigee-cassandra-schema-val-myhybridorg-5b044c1,apigee-c
assandra-user-setup-myhybridorg-5b044c1,apigee-mart-myhybridorg-5b0
44c1,apigee-mint-task-scheduler-myhybridorg-5b044c1,apigee-connect-
agent-myhybridorg-5b044c1,apigee-watcher-myhybridorg-5b044c1,apigee
-udca-myhybridorg-5b044c1,apigee-metrics-apigee-telemetry,apigee-op
en-telemetry-collector-apigee-telemetry,apigee-logger-apigee-teleme
try,apigee-synchronizer-myhybridorg-dev-ee52aca,apigee-runtime-myhy
bridorg-dev-ee52aca,apigee-synchronizer-myhybridorg-prod-2d0221c,ap
igee-runtime-myhybridorg-prod-2d0221c

Copie o texto de saída e separe-o em listas, uma lista para os nomes das contas de serviço org e uma lista separada para o nome da conta de serviço env para cada ambiente. As contas de serviço da organização estão primeiro na lista de resultados até apigee-logger-apigee-telemetry.

A lista de nomes de serviços org do exemplo anterior:

apigee-manager,apigee-cassandra-default,apigee-cassandra-backup-sa,
apigee-cassandra-restore-sa,apigee-cassandra-schema-setup-myhybrido
rg-5b044c1,apigee-cassandra-schema-val-myhybridorg-5b044c1,apigee-c
assandra-user-setup-myhybridorg-5b044c1,apigee-mart-myhybridorg-5b0
44c1,apigee-mint-task-scheduler-myhybridorg-5b044c1,apigee-connect-
agent-myhybridorg-5b044c1,apigee-watcher-myhybridorg-5b044c1,apigee
-udca-myhybridorg-5b044c1,apigee-metrics-apigee-telemetry,apigee-op
en-telemetry-collector-apigee-telemetry,apigee-logger-apigee-teleme
try

Os nomes das contas de serviço env têm o padrão apigee-synchronizer-ORG_NAME-ENV_NAME-HASH_TEXT e apigee-runtime-ORG_NAME-ENV_NAME-HASH_TEXT. Separe-os em listas separadas para cada ambiente. Por exemplo, o resultado do exemplo anterior pode ser separado nas duas listas seguintes:

dev ambiente:

apigee-synchronizer-myhybridorg-dev-ee52aca,apigee-runtime-myhybrid
org-dev-ee52aca

prod ambiente:

apigee-synchronizer-myhybridorg-prod-2d0221c,apigee-runtime-myhybri
dorg-prod-2d0221c

Usando a política, crie uma função do Vault que associe as contas de serviço do Apigee específicas da organização:

vault write auth/kubernetes/role/apigee-orgsakeys \
    bound_service_account_names=LIST_OF_ORG_SA_NAMES \
    bound_service_account_namespaces=apigee \
    policies=apigee-orgsakeys-auth \
    ttl=1m

Para cada ambiente, crie uma função do Vault para as respetivas chaves de conta de serviço:

vault write auth/kubernetes/role/apigee-envsakeys-ENV_NAME \
    bound_service_account_names=LIST_OF_ENV_NAME_SA_NAMES \
    bound_service_account_namespaces=apigee \
    policies=apigee-envsakeys-ENV_NAME-auth \ 
    ttl=1m

Repita este passo para cada ambiente.

Crie `SecretProviderClass` objetos

O recurso SecretProviderClass indica ao controlador CSI com que fornecedor comunicar quando pede segredos. As chaves de conta de serviço têm de ser configuradas através deste objeto. A tabela seguinte mostra os nomes de ficheiros (objectNames) esperados pelo Apigee Hybrid:

Conta de serviço	Nomes de ficheiros secretos esperados
Cópia de segurança do Cassandra	`cassandraBackup`
Restauro do Cassandra	`cassandraRestore`
Ligar a um agente	`connectAgent`
Registo	`logger`
MART	`mart`
Métrica	`metrics`
Rentabilização (se usar a rentabilização para o Apigee Hybrid)	`mint`
Tempo de execução	`runtime`
Sincronizador	`synchronizer`
UDCA	`udca`
Observador	`watcher`

Use o seguinte modelo SecretProviderClass para configurar este recurso para os segredos específicos da organização:

apiVersion: secrets-store.csi.x-k8s.io/v1
kind: SecretProviderClass
metadata:
    name: apigee-orgsakeys-spc
spec:
    provider: vault
    parameters:
        roleName: apigee-orgsakeys
        vaultAddress: VAULT_ADDRESS
        # "objectName" is an alias used within the SecretProviderClass to reference
        # that specific secret. This will also be the filename containing the secret.
        # Apigee Hybrid expects these exact values so they must not be changed.
        # "secretPath" is the path in Vault where the secret should be retrieved.
        # "secretKey" is the key within the Vault secret response to extract a value from.
        objects: |
            - objectName: "cassandraBackup"
                secretPath: ""
                secretKey: ""
            - objectName: "cassandraRestore"
                secretPath: ""
                secretKey: ""
            - objectName: "connectAgent"
                secretPath: ""
                secretKey: ""
            - objectName: "logger"
                secretPath: ""
                secretKey: ""
            - objectName: "mart"
                secretPath: ""
                secretKey: ""
            - objectName: "metrics"
                secretPath: ""
                secretKey: ""
            - objectName: "mint"
                secretPath: ""
                secretKey: ""
            - objectName: "udca"
                secretPath: ""
                secretKey: ""
            - objectName: "watcher"
                secretPath: ""
                secretKey: ""

Nota: remova as linhas objectName: "mint" se não estiver a usar a rentabilização para o Apigee Hybrid.

VAULT_ADDRESS é o ponto final onde o servidor do Vault está em execução. Se o Vault estiver a ser executado no mesmo cluster que o Apigee, o formato é geralmente http://vault.$APIGEE_NAMESPACE.svc.cluster.local:VAULT_SERVICE_PORT.

Guarde o modelo num ficheiro com o nome spc-org.yaml.

Aplique o SecretProviderClass específico da organização ao seu espaço de nomes do Apigee:
```
kubectl -n $APIGEE_NAMESPACE apply -f spc-org.yaml
```

Para cada ambiente, use o seguinte modelo SecretProviderClass para configurar este recurso para os segredos específicos do ambiente. Repita este passo para cada ambiente:

apiVersion: secrets-store.csi.x-k8s.io/v1
kind: SecretProviderClass
metadata:
    name: apigee-envsakeys-ENV_NAME-spc
spec:
    provider: vault
    parameters:
        roleName: apigee-envsakeys-ENV_NAME
        vaultAddress: VAULT_ADDRESS
        # "objectName" is an alias used within the SecretProviderClass to reference
        # that specific secret. This will also be the filename containing the secret.
        # Apigee Hybrid expects these exact values so they must not be changed.
        # "secretPath" is the path in Vault where the secret should be retrieved.
        # "secretKey" is the key within the Vault secret response to extract a value from.
        objects: |
            - objectName: "runtime"
                secretPath: ""
                secretKey: ""
            - objectName: "synchronizer"
                secretPath: ""
                secretKey: ""
            - objectName: "udca"
                secretPath: ""
                secretKey: ""

VAULT_ADDRESS é o ponto final onde o servidor do Vault está em execução. Se o Vault estiver a ser executado no mesmo cluster e espaço de nomes que o Apigee, o formato é geralmente http://vault.$APIGEE_NAMESPACE.svc.cluster.local:VAULT_SERVICE_PORT.

Guarde o modelo num ficheiro com o nome spc-env-ENV_NAME.yaml.

Para cada ambiente, aplique o SecretProviderClass específico do ambiente ao seu espaço de nomes do Apigee:
```
kubectl -n $APIGEE_NAMESPACE apply -f spc-env-ENV_NAME.yaml
```
Repita este passo para cada ambiente.
Opcional: pode eliminar os ficheiros JSON da conta de serviço depois de criar os objetos SecretProviderClass.

WIF para o GKE

Prepare-se para configurar a federação de identidades de cargas de trabalho para o GKE

Verifique se a Workload Identity Federation para o GKE está ativada no ficheiro de substituições. Deve ser ativado no ficheiro de substituições nas seguintes propriedades.
- namespace é obrigatório. Por exemplo:
```
instanceID: "hybrid-instance-1"
namespace: "apigee"
```
- Se estiver a usar uma única conta de serviço (não de produção) para todos os componentes, especifique-a com: gcp.workloadIdentity.gsa. Por exemplo:
```
  gcp:
    workloadIdentity:
      enabled: true
      gsa: "apigee-non-prod@my-hybrid-project.iam.gserviceaccount.com"
  
```
- Se estiver a usar uma conta de serviço separada para cada componente (instalações de produção), especifique a conta de serviço com a propriedade gsa do componente. Por exemplo:
```
  logger:
    gsa: "apigee-logger@my-hybrid-project.iam.gserviceaccount.com"
  
```
Veja: gcp.workloadIdentity.enabled.
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
```

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

gcloud config set project $PROJECT_ID

Verifique se a Workload Identity Federation para o GKE está ativada para o seu cluster do GKE. Quando criou o cluster no Passo 1: crie um cluster, o passo 6 foi ativar a Workload Identity Federation para o GKE. Confirme se está ativada com o seguinte comando:

Clusters regionais

gcloud container clusters describe $CLUSTER_NAME \
  --region $CLUSTER_LOCATION \
  --project $PROJECT_ID \
  --flatten 'workloadIdentityConfig'

Clusters zonais

gcloud container clusters describe $CLUSTER_NAME \
  --zone $CLUSTER_LOCATION \
  --project $PROJECT_ID \
  --flatten 'workloadIdentityConfig'

O resultado deve ter o seguinte aspeto:

  ---
  workloadPool: $PROJECT_ID.svc.id.goog

Se vir null nos resultados, execute o seguinte comando para ativar a Workload Identity Federation para o GKE para o seu cluster:

Clusters regionais

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

Clusters zonais

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

Ative a Workload Identity Federation para o GKE para cada conjunto de nós com os seguintes comandos. Esta operação pode demorar até 30 minutos para cada nó:
Clusters regionais
```
gcloud container node-pools update NODE_POOL_NAME \
  --cluster=$CLUSTER_NAME \
  --region $CLUSTER_LOCATION \
  --project $PROJECT_ID \
  --workload-metadata=GKE_METADATA
```
Clusters zonais
```
gcloud container node-pools update NODE_POOL_NAME \
  --cluster=$CLUSTER_NAME \
  --zone $CLUSTER_LOCATION \
  --project $PROJECT_ID \
  --workload-metadata=GKE_METADATA
```
Onde NODE_POOL_NAME é o nome de cada conjunto de nós. Na maioria das instalações do Apigee hybrid, os dois conjuntos de nós predefinidos têm os nomes apigee-data e apigee-runtime.

Verifique se a Workload Identity Federation para o GKE está ativada nos seus node pools com os seguintes comandos:

Clusters regionais

gcloud container node-pools describe apigee-data \
  --cluster $CLUSTER_NAME \
  --region $CLUSTER_LOCATION \
  --project $PROJECT_ID \
  --flatten "config:"

gcloud container node-pools describe apigee-runtime \
  --cluster $CLUSTER_NAME \
  --region $CLUSTER_LOCATION \
  --project $PROJECT_ID \
  --flatten "config:"

Clusters zonais

gcloud container node-pools describe apigee-data \
  --cluster $CLUSTER_NAME \
  --zone $CLUSTER_LOCATION \
  --project $PROJECT_ID \
  --flatten "config:"

gcloud container node-pools describe apigee-runtime \
  --cluster $CLUSTER_NAME \
  --zone $CLUSTER_LOCATION \
  --project $PROJECT_ID \
  --flatten "config:"

O resultado deve ter um aspeto semelhante ao seguinte:

---
diskSizeGb: 100
diskType: pd-standard
...
workloadMetadataConfig:
  mode: GKE_METADATA

Dica: pode limitar o resultado ao campo workloadMetadataConfig ao encaminhar o resultado através de grep com a flag -A 1 para incluir a seguinte linha:

gcloud container node-pools describe apigee-data \
  --cluster $CLUSTER_NAME \
  --region $CLUSTER_LOCATION \
  --project $PROJECT_ID \
  --flatten "config:" | grep "workloadMetadataConfig" -A 1

WIF noutras plataformas

Se usar a Workload Identity Federation em plataformas que não sejam o GKE, pode usar os seguintes métodos para configurar a autenticação de SA:

Segredos do Kubernetes
Ficheiros JSON da conta de serviço
Vault

Nas instruções seguintes, escolha o separador do método de autenticação que está a usar.

Este procedimento usa as duas variáveis de ambiente seguintes definidas no Passo 2: transfira os gráficos do Helm do Apigee. Estas variáveis são opcionais. Se não os definiu, substitua o caminho do diretório adequado para cada variável nos exemplos de código.

$APIGEE_HELM_CHARTS_HOME: o diretório onde transferiu os gráficos Helm do Apigee, definidos no Passo 2: transfira os gráficos Helm do Apigee.
$PROJECT_ID: o ID do projeto do Google Cloud, definido na Parte 1: configuração do projeto e da organização – Passo 1: ativar APIs.

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.

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

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

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:
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
```
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:
- Administrador do Workload Identity Pool (roles/iam.workloadIdentityPoolAdmin)
- Administrador da conta de serviço (roles/iam.serviceAccountAdmin)
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 CLUSTER_NAME -g RESOURCE_GROUP --query "oidcIssuerProfile.issuerUrl" -otsv
  Substitua o seguinte:
  - CLUSTER_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 CLUSTER_NAME --query "cluster.identity.oidc.issuer" --output text
  Substitua CLUSTER_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:
  Nota: este passo requer acesso kubectl ao seu cluster.
  
  Sugestão: quando usar o ficheiro JWKS, tem de carregar um novo ficheiro JWKS sempre que rodar as chaves de assinatura para o 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"
  Nota: se rodar as chaves, tem de carregar o novo JWKS com cada rotação de chaves.
  O comando não valida o JWKS do cluster. Se o JWKS estiver formatado incorretamente ou tiver expirado, as tentativas de autenticação subsequentes podem falhar com uma mensagem de erro Error connecting to the given credential's issuer.
  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:

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
```
Nota: muito provavelmente, já criou as contas de serviço do IAM (também denominadas "contas de serviço Google") durante a instalação inicial do Apigee hybrid com a ferramenta create-service-account. Consulte o artigo Acerca das contas de serviço para ver uma lista das contas de serviço do IAM necessárias para o Apigee hybrid. Consulte o Passo 4: crie contas de serviço do procedimento do guia de instalação para criar as contas de serviço do IAM.

Tem de criar os ficheiros de configuração de credenciais para as seguintes contas de serviço do IAM:
Produção

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_id.iam.gserviceaccount.com      False
```
Sugestão: se tiver nomes personalizados para as suas contas de serviço que não correspondam facilmente aos nomes dos componentes do Apigee, pode determinar a função de cada conta de serviço verificando as funções atribuídas à mesma e comparando-as com as funções recomendadas no artigo Acerca das contas de serviço.
Use o seguinte comando para verificar as funções atribuídas a uma conta de serviço:
```
gcloud projects get-iam-policy $PROJECT_ID  \
    --flatten="bindings[].members" \
    --format='table(bindings.role)' \
    --filter="SERVICE_ACCOUNT_NAME"
```
Tenha em atenção a conta de serviço personalizada que corresponde a cada SA do IAM indicado na lista anterior.

Crie um ficheiro de configuração de credenciais para cada conta de serviço do IAM na lista anterior.

WIF: secrets

Esta abordagem usa configurações de credenciais armazenadas em segredos do Kubernetes. Quando cria o ficheiro de substituições no passo 7: crie as substituições, indica o nome do segredo para cada conta de serviço com a propriedade serviceAccountRef ou envs.serviceAccountRefs.

Crie os ficheiros de configuração de credenciais

Produção

Tem de criar os ficheiros de configuração de credenciais para as seguintes contas de serviço:

apigee-cassandra
apigee-mart
apigee-metrics
apigee-mint-task-scheduler Se estiver a usar a rentabilização para o Apigee Hybrid.
apigee-runtime
apigee-synchronizer
apigee-udca

Crie um diretório para os ficheiros de configuração das credenciais. O diretório pode ter qualquer nome. Para este procedimento, o diretório tem o nome credential-configurations:
```
mkdir $APIGEE_HELM_CHARTS_HOME/credential-configurations
```

Crie o ficheiro de configuração de credenciais para apigee-cassandra:

gcloud iam workload-identity-pools create-cred-config \
  projects/PROJECT_NUMBER/locations/global/workloadIdentityPools/POOL_ID/providers/WORKLOAD_PROVIDER_ID \
  --service-account=apigee-cassandra@$PROJECT_ID.iam.gserviceaccount.com \
  --credential-source-file=/var/run/service-account/token \
  --credential-source-type=text \
  --output-file=$APIGEE_HELM_CHARTS_HOME/credential-configurations/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

Importante: credential-source-type tem de estar definido como text.

Crie o ficheiro de configuração de credenciais para apigee-mart:

gcloud iam workload-identity-pools create-cred-config \
  projects/PROJECT_NUMBER/locations/global/workloadIdentityPools/POOL_ID/providers/WORKLOAD_PROVIDER_ID \
  --service-account=apigee-mart@$PROJECT_ID.iam.gserviceaccount.com \
  --credential-source-file=/var/run/service-account/token \
  --credential-source-type=text \
  --output-file=$APIGEE_HELM_CHARTS_HOME/credential-configurations/apigee-mart-credential-configuration.json

Crie o ficheiro de configuração de credenciais para apigee-metrics:

gcloud iam workload-identity-pools create-cred-config \
  projects/PROJECT_NUMBER/locations/global/workloadIdentityPools/POOL_ID/providers/WORKLOAD_PROVIDER_ID \
  --service-account=apigee-metrics@$PROJECT_ID.iam.gserviceaccount.com \
  --credential-source-file=/var/run/service-account/token \
  --credential-source-type=text \
  --output-file=$APIGEE_HELM_CHARTS_HOME/credential-configurations/apigee-metrics-credential-configuration.json

Crie o ficheiro de configuração de credenciais para apigee-runtime:

gcloud iam workload-identity-pools create-cred-config \
  projects/PROJECT_NUMBER/locations/global/workloadIdentityPools/POOL_ID/providers/WORKLOAD_PROVIDER_ID \
  --service-account=apigee-runtime@$PROJECT_ID.iam.gserviceaccount.com \
  --credential-source-file=/var/run/service-account/token \
  --credential-source-type=text \
  --output-file=$APIGEE_HELM_CHARTS_HOME/credential-configurations/apigee-runtime-credential-configuration.json

Crie o ficheiro de configuração de credenciais para apigee-synchronizer:

gcloud iam workload-identity-pools create-cred-config \
  projects/PROJECT_NUMBER/locations/global/workloadIdentityPools/POOL_ID/providers/WORKLOAD_PROVIDER_ID \
  --service-account=apigee-synchronizer@$PROJECT_ID.iam.gserviceaccount.com \
  --credential-source-file=/var/run/service-account/token \
  --credential-source-type=text \
  --output-file=$APIGEE_HELM_CHARTS_HOME/credential-configurations/apigee-synchronizer-credential-configuration.json

Crie o ficheiro de configuração de credenciais para apigee-udca:

gcloud iam workload-identity-pools create-cred-config \
  projects/PROJECT_NUMBER/locations/global/workloadIdentityPools/POOL_ID/providers/WORKLOAD_PROVIDER_ID \
  --service-account=apigee-udca@$PROJECT_ID.iam.gserviceaccount.com \
  --credential-source-file=/var/run/service-account/token \
  --credential-source-type=text \
  --output-file=$APIGEE_HELM_CHARTS_HOME/credential-configurations/apigee-udca-credential-configuration.json

Crie o ficheiro de configuração de credenciais para apigee-watcher:

gcloud iam workload-identity-pools create-cred-config \
  projects/PROJECT_NUMBER/locations/global/workloadIdentityPools/POOL_ID/providers/WORKLOAD_PROVIDER_ID \
  --service-account=apigee-watcher@$PROJECT_ID.iam.gserviceaccount.com \
  --credential-source-file=/var/run/service-account/token \
  --credential-source-type=text \
  --output-file=$APIGEE_HELM_CHARTS_HOME/credential-configurations/apigee-watcher-credential-configuration.json

Se estiver a usar a rentabilização para o Apigee Hybrid, também tem de criar o ficheiro de configuração de credenciais para apigee-mint-task-scheduler:

gcloud iam workload-identity-pools create-cred-config \
  projects/PROJECT_NUMBER/locations/global/workloadIdentityPools/POOL_ID/providers/WORKLOAD_PROVIDER_ID \
  --service-account=apigee-mint-task-scheduler@$PROJECT_ID.iam.gserviceaccount.com \
  --credential-source-file=/var/run/service-account/token \
  --credential-source-type=text \
  --output-file=$APIGEE_HELM_CHARTS_HOME/credential-configurations/apigee-mint-task-scheduler-credential-configuration.json

Nota: não crie um ficheiro de configuração de credenciais para a conta de serviço apigee-logger.

Não prod

Crie um diretório para o ficheiro de configuração das credenciais. O diretório pode ter qualquer nome. Para este procedimento, o diretório tem o nome credential-configurations:
```
mkdir $APIGEE_HELM_CHARTS_HOME/credential-configurations
```
Crie o ficheiro de configuração de credenciais para a conta de serviço apigee-non-prod no diretório credential-configurations com o seguinte comando:
```
gcloud iam workload-identity-pools create-cred-config \
projects/PROJECT_NUMBER/locations/global/workloadIdentityPools/POOL_ID/providers/WORKLOAD_PROVIDER_ID \
  --service-account=apigee-non-prod@$PROJECT_ID.iam.gserviceaccount.com \
  --credential-source-file=/var/run/service-account/token \
  --credential-source-type=text \
  --output-file=$APIGEE_HELM_CHARTS_HOME/credential-configurations/apigee-non-prod-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
Importante: credential-source-type tem de estar definido como text.

Crie os segredos do Kubernetes

Crie os segredos do Kubernetes para armazenar os ficheiros de configuração das credenciais de cada conta de serviço.

O comando kubectl create secret nos seguintes exemplos de código tem a estrutura:

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

Produção

Crie o ficheiro secreto para apigee-cassandra:

kubectl create secret generic apigee-cassandra-svc-account \
  --from-file="client_secret.json=$APIGEE_HELM_CHARTS_HOME/credential-configurations/$PROJECT_ID-apigee-cassandra.json" \
  -n APIGEE_NAMESPACE

Crie o ficheiro secreto para apigee-mart:

kubectl create secret generic apigee-mart-svc-account \
  --from-file="client_secret.json=$APIGEE_HELM_CHARTS_HOME/credential-configurations/$PROJECT_ID-apigee-mart.json" \
  -n APIGEE_NAMESPACE

Crie o ficheiro secreto para apigee-metrics:

kubectl create secret generic apigee-metrics-svc-account \
  --from-file="client_secret.json=$APIGEE_HELM_CHARTS_HOME/credential-configurations/$PROJECT_ID-apigee-metrics.json" \
  -n APIGEE_NAMESPACE

Crie o ficheiro secreto para apigee-runtime:

kubectl create secret generic apigee-runtime-svc-account \
  --from-file="client_secret.json=$APIGEE_HELM_CHARTS_HOME/credential-configurations/$PROJECT_ID-apigee-runtime.json" \
  -n APIGEE_NAMESPACE

Crie o ficheiro secreto para apigee-synchronizer:

kubectl create secret generic apigee-synchronizer-svc-account \
  --from-file="client_secret.json=$APIGEE_HELM_CHARTS_HOME/credential-configurations/$PROJECT_ID-apigee-synchronizer.json" \
  -n APIGEE_NAMESPACE

Crie o ficheiro secreto para apigee-udca:

kubectl create secret generic apigee-udca-svc-account \
  --from-file="client_secret.json=$APIGEE_HELM_CHARTS_HOME/credential-configurations/$PROJECT_ID-apigee-udca.json" \
  -n APIGEE_NAMESPACE

Crie o ficheiro secreto para apigee-watcher:

kubectl create secret generic apigee-watcher-svc-account \
  --from-file="client_secret.json=$APIGEE_HELM_CHARTS_HOME/credential-configurations/$PROJECT_ID-apigee-watcher.json" \
  -n APIGEE_NAMESPACE

Se estiver a usar a rentabilização para o Apigee Hybrid, crie o ficheiro secreto para apigee-mint-task-scheduler:

kubectl create secret generic apigee-mint-task-scheduler-svc-account \
  --from-file="client_secret.json=$APIGEE_HELM_CHARTS_HOME/credential-configurations/$PROJECT_ID-apigee-mint-task-scheduler.json" \
  -n APIGEE_NAMESPACE

Crie o ficheiro secreto para apigee-non-prod:

Não prod

kubectl create secret generic apigee-non-prod-svc-account \
        --from-file="client_secret.json=$APIGEE_HELM_CHARTS_HOME/credential-configurations/$PROJECT_ID-apigee-non-prod.json" \
        -n APIGEE_NAMESPACE

WIF: ficheiros

Esta abordagem usa os ficheiros de configuração de credenciais em vez dos ficheiros de chave da conta de serviço Google. Quando cria o ficheiro de substituições no Passo 7: crie as substituições, indica o caminho para o ficheiro de configuração de credenciais de cada propriedade serviceAccountPath ou envs.serviceAccountPaths.

Produção

Tem de criar os ficheiros de configuração das credenciais nos diretórios dos gráficos correspondentes:

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/`

Crie os ficheiros de configuração das credenciais com os seguintes comandos:

apigee-cassandra:

gcloud iam workload-identity-pools create-cred-config \
  projects/PROJECT_NUMBER/locations/global/workloadIdentityPools/POOL_ID/providers/WORKLOAD_PROVIDER_ID \
  --service-account=apigee-cassandra@$PROJECT_ID.iam.gserviceaccount.com \
  --credential-source-file=/var/run/service-account/token \
  --credential-source-type=text \
  --output-file=$APIGEE_HELM_CHARTS_HOME/apigee-datastore/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

Importante: credential-source-type tem de estar definido como text.

apigee-mart:

gcloud iam workload-identity-pools create-cred-config \
  projects/PROJECT_NUMBER/locations/global/workloadIdentityPools/POOL_ID/providers/WORKLOAD_PROVIDER_ID \
  --service-account=apigee-mart@$PROJECT_ID.iam.gserviceaccount.com \
  --credential-source-file=/var/run/service-account/token \
  --credential-source-type=text \
  --output-file=$APIGEE_HELM_CHARTS_HOME/apigee-org/apigee-mart-credential-configuration.json

apigee-metrics:

gcloud iam workload-identity-pools create-cred-config \
  projects/PROJECT_NUMBER/locations/global/workloadIdentityPools/POOL_ID/providers/WORKLOAD_PROVIDER_ID \
  --service-account=apigee-metrics@$PROJECT_ID.iam.gserviceaccount.com \
  --credential-source-file=/var/run/service-account/token \
  --credential-source-type=text \
  --output-file=$APIGEE_HELM_CHARTS_HOME/apigee-telemetry/apigee-metrics-credential-configuration.json

apigee-runtime:

gcloud iam workload-identity-pools create-cred-config \
  projects/PROJECT_NUMBER/locations/global/workloadIdentityPools/POOL_ID/providers/WORKLOAD_PROVIDER_ID \
  --service-account=apigee-runtime@$PROJECT_ID.iam.gserviceaccount.com \
  --credential-source-file=/var/run/service-account/token \
  --credential-source-type=text \
  --output-file=$APIGEE_HELM_CHARTS_HOME/apigee-env/apigee-runtime-credential-configuration.json

apigee-synchronizer:

gcloud iam workload-identity-pools create-cred-config \
  projects/PROJECT_NUMBER/locations/global/workloadIdentityPools/POOL_ID/providers/WORKLOAD_PROVIDER_ID \
  --service-account=apigee-synchronizer@$PROJECT_ID.iam.gserviceaccount.com \
  --credential-source-file=/var/run/service-account/token \
  --credential-source-type=text \
  --output-file=$APIGEE_HELM_CHARTS_HOME/apigee-env/apigee-synchronizer-credential-configuration.json

apigee-udca:

A conta de serviço apigee-udca é usada pelos gráficos apigee-org e apigee-env.

Crie o ficheiro de configuração de credenciais no diretório apigee-org do gráfico.

gcloud iam workload-identity-pools create-cred-config \
  projects/PROJECT_NUMBER/locations/global/workloadIdentityPools/POOL_ID/providers/WORKLOAD_PROVIDER_ID \
  --service-account=apigee-udca@$PROJECT_ID.iam.gserviceaccount.com \
  --credential-source-file=/var/run/service-account/token \
  --credential-source-type=text \
  --output-file=$APIGEE_HELM_CHARTS_HOME/apigee-org/apigee-udca-credential-configuration.json

Copie o ficheiro de configuração de credenciais para o diretório do gráfico apigee-env.

cp $APIGEE_HELM_CHARTS_HOME/apigee-org/apigee-udca-credential-configuration.json \
  $APIGEE_HELM_CHARTS_HOME/apigee-env/apigee-udca-credential-configuration.json

apigee-watcher:

gcloud iam workload-identity-pools create-cred-config \
  projects/PROJECT_NUMBER/locations/global/workloadIdentityPools/POOL_ID/providers/WORKLOAD_PROVIDER_ID \
  --service-account=apigee-watcher@$PROJECT_ID.iam.gserviceaccount.com \
  --credential-source-file=/var/run/service-account/token \
  --credential-source-type=text \
  --output-file=$APIGEE_HELM_CHARTS_HOME/apigee-org/apigee-watcher-credential-configuration.json

Se estiver a usar a href="monetization-for-hybrid">Rentabilização para o Apigee hybrid, também tem de criar o ficheiro de configuração de credenciais para apigee-mint-task-scheduler:

gcloud iam workload-identity-pools create-cred-config \
  projects/PROJECT_NUMBER/locations/global/workloadIdentityPools/POOL_ID/providers/WORKLOAD_PROVIDER_ID \
  --service-account=apigee-mint-task-scheduler@$PROJECT_ID.iam.gserviceaccount.com \
  --credential-source-file=/var/run/service-account/token \
  --credential-source-type=text \
  --output-file=$APIGEE_HELM_CHARTS_HOME/apigee-org/apigee-mint-task-scheduler-credential-configuration.json

Nota: não crie um ficheiro de configuração de credenciais para a conta de serviço apigee-logger.

Não prod

Tem de criar o ficheiro de configuração de credenciais e copiá-lo para os diretórios de gráficos correspondentes:

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

Crie o ficheiro de configuração de credenciais no diretório do gráfico apigee-datastore com o seguinte comando:

gcloud iam workload-identity-pools create-cred-config \
projects/PROJECT_NUMBER/locations/global/workloadIdentityPools/POOL_ID/providers/WORKLOAD_PROVIDER_ID \
--service-account=apigee-non-prod@$PROJECT_ID.iam.gserviceaccount.com \
--credential-source-file=/var/run/service-account/token \
--credential-source-type=text \
--output-file=$APIGEE_HELM_CHARTS_HOME/apigee-datastore/apigee-non-prod-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

Importante: credential-source-type tem de estar definido como text.

Copie o ficheiro de configuração de credenciais para o diretório do gráfico apigee-env, apigee-org/ e apigee-telemetry/.

cp $APIGEE_HELM_CHARTS_HOME/apigee-datastore/apigee-non-prod-credential-configuration.json \
  $APIGEE_HELM_CHARTS_HOME/apigee-env/apigee-non-prod-credential-configuration.json
cp $APIGEE_HELM_CHARTS_HOME/apigee-datastore/apigee-non-prod-credential-configuration.json \
  $APIGEE_HELM_CHARTS_HOME/apigee-org/apigee-non-prod-credential-configuration.json
cp $APIGEE_HELM_CHARTS_HOME/apigee-datastore/apigee-non-prod-credential-configuration.json \
  $APIGEE_HELM_CHARTS_HOME/apigee-telemetry/apigee-non-prod-credential-configuration.json

WIF: Vault

Esta abordagem usa configurações de credenciais armazenadas num gestor de segredos externo, o Hashicorp Vault. Quando cria o ficheiro de substituições no Passo 7: crie as substituições, fornece segredos do cofre ao nível da organização e do ambiente com as propriedades serviceAccountSecretProviderClass ou envs.serviceAccountSecretProviderClass.

Crie os ficheiros de configuração de credenciais

Produção

Tem de criar os ficheiros de configuração de credenciais para as seguintes contas de serviço:

apigee-cassandra
apigee-mart
apigee-metrics
apigee-mint-task-scheduler (Se estiver a usar a rentabilização para o Apigee Hybrid)
apigee-runtime
apigee-synchronizer
apigee-udca

Crie um diretório para os ficheiros de configuração das credenciais. O diretório pode ter qualquer nome. Para este procedimento, o diretório tem o nome credential-configurations:
```
mkdir $APIGEE_HELM_CHARTS_HOME/credential-configurations
```

Crie o ficheiro de configuração de credenciais para apigee-cassandra:

gcloud iam workload-identity-pools create-cred-config \
  projects/PROJECT_NUMBER/locations/global/workloadIdentityPools/POOL_ID/providers/WORKLOAD_PROVIDER_ID \
  --service-account=apigee-cassandra@$PROJECT_ID.iam.gserviceaccount.com \
  --credential-source-file=/var/run/service-account/token \
  --credential-source-type=text \
  --output-file=$APIGEE_HELM_CHARTS_HOME/credential-configurations/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

Importante: credential-source-type tem de estar definido como text.

Crie o ficheiro de configuração de credenciais para apigee-mart:

gcloud iam workload-identity-pools create-cred-config \
  projects/PROJECT_NUMBER/locations/global/workloadIdentityPools/POOL_ID/providers/WORKLOAD_PROVIDER_ID \
  --service-account=apigee-mart@$PROJECT_ID.iam.gserviceaccount.com \
  --credential-source-file=/var/run/service-account/token \
  --credential-source-type=text \
  --output-file=$APIGEE_HELM_CHARTS_HOME/credential-configurations/apigee-mart-credential-configuration.json

Crie o ficheiro de configuração de credenciais para apigee-metrics:

gcloud iam workload-identity-pools create-cred-config \
  projects/PROJECT_NUMBER/locations/global/workloadIdentityPools/POOL_ID/providers/WORKLOAD_PROVIDER_ID \
  --service-account=apigee-metrics@$PROJECT_ID.iam.gserviceaccount.com \
  --credential-source-file=run/service-account/token \
  --credential-source-type=text \
  --output-file=$APIGEE_HELM_CHARTS_HOME/credential-configurations/apigee-metrics-credential-configuration.json

Crie o ficheiro de configuração de credenciais para apigee-runtime:

gcloud iam workload-identity-pools create-cred-config \
  projects/PROJECT_NUMBER/locations/global/workloadIdentityPools/POOL_ID/providers/WORKLOAD_PROVIDER_ID \
  --service-account=apigee-runtime@$PROJECT_ID.iam.gserviceaccount.com \
  --credential-source-file=/var/run/service-account/token \
  --credential-source-type=text \
  --output-file=$APIGEE_HELM_CHARTS_HOME/credential-configurations/apigee-runtime-credential-configuration.json

Crie o ficheiro de configuração de credenciais para apigee-synchronizer:

gcloud iam workload-identity-pools create-cred-config \
  projects/PROJECT_NUMBER/locations/global/workloadIdentityPools/POOL_ID/providers/WORKLOAD_PROVIDER_ID \
  --service-account=apigee-synchronizer@$PROJECT_ID.iam.gserviceaccount.com \
  --credential-source-file=/var/run/service-account/token \
  --credential-source-type=text \
  --output-file=$APIGEE_HELM_CHARTS_HOME/credential-configurations/apigee-synchronizer-credential-configuration.json

Crie o ficheiro de configuração de credenciais para apigee-udca:

gcloud iam workload-identity-pools create-cred-config \
  projects/PROJECT_NUMBER/locations/global/workloadIdentityPools/POOL_ID/providers/WORKLOAD_PROVIDER_ID \
  --service-account=apigee-udca@$PROJECT_ID.iam.gserviceaccount.com \
  --credential-source-file=/var/run/service-account/token \
  --credential-source-type=text \
  --output-file=$APIGEE_HELM_CHARTS_HOME/credential-configurations/apigee-udca-credential-configuration.json

Crie o ficheiro de configuração de credenciais para apigee-watcher:

gcloud iam workload-identity-pools create-cred-config \
  projects/PROJECT_NUMBER/locations/global/workloadIdentityPools/POOL_ID/providers/WORKLOAD_PROVIDER_ID \
  --service-account=apigee-watcher@$PROJECT_ID.iam.gserviceaccount.com \
  --credential-source-file=/var/run/service-account/token \
  --credential-source-type=text \
  --output-file=$APIGEE_HELM_CHARTS_HOME/credential-configurations/apigee-watcher-credential-configuration.json

Se estiver a usar a rentabilização para o Apigee Hybrid, também tem de criar o ficheiro de configuração de credenciais para apigee-mint-task-scheduler:

gcloud iam workload-identity-pools create-cred-config \
  projects/PROJECT_NUMBER/locations/global/workloadIdentityPools/POOL_ID/providers/WORKLOAD_PROVIDER_ID \
  --service-account=apigee-mint-task-scheduler@$PROJECT_ID.iam.gserviceaccount.com \
  --credential-source-file=/var/run/service-account/token \
  --credential-source-type=text \
  --output-file=$APIGEE_HELM_CHARTS_HOME/credential-configurations/apigee-mint-task-scheduler-credential-configuration.json

Nota: não crie um ficheiro de configuração de credenciais para a conta de serviço apigee-logger.

Não prod

Crie um diretório para o ficheiro de configuração das credenciais. O diretório pode ter qualquer nome. Para este procedimento, o diretório tem o nome credential-configurations:
```
mkdir $APIGEE_HELM_CHARTS_HOME/credential-configurations
```
Crie o ficheiro de configuração de credenciais para a conta de serviço apigee-non-prod no diretório credential-configurations com o seguinte comando:
```
gcloud iam workload-identity-pools create-cred-config \
projects/PROJECT_NUMBER/locations/global/workloadIdentityPools/POOL_ID/providers/WORKLOAD_PROVIDER_ID \
  --service-account=apigee-non-prod@$PROJECT_ID.iam.gserviceaccount.com \
  --credential-source-file=/var/run/service-account/token \
  --credential-source-type=text \
  --output-file=$APIGEE_HELM_CHARTS_HOME/credential-configurations/apigee-non-prod-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.
  Sugestão: pode encontrar o número do projeto com o seguinte comando:
```
gcloud projects describe $PROJECT_ID --format="value(projectNumber)"
```
  "
- POOL_ID: o ID do Workload Identity Pool
- WORKLOAD_PROVIDER_ID: o ID do fornecedor do Workload Identity Pool
Importante: credential-source-type tem de estar definido como text.

Instale o controlador CSI e o fornecedor do Vault

Consulte as plataformas e versões suportadas do Apigee Hybrid para ver as versões mínimas do controlador CSI suportadas pelo Apigee Hybrid.

Crie segredos, políticas e funções do Vault

Use a IU ou as APIs do Vault para criar segredos e conceder autorizações às contas de serviço do Kubernetes usadas pelo Apigee hybrid para ler esses segredos.

Crie os segredos específicos da organização e do ambiente no seguinte formato:

Chave secreta Dados secretos

Chave secreta	Dados secretos
secret/data/apigee/orgsakeys	{ "cassandraBackup": "*", "cassandraRestore": "", "connectAgent": "", "logger": "", "mart": "", "metrics": "", "mint": "", "udca": "", "watcher": "" } Nota:** `mint` só é necessário se usar a rentabilização para o Apigee Hybrid (v1.15.1 e posterior).
secret/data/apigee/envsakeys-`ENV_NAME`	{ "runtime": "*", "synchronizer": "", "udca": "**". }

secret/data/apigee/orgsakeys

{
  "cassandraBackup": "***",
  "cassandraRestore": "***",
  "connectAgent": "***",
  "logger": "***",
  "mart": "***",
  "metrics": "***",
  "mint": "***",
  "udca": "***",
  "watcher": "***"
}

Nota: mint só é necessário se usar a rentabilização para o Apigee Hybrid (v1.15.1 e posterior).

secret/data/apigee/envsakeys-ENV_NAME

{
  "runtime": "***",
  "synchronizer": "***",
  "udca": "***".
    }

Produção

Substitua o "***" em cada par pelo conteúdo do ficheiro de configuração de credenciais da conta de serviço Google correspondente ao componente do Apigee. O apigee-cassandra-backup e o apigee-cassandra-restore usam a conta de serviço apigee-cassandra. Por exemplo:

{
  "cassandraBackup": "{
    "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-cassandra@my-project.iam.gserviceaccount.com:generateAccessToken",
    "credential_source": {
      "file": "/var/run/service-account/token",
      "format": {
        "type": "text"
      }
    }
  }",
  "cassandraRestore":...
...
}

Não prod

Substitua o "***" em cada par pelo conteúdo do ficheiro de configuração de credenciais para a conta de serviço apigee-non-prod. O apigee-cassandra-backup e o apigee-cassandra-restore usam a conta de serviço apigee-cassandra. Por exemplo:

{
  "cassandraBackup": "{
    "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-non-prod@my-project.iam.gserviceaccount.com:generateAccessToken",
    "credential_source": {
      "file": "/var/run/service-account/token",
      "format": {
        "type": "text"
      }
    }
  }",
  "cassandraRestore":...
...
}

Conceda acesso ao segredo da organização. Crie um ficheiro de texto denominado orgsakeys-auth-policy.txt com o seguinte conteúdo:
```
path "secret/data/apigee/orgsakeys" {
  capabilities = ["read"]
}
```
No Vault, crie uma política que conceda acesso ao segredo da organização:
```
vault policy write apigee-orgsakeys-auth orgsakeys-auth-policy.txt
```
Para cada ambiente, crie um ficheiro de texto denominado envsakeys-ENV_NAME-auth-policy.txt com o seguinte conteúdo:
```
path "secret/data/apigee/envsakeys-ENV_NAME" {
  capabilities = ["read"]
}
```
Repita este passo para cada ambiente.
No Vault, crie uma política que conceda acesso ao segredo do ambiente:
```
vault policy write apigee-envsakeys-ENV_NAME-auth envsakeys-ENV_NAME-auth-policy.txt
```
Repita este passo para cada ambiente.

Crie um script denominado generate-encoded-sas.sh com o seguinte conteúdo:

# generate-encoded-sas.sh

ORG=$APIGEE_ORG            # Apigee organization name
ENVS=$APIGEE_ENV_LIST      # comma separated env names, for example: dev,prod

ORG_SHORT_NAME=$(echo $ORG | head -c 15)
ENCODE=$(echo -n $ORG | shasum -a 256 | head -c 7)
ORG_ENCODE=$(echo "$ORG_SHORT_NAME-$ENCODE")
NAMES=apigee-manager,apigee-cassandra-default,apigee-cassandra-backup-sa,apigee-cassandra-restore-sa,apigee-cassandra-schema-setup-${ORG_ENCODE},apigee-cassandra-schema-val-${ORG_ENCODE},apigee-cassandra-user-setup-${ORG_ENCODE},apigee-mart-${ORG_ENCODE},apigee-mint-task-scheduler-${ORG_ENCODE},apigee-connect-agent-${ORG_ENCODE},apigee-watcher-${ORG_ENCODE},apigee-udca-${ORG_ENCODE},apigee-metrics-apigee-telemetry,apigee-open-telemetry-collector-apigee-telemetry,apigee-logger-apigee-telemetry

for ENV in ${ENVS//,/ }
  do
    ENV_SHORT_NAME=$(echo $ENV | head -c 15)
    ENCODE=$(echo -n $ORG:$ENV | shasum -a 256 | head -c 7)
    ENV_ENCODE=$(echo "$ORG_SHORT_NAME-$ENV_SHORT_NAME-$ENCODE")
    NAMES+=,apigee-synchronizer-${ENV_ENCODE},apigee-runtime-${ENV_ENCODE}
  done

echo $NAMES

Nota: remova apigee-mint-task-scheduler-${ORG_ENCODE} se não estiver a usar a rentabilização para o Apigee Hybrid.

Execute o script para gerar a lista de nomes de contas de serviço à qual associar a política:

./generate-encoded-sas.sh

O resultado deve ser uma lista de nomes de contas de serviço do Kubernetes separados por vírgulas, semelhante ao seguinte exemplo:

./generate-encoded-sas.sh
apigee-manager,apigee-cassandra-default,apigee-cassandra-backup-sa,
apigee-cassandra-restore-sa,apigee-cassandra-schema-setup-myhybrido
rg-5b044c1,apigee-cassandra-schema-val-myhybridorg-5b044c1,apigee-c
assandra-user-setup-myhybridorg-5b044c1,apigee-mart-myhybridorg-5b0
44c1,apigee-mint-task-scheduler-myhybridorg-5b044c1,apigee-connect-
agent-myhybridorg-5b044c1,apigee-watcher-myhybridorg-5b044c1,apigee
-udca-myhybridorg-5b044c1,apigee-metrics-apigee-telemetry,apigee-op
en-telemetry-collector-apigee-telemetry,apigee-logger-apigee-teleme
try,apigee-synchronizer-myhybridorg-dev-ee52aca,apigee-runtime-myhy
bridorg-dev-ee52aca,apigee-synchronizer-myhybridorg-prod-2d0221c,ap
igee-runtime-myhybridorg-prod-2d0221c

A lista de nomes de serviços org do exemplo anterior:

apigee-manager,apigee-cassandra-default,apigee-cassandra-backup-sa,
apigee-cassandra-restore-sa,apigee-cassandra-schema-setup-myhybrido
rg-5b044c1,apigee-cassandra-schema-val-myhybridorg-5b044c1,apigee-c
assandra-user-setup-myhybridorg-5b044c1,apigee-mart-myhybridorg-5b0
44c1,apigee-mint-task-scheduler-myhybridorg-5b044c1,apigee-connect-
agent-myhybridorg-5b044c1,apigee-watcher-myhybridorg-5b044c1,apigee
-udca-myhybridorg-5b044c1,apigee-metrics-apigee-telemetry,apigee-op
en-telemetry-collector-apigee-telemetry,apigee-logger-apigee-teleme
try

dev ambiente:

apigee-synchronizer-myhybridorg-dev-ee52aca,apigee-runtime-myhybrid
org-dev-ee52aca

prod ambiente:

apigee-synchronizer-myhybridorg-prod-2d0221c,apigee-runtime-myhybri
dorg-prod-2d0221c

Usando a política, crie uma função do Vault que associe as contas de serviço do Apigee específicas da organização:

vault write auth/kubernetes/role/apigee-orgsakeys \
  bound_service_account_names=LIST_OF_ORG_SA_NAMES \
  bound_service_account_namespaces=apigee \
  policies=apigee-orgsakeys-auth \
  ttl=1m

Para cada ambiente, crie uma função do Vault para as respetivas chaves de conta de serviço:

vault write auth/kubernetes/role/apigee-envsakeys-ENV_NAME \
  bound_service_account_names=LIST_OF_ENV_NAME_SA_NAMES \
  bound_service_account_namespaces=apigee \
  policies=apigee-envsakeys-ENV_NAME-auth \ 
  ttl=1m

Repita este passo para cada ambiente.

Crie `SecretProviderClass` objetos

Conta de serviço	Nomes de ficheiros secretos esperados
Cópia de segurança do Cassandra	`cassandraBackup`
Restauro do Cassandra	`cassandraRestore`
Ligar a um agente	`connectAgent`
MART	`mart`
Métrica	`metrics`
Rentabilização (se usar a rentabilização para o Apigee Hybrid)	`mint`
Tempo de execução	`runtime`
Sincronizador	`synchronizer`
UDCA	`udca`
Observador	`watcher`

Use o seguinte modelo SecretProviderClass para configurar este recurso para os segredos específicos da organização:

apiVersion: secrets-store.csi.x-k8s.io/v1
kind: SecretProviderClass
metadata:
  name: apigee-orgsakeys-spc
spec:
  provider: vault
  parameters:
    roleName: apigee-orgsakeys
    vaultAddress: VAULT_ADDRESS
    # "objectName" is an alias used within the SecretProviderClass to reference
    # that specific secret. This will also be the filename containing the secret.
    # Apigee Hybrid expects these exact values so they must not be changed.
    # "secretPath" is the path in Vault where the secret should be retrieved.
    # "secretKey" is the key within the Vault secret response to extract a value from.
      objects: |
      - objectName: "cassandraBackup"
        secretPath: ""
        secretKey: ""
      - objectName: "cassandraRestore"
        secretPath: ""
        secretKey: ""
      - objectName: "connectAgent"
        secretPath: ""
        secretKey: ""
      - objectName: "logger"
        secretPath: ""
        secretKey: ""
      - objectName: "mart"
        secretPath: ""
        secretKey: ""
      - objectName: "metrics"
        secretPath: ""
        secretKey: ""
      - objectName: "mint"
        secretPath: ""
        secretKey: ""
      - objectName: "udca"
        secretPath: ""
        secretKey: ""
      - objectName: "watcher"
        secretPath: ""
        secretKey: ""

Nota: remova as linhas objectName: "mint" se não estiver a usar a rentabilização para o Apigee Hybrid.

Guarde o modelo num ficheiro com o nome spc-org.yaml.

Aplique o SecretProviderClass específico da organização ao seu espaço de nomes do Apigee:
```
kubectl -n $APIGEE_NAMESPACE apply -f spc-org.yaml
```

Para cada ambiente, use o seguinte modelo SecretProviderClass para configurar este recurso para os segredos específicos do ambiente. Repita este passo para cada ambiente:

apiVersion: secrets-store.csi.x-k8s.io/v1
kind: SecretProviderClass
metadata:
  name: apigee-envsakeys-ENV_NAME-spc
spec:
  provider: vault
  parameters:
    roleName: apigee-envsakeys-ENV_NAME
    vaultAddress: VAULT_ADDRESS
    # "objectName" is an alias used within the SecretProviderClass to reference
    # that specific secret. This will also be the filename containing the secret.
    # Apigee Hybrid expects these exact values so they must not be changed.
    # "secretPath" is the path in Vault where the secret should be retrieved.
    # "secretKey" is the key within the Vault secret response to extract a value from.
    objects: |
      - objectName: "runtime"
        secretPath: ""
        secretKey: ""
      - objectName: "synchronizer"
        secretPath: ""
        secretKey: ""
      - objectName: "udca"
        secretPath: ""
        secretKey: ""

Guarde o modelo num ficheiro com o nome spc-env-ENV_NAME.yaml.

Para cada ambiente, aplique o SecretProviderClass específico do ambiente ao seu espaço de nomes do Apigee:
```
kubectl -n $APIGEE_NAMESPACE apply -f spc-env-ENV_NAME.yaml
```
Repita este passo para cada ambiente.

Passo seguinte

1 2 3 4 5 (NEXT) Passo 6: crie certificados TLS 7 8 9 10 11

Passo 5: configure a autenticação da conta de serviço Mantenha tudo organizado com as coleções Salve e categorize o conteúdo com base nas suas preferências.

Vista geral

Segredos do Kubernetes

Contas de serviço

Produção

Não prod

Crie segredos do Kubernetes

Produção

Não prod

Ficheiros JSON

Vault

Configure o armazenamento de segredos da conta de serviço no Vault

Instale o controlador CSI e o fornecedor do Vault

Crie segredos, políticas e funções do Vault

Crie SecretProviderClass objetos

WIF para o GKE

Prepare-se para configurar a federação de identidades de cargas de trabalho para o GKE

Clusters regionais

Clusters zonais

Clusters regionais

Clusters zonais

Clusters regionais

Clusters zonais

Clusters regionais

Clusters zonais

WIF noutras plataformas

Configure o cluster para usar a Workload Identity Federation.

Consola

Linha de comandos

Funções necessárias

AKS

EKS

Outro Kubernetes

Acessível publicamente

Não acessível publicamente

Crie os ficheiros de configuração de credenciais

Produção

Não prod

WIF: secrets

Crie os ficheiros de configuração de credenciais

Produção

Não prod

Crie os segredos do Kubernetes

Produção

Não prod

WIF: ficheiros

Produção

Não prod

WIF: Vault

Crie os ficheiros de configuração de credenciais

Produção

Não prod

Instale o controlador CSI e o fornecedor do Vault

Crie segredos, políticas e funções do Vault

Produção

Não prod

Crie SecretProviderClass objetos

Passo seguinte

Passo 5: configure a autenticação da conta de serviço

Crie `SecretProviderClass` objetos

Crie `SecretProviderClass` objetos