Esta página foi traduzida pela API Cloud Translation.

Etapa 5: configurar a autenticação da conta de serviço

Visão geral

Nesta etapa, explicamos como configurar os métodos de autenticação para as contas de serviço do Google Cloud criadas na etapa anterior.

Selecione as instruções para o método de autenticação que você quer usar. Consulte Métodos de autenticação de contas de serviço na Apigee híbrida para uma visão geral dos diferentes métodos de autenticação.

Secrets do Kubernetes

Contas de serviço

Você precisará criar secrets do Kubernetes para as seguintes contas de serviço:

Produção

apigee-cassandra
apigee-logger
apigee-mart
apigee-metrics
apigee-mint-task-scheduler (se você estiver usando a Monetização para Apigee híbrida)
apigee-runtime
apigee-synchronizer
apigee-udca
apigee-watcher

Sem produção

apigee-non-prod

Você vai fornecer cada um desses secrets na etapa Criar o arquivo de substituições.

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

$APIGEE_HELM_CHARTS_HOME
$APIGEE_NAMESPACE
$PROJECT_ID

Se você não as tiver definido, substitua o valor apropriado para cada variável nos exemplos de código.

Criar secrets do Kubernetes

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

O comando kubectl create secret nas amostras de código a seguir tem a estrutura:

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

Observação:os comandos a seguir pressupõem que você fez o download dos arquivos de chave da conta de serviço no diretório $APIGEE_HELM_CHARTS_HOME/service-accounts/ na Etapa 4: criar contas de serviço. Se você fez o download das 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 você estiver usando a Monetização para Apigee híbrida, também será necessário criar um secret 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

Sem produção

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:você pode excluir os arquivos JSON da conta de serviço depois de criar os segredos do Kubernetes.

Para mais informações sobre como usar secrets do Kubernetes com a Apigee híbrida, consulte Como armazenar chaves de conta de serviço em secrets do Kubernetes.

Arquivos JSON

Nenhuma etapa extra é necessária para configurar a autenticação com arquivos JSON. Acesse Etapa 6: criar certificados TLS.

Vault

Configurar para armazenar secrets de contas de serviço no Vault

Instalar o driver CSI e o provedor do Vault

Se você ainda não instalou o driver CSI no cluster usando o Helm, siga as instruções em Driver CSI do Secrets Store: instalação (em inglês). Para mais informações, consulte Como instalar o provedor CSI do Vault na documentação do Vault.

Acesse Plataformas e versões compatíveis com a Apigee híbrida para ver as versões mínimas de drivers CSI compatíveis com a Apigee híbrida.

Criar secrets, políticas e papéis do Vault

Use a interface ou as APIs do Vault para criar segredos e conceder permissões às contas de serviço do Kubernetes usadas pela Apigee híbrida para ler esses segredos.

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

Chave secreta Dados de secret

Chave secreta	Dados de secret
secret/data/apigee/orgsakeys	{ "cassandraBackup": "*", "cassandraRestore": "", "connectAgent": "", "logger": "", "mart": "", "metrics": "", "mint": "", "udca": "", "watcher": "" } Observação**:`mint` só é necessário se você estiver usando a Monetização para Apigee híbrida (v1.15.1 e mais recentes).
secret/data/apigee/envsakeys-`ENV_NAME`	{ "runtime": "*", "synchronizer": "", "udca": "**". }

secret/data/apigee/orgsakeys

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

Observação:mint só é necessário se você estiver usando a Monetização para Apigee híbrida (v1.15.1 e mais recentes).

secret/data/apigee/envsakeys-ENV_NAME

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

Substitua o "***" em cada par pelo conteúdo do arquivo .json da conta de serviço do Google correspondente ao componente da Apigee. apigee-cassandra-backup e apigee-cassandra-restore usam a conta de serviço apigee-cassandra. 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 secret da organização. Crie um arquivo de texto chamado 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 secret da organização:
```
vault policy write apigee-orgsakeys-auth orgsakeys-auth-policy.txt
```
Para cada ambiente, crie um arquivo de texto chamado envsakeys-ENV_NAME-auth-policy.txt com o seguinte conteúdo:
```
path "secret/data/apigee/envsakeys-ENV_NAME" {
    capabilities = ["read"]
}
```
Repita essa etapa para cada ambiente.
No Vault, crie uma política que conceda acesso ao secret do ambiente:
```
vault policy write apigee-envsakeys-ENV_NAME-auth envsakeys-ENV_NAME-auth-policy.txt
```
Repita essa etapa para cada ambiente.

Crie um script chamado 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

Observação:remova apigee-mint-task-scheduler-${ORG_ENCODE} se não estiver usando a monetização para a Apigee híbrida.

Execute o script para gerar a lista de nomes da conta de serviço e vincular a política a:

./generate-encoded-sas.sh

A saída será uma lista de nomes de contas de serviço do Kubernetes separados por vírgulas, semelhante ao exemplo a seguir:

./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 o separe em listas, uma para os nomes das contas de serviço org e outra para os nomes das contas de serviço env de cada ambiente. As contas de serviço da organização são as primeiras na lista de saída até apigee-logger-apigee-telemetry.

A lista de nomes de serviço da 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-as em listas separadas para cada ambiente. Por exemplo, a saída do exemplo anterior pode ser separada nas duas listas a seguir:

ambiente dev:

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

ambiente prod:

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

Usando a política, crie um papel do Vault que vincule 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

Crie um papel do Vault para as chaves das contas de serviço de cada ambiente:

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 essa etapa para cada ambiente.

Criar objetos `SecretProviderClass`

O recurso SecretProviderClass informa ao driver CSI com qual provedor se comunicar ao solicitar secrets. As chaves da conta de serviço precisam ser configuradas por meio desse objeto. A tabela a seguir mostra os nomes de arquivo (objectNames) esperados pela Apigee híbrida:

Conta de serviço	Nomes de arquivos de secrets esperados
Backup do Cassandra	`cassandraBackup`
Restauração do Cassandra	`cassandraRestore`
Agente do Connect	`connectAgent`
Logger	`logger`
MART	`mart`
Métricas	`metrics`
Monetização (se estiver usando a Monetização para a Apigee híbrida)	`mint`
Ambiente de execução	`runtime`
Sincronizador	`synchronizer`
UDCA	`udca`
Watcher	`watcher`

Use o seguinte modelo de 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: ""

Observação:remova as linhas objectName: "mint" se não estiver usando a monetização para a Apigee híbrida.

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

Salve o modelo em um arquivo chamado spc-org.yaml.

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

Para cada ambiente, use o seguinte modelo de SecretProviderClass para configurar esse recurso para os segredos específicos do ambiente. Repita essa etapa 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 endpoint em que o servidor do Vault está em execução. Se o Vault estiver sendo executado no mesmo cluster e namespace que a Apigee, o formato geralmente será http://vault.$APIGEE_NAMESPACE.svc.cluster.local:VAULT_SERVICE_PORT.

Salve o modelo em um arquivo chamado spc-env-ENV_NAME.yaml.

Para cada ambiente, aplique o SecretProviderClass específico ao ambiente ao seu namespace do Apigee:
```
kubectl -n $APIGEE_NAMESPACE apply -f spc-env-ENV_NAME.yaml
```
Repita essa etapa para cada ambiente.
Opcional:você pode excluir os arquivos JSON da conta de serviço depois de criar os objetos SecretProviderClass.

WIF para GKE

Preparar-se para configurar a Federação de Identidade da Carga de Trabalho para GKE

Verifique se a federação de identidade da carga de trabalho para GKE está ativada no arquivo de substituições. Ela precisa ser ativada no arquivo de substituições nas propriedades a seguir.
- namespace é obrigatório. Exemplo:
```
instanceID: "hybrid-instance-1"
namespace: "apigee"
```
- Se você estiver usando uma única conta de serviço (de não produção) para todos os componentes, especifique-a com: gcp.workloadIdentity.gsa. Exemplo:
```
  gcp:
    workloadIdentity:
      enabled: true
      gsa: "apigee-non-prod@my-hybrid-project.iam.gserviceaccount.com"
  
```
- Se você estiver usando uma conta de serviço separada para cada componente (instalações Production), especifique a conta de serviço com a propriedade gsa do componente. Exemplo:
```
  logger:
    gsa: "apigee-logger@my-hybrid-project.iam.gserviceaccount.com"
  
```
Ver: gcp.workloadIdentity.enabled.
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

Verifique se a federação de identidade da carga de trabalho do GKE está ativada no cluster do GKE. Quando você criou o cluster na Etapa 1: criar um cluster, a etapa 6 foi ativar a federação de identidade da carga de trabalho para o GKE. Confirme se ele está ativado 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'

A saída será semelhante a esta:

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

Se você vir null nos resultados, execute o seguinte comando para ativar a federação de identidade da carga de trabalho para GKE no 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 federação de identidade da carga de trabalho para o GKE em cada pool de nós com os comandos a seguir. Essa operação pode levar 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
```
Em que NODE_POOL_NAME é o nome de cada pool de nós. Na maioria das instalações da Apigee híbrida, os dois pools de nós padrão são denominados apigee-data e apigee-runtime.

Verifique se a federação de identidade da carga de trabalho para GKE está ativada nos pools de nós 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:"

A resposta será semelhante a esta:

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

Dica:é possível limitar a saída ao campo workloadMetadataConfig encaminhando a saída por 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 em outras plataformas

Ao usar a federação de identidade da carga de trabalho em plataformas diferentes do GKE, é possível usar os seguintes métodos para configurar a autenticação da SA:

Secrets do Kubernetes
Arquivos JSON da conta de serviço
Vault

Nas instruções a seguir, escolha a guia do método de autenticação que você está usando.

Este procedimento usa as duas variáveis de ambiente a seguir definidas na Etapa 2: fazer o download dos gráficos do Apigee Helm. Essas variáveis são opcionais. Se você não as tiver definido, substitua o caminho do diretório apropriado para cada variável nos exemplos de código.

$APIGEE_HELM_CHARTS_HOME: o diretório em que você fez o download dos gráficos do Apigee Helm, definido na Etapa 2: fazer o download dos gráficos do Apigee Helm.
$PROJECT_ID: o ID do projeto do Google Cloud, definido na Parte 1: configuração do projeto e da organização - Etapa 1: ativar APIs.

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 seguinte comando:
```
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.
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 comando

Ative a API com o seguinte comando:
```
gcloud services enable sts.googleapis.com --project $PROJECT_ID
```
Crie o pool de identidades 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 usando papéis personalizados ou 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, recomendamos que você faça 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 CLUSTER_NAME -g RESOURCE_GROUP --query "oidcIssuerProfile.issuerUrl" -otsv
  Substitua:
  - CLUSTER_NAME: o nome do cluster.
  - RESOURCE_GROUP: o grupo de recursos do cluster.
  O comando gera o URL do emissor. Você vai precisar 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 CLUSTER_NAME --query "cluster.identity.oidc.issuer" --output text
  Substitua CLUSTER_NAME pelo nome do cluster.
  
  O comando gera o URL do emissor. Você precisa do URL do emissor em uma das etapas a seguir.
  Outro Kubernetes
  
  Conecte-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
  Você precisa do URL do emissor em uma das etapas a seguir.
2. Opcional:se o emissor do OIDC não estiver acessível publicamente, faça o download do conjunto de chaves da Web JSON (JWKS) do cluster:
  Observação:esta etapa exige acesso do kubectl ao cluster.
  
  Dica:ao usar o arquivo JWKS, você precisará fazer upload de um novo arquivo 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, acesse o URL dele com um comando CURL e receba 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 identidades de carga de trabalho. Escolha o comando para criar o provedor dependendo se o emissor OIDC está acessível publicamente ou não acessível publicamente:
  Acessível publicamente
  
  Se o emissor do OIDC estiver 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 publicamente
  
  Se o emissor OIDC não estiver 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" \ --jwks-file="cluster-jwks.json" \ --attribute-mapping="google.subject=assertion.sub"
  Observação:se você alternar as chaves, faça upload do novo JWKS a cada rotação de chaves.
  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 identidades 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 assunto do Kubernetes para o assunto do IAM.

Criar os arquivos de configuração de credenciais

Para implantar uma carga de trabalho do Kubernetes que possa acessar recursos do Google Cloud , primeiro crie 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:você provavelmente já criou as contas de serviço do IAM (também chamadas de "contas de serviço do Google") durante a instalação inicial da Apigee híbrida 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 Etapa 4: criar contas de serviço no guia de instalação para criar as contas de serviço do IAM.

É necessário criar os arquivos 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 você estiver usando a Monetização para Apigee híbrida na v1.15.1 e versões mais recentes, também será necessário criar o arquivo 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
...
```
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 correspondam facilmente aos nomes dos componentes da Apigee, determine a função de cada conta de serviço verificando os papéis atribuídos a ela e comparando-os com os papéis 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"
```
Observe qual conta de serviço personalizada corresponde a cada SA do IAM listada na lista anterior.

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

WIF: secrets

Essa abordagem usa configurações de credenciais armazenadas em secrets do Kubernetes. Ao criar o arquivo de substituições na Etapa 7: criar as substituições, você fornece o nome do secret para cada conta de serviço com a propriedade serviceAccountRef ou envs.serviceAccountRefs.

Criar os arquivos de configuração de credenciais

Produção

Você precisará criar os arquivos de configuração de credenciais para as seguintes contas de serviço:

apigee-cassandra
apigee-mart
apigee-metrics
apigee-mint-task-scheduler Se você estiver usando a Monetização para a Apigee híbrida.
apigee-runtime
apigee-synchronizer
apigee-udca

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

Crie o arquivo 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

Em que:

PROJECT_NUMBER: o número do projeto que contém o pool de identidades da carga de trabalho. Esse precisa ser o número do projeto, não o ID do projeto.
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

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

Crie o arquivo 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 arquivo 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 arquivo 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 arquivo 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 arquivo 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 arquivo 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 você estiver usando a Monetização para a Apigee híbrida, também será necessário criar o arquivo 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

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

Sem produção

Crie um diretório para o arquivo de configuração de credenciais. O diretório pode ter qualquer nome. Para este procedimento, o diretório é chamado de credential-configurations:
```
mkdir $APIGEE_HELM_CHARTS_HOME/credential-configurations
```
Crie o arquivo 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
```
Em que:
- PROJECT_NUMBER: o número do projeto que contém o pool de identidades da carga de trabalho. Esse precisa ser o número do projeto, não o ID do projeto.
- 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
Importante:credential-source-type precisa ser definido como text.

Criar os secrets do Kubernetes

Crie os secrets do Kubernetes para armazenar os arquivos de configuração de credenciais de cada conta de serviço.

O comando kubectl create secret nas amostras de código a seguir 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 arquivo de secret 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 arquivo de secret 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 arquivo de secret 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 arquivo de secret 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 arquivo de secret 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 arquivo de secret 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 arquivo de secret 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 você estiver usando a Monetização para a Apigee híbrida, crie o arquivo de secret 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 arquivo de secret para apigee-non-prod:

Sem produção

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: arquivos

Essa abordagem usa os arquivos de configuração de credenciais em vez dos arquivos de chave da conta de serviço do Google. Ao criar o arquivo de substituições na Etapa 7: criar as substituições, você fornece o caminho para o arquivo de configuração de credenciais de cada propriedade serviceAccountPath ou envs.serviceAccountPaths.

Produção

Você precisará criar os arquivos de configuração de credenciais nos diretórios de gráficos correspondentes:

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-mint-task-scheduler` (se você estiver usando a Monetização para Apigee híbrida)	`apigee-org/`
`apigee-runtime`	`apigee-env/`
`apigee-synchronizer`	`apigee-env/`
`apigee-udca`	`apigee-org/` `apigee-env/`
`apigee-watcher`	`apigee-org/`

Crie os arquivos de configuração de 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

Em que:

PROJECT_NUMBER: o número do projeto que contém o pool de identidades da carga de trabalho. Esse precisa ser o número do projeto, não o ID do projeto.
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

Importante:credential-source-type precisa ser 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 arquivo de configuração de credenciais no diretório de gráfico apigee-org.

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 arquivo de configuração de credenciais para o diretório de gráficos 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 você estiver usando a href="monetization-for-hybrid">Monetização para a Apigee híbrida, também será necessário criar o arquivo 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

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

Sem produção

Crie o arquivo de configuração de credenciais e copie para os diretórios de gráficos correspondentes:

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

Crie o arquivo 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
```
Em que:
- PROJECT_NUMBER: o número do projeto que contém o pool de identidades da carga de trabalho. Esse precisa ser o número do projeto, não o ID do projeto.
- 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
Importante:credential-source-type precisa ser definido como text.

Copie o arquivo de configuração de credenciais para os diretórios de gráficos 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

Essa abordagem usa configurações de credenciais armazenadas em um gerenciador de secrets externo, o Hashicorp Vault. Ao criar o arquivo de substituições na Etapa 7: criar as substituições, você fornece secrets do Vault no nível da organização e do ambiente com as propriedades serviceAccountSecretProviderClass ou envs.serviceAccountSecretProviderClass.

Criar os arquivos de configuração de credenciais

Produção

Você precisará criar os arquivos de configuração de credenciais para as seguintes contas de serviço:

apigee-cassandra
apigee-mart
apigee-metrics
apigee-mint-task-scheduler (se você estiver usando a Monetização para Apigee híbrida)
apigee-runtime
apigee-synchronizer
apigee-udca

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

Crie o arquivo 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

Em que:

PROJECT_NUMBER: o número do projeto que contém o pool de identidades da carga de trabalho. Esse precisa ser o número do projeto, não o ID do projeto.
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

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

Crie o arquivo 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 arquivo 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 arquivo 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 arquivo 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 arquivo 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 arquivo 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 você estiver usando a Monetização para a Apigee híbrida, também será necessário criar o arquivo 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

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

Sem produção

Crie um diretório para o arquivo de configuração de credenciais. O diretório pode ter qualquer nome. Para este procedimento, o diretório é chamado de credential-configurations:
```
mkdir $APIGEE_HELM_CHARTS_HOME/credential-configurations
```
Crie o arquivo 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
```
Em que:
- PROJECT_NUMBER: o número do projeto que contém o pool de identidades da carga de trabalho. Esse precisa ser o número do projeto, não o ID do projeto.
  Dica:para encontrar o número do projeto, use o seguinte comando:
```
gcloud projects describe $PROJECT_ID --format="value(projectNumber)"
```
  "
- 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
Importante:credential-source-type precisa ser definido como text.

Instalar o driver CSI e o provedor do Vault

Acesse Plataformas e versões compatíveis com a Apigee híbrida para ver as versões mínimas de drivers CSI compatíveis com a Apigee híbrida.

Criar secrets, políticas e papéis do Vault

Use a interface ou as APIs do Vault para criar segredos e conceder permissões às contas de serviço do Kubernetes usadas pela Apigee híbrida para ler esses segredos.

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

Chave secreta Dados de secret

Chave secreta	Dados de secret
secret/data/apigee/orgsakeys	{ "cassandraBackup": "*", "cassandraRestore": "", "connectAgent": "", "logger": "", "mart": "", "metrics": "", "mint": "", "udca": "", "watcher": "" } Observação**:`mint` só é necessário se você estiver usando a Monetização para Apigee híbrida (v1.15.1 e mais recente).
secret/data/apigee/envsakeys-`ENV_NAME`	{ "runtime": "*", "synchronizer": "", "udca": "**". }

secret/data/apigee/orgsakeys

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

Observação:mint só é necessário se você estiver usando a Monetização para Apigee híbrida (v1.15.1 e mais recente).

secret/data/apigee/envsakeys-ENV_NAME

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

Produção

Substitua o "***" em cada par pelo conteúdo do arquivo de configuração de credenciais da conta de serviço do Google correspondente ao componente da Apigee. apigee-cassandra-backup e apigee-cassandra-restore usam a conta de serviço apigee-cassandra. 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":...
...
}

Sem produção

Substitua o "***" em cada par pelo conteúdo do arquivo de configuração de credenciais da conta de serviço apigee-non-prod. apigee-cassandra-backup e apigee-cassandra-restore usam a conta de serviço apigee-cassandra. 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 secret da organização. Crie um arquivo de texto chamado 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 secret da organização:
```
vault policy write apigee-orgsakeys-auth orgsakeys-auth-policy.txt
```
Para cada ambiente, crie um arquivo de texto chamado envsakeys-ENV_NAME-auth-policy.txt com o seguinte conteúdo:
```
path "secret/data/apigee/envsakeys-ENV_NAME" {
  capabilities = ["read"]
}
```
Repita essa etapa para cada ambiente.
No Vault, crie uma política que conceda acesso ao secret do ambiente:
```
vault policy write apigee-envsakeys-ENV_NAME-auth envsakeys-ENV_NAME-auth-policy.txt
```
Repita essa etapa para cada ambiente.

Crie um script chamado 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

Observação:remova apigee-mint-task-scheduler-${ORG_ENCODE} se não estiver usando a monetização para a Apigee híbrida.

Execute o script para gerar a lista de nomes da conta de serviço e vincular a política a:

./generate-encoded-sas.sh

A saída será uma lista de nomes de contas de serviço do Kubernetes separados por vírgulas, semelhante ao exemplo a seguir:

./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ço da 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

ambiente dev:

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

ambiente prod:

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

Usando a política, crie um papel do Vault que vincule 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

Crie um papel do Vault para as chaves das contas de serviço de cada ambiente:

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 essa etapa para cada ambiente.

Criar objetos `SecretProviderClass`

Conta de serviço	Nomes de arquivos de secrets esperados
Backup do Cassandra	`cassandraBackup`
Restauração do Cassandra	`cassandraRestore`
Agente do Connect	`connectAgent`
MART	`mart`
Métricas	`metrics`
Monetização (se estiver usando a Monetização para Apigee híbrida)	`mint`
Ambiente de execução	`runtime`
Sincronizador	`synchronizer`
UDCA	`udca`
Watcher	`watcher`

Use o seguinte modelo de 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: ""

Observação:remova as linhas objectName: "mint" se não estiver usando a monetização da Apigee híbrida.

Salve o modelo em um arquivo chamado spc-org.yaml.

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

Para cada ambiente, use o seguinte modelo de SecretProviderClass para configurar esse recurso para os segredos específicos do ambiente. Repita essa etapa 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: ""

Salve o modelo em um arquivo chamado spc-env-ENV_NAME.yaml.

Para cada ambiente, aplique o SecretProviderClass específico ao ambiente ao seu namespace do Apigee:
```
kubectl -n $APIGEE_NAMESPACE apply -f spc-env-ENV_NAME.yaml
```
Repita essa etapa para cada ambiente.

Próxima etapa

1 2 3 4 5 (PRÓXIMA) Etapa 6: criar certificados TLS 7 8 9 10 11

Etapa 5: configurar 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.

Visão geral

Secrets do Kubernetes

Contas de serviço

Produção

Sem produção

Criar secrets do Kubernetes

Produção

Sem produção

Arquivos JSON

Vault

Configurar para armazenar secrets de contas de serviço no Vault

Instalar o driver CSI e o provedor do Vault

Criar secrets, políticas e papéis do Vault

Criar objetos SecretProviderClass

WIF para GKE

Preparar-se para configurar a Federação de Identidade da Carga de Trabalho para GKE

Clusters regionais

Clusters zonais

Clusters regionais

Clusters zonais

Clusters regionais

Clusters zonais

Clusters regionais

Clusters zonais

WIF em outras plataformas

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

Console

Linha de comando

Funções exigidas

AKS

EKS

Outro Kubernetes

Acessível publicamente

Não acessível publicamente

Criar os arquivos de configuração de credenciais

Produção

Sem produção

WIF: secrets

Criar os arquivos de configuração de credenciais

Produção

Sem produção

Criar os secrets do Kubernetes

Produção

Sem produção

WIF: arquivos

Produção

Sem produção

WIF: Vault

Criar os arquivos de configuração de credenciais

Produção

Sem produção

Instalar o driver CSI e o provedor do Vault

Criar secrets, políticas e papéis do Vault

Produção

Sem produção

Criar objetos SecretProviderClass

Próxima etapa

Etapa 5: configurar a autenticação da conta de serviço

Criar objetos `SecretProviderClass`

Criar objetos `SecretProviderClass`