Questa pagina è stata tradotta dall'API Cloud Translation.

Passaggio 5: configura l'autenticazione del account di servizio

Panoramica

Questo passaggio spiega come configurare i metodi di autenticazione per gli account di servizio Google Cloud che hai creato nel passaggio precedente.

Seleziona le istruzioni per il metodo di autenticazione che vuoi utilizzare. Per una panoramica dei diversi metodi di autenticazione, consulta Metodi di autenticazione dell'account di servizio in Apigee Hybrid.

Secret Kubernetes

Account di servizio

Devi creare secret Kubernetes per i seguenti service account:

Produzione

apigee-cassandra
apigee-logger
apigee-mart
apigee-metrics
apigee-mint-task-scheduler (se utilizzi Monetizzazione per Apigee hybrid)
apigee-runtime
apigee-synchronizer
apigee-udca
apigee-watcher

Non di produzione

apigee-non-prod

Fornirai ciascuno di questi secret durante il passaggio Crea il file di override.

Questa procedura utilizza le seguenti variabili di ambiente facoltative:

$APIGEE_HELM_CHARTS_HOME
$APIGEE_NAMESPACE
$PROJECT_ID

Se non hai definito queste variabili, sostituisci il valore appropriato per ciascuna variabile negli esempi di codice.

Crea secret Kubernetes

Crea i secret di Kubernetes per archiviare le chiavi del account di servizio.

Il comando kubectl create secret nei seguenti esempi di codice ha la struttura:

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

Nota:i seguenti comandi presuppongono che tu abbia scaricato i file della chiave del account di servizio nella directory $APIGEE_HELM_CHARTS_HOME/service-accounts/ nel passaggio 4: crea service account. Se hai scaricato le chiavi in una directory diversa, modifica i comandi in modo da utilizzare la directory corretta.

Produzione

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 utilizzi Monetizzazione per Apigee hybrid, devi anche creare un secret Kubernetes per l'account di servizio 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

Non di produzione

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

(Facoltativo) Puoi eliminare i file JSON del account di servizio dopo aver creato i secret Kubernetes.

Per ulteriori informazioni sull'utilizzo dei secret di Kubernetes con Apigee Hybrid, consulta Memorizzare le chiavi dei account di servizio nei secret di Kubernetes.

File JSON

Non sono necessari ulteriori passaggi per configurare l'autenticazione con i file JSON. Vai al Passaggio 6: crea i certificati TLS.

Vault

Configurare l'archiviazione dei secret del account di servizio in Vault

Installa il driver CSI e il provider Vault

Se non hai ancora installato il driver CSI sul cluster utilizzando Helm, segui le istruzioni riportate in Secrets Store CSI Driver: Installation. Per saperne di più, consulta la sezione Installazione del provider CSI di Vault nella documentazione di Vault.

Consulta Piattaforme e versioni supportate di Apigee hybrid per le versioni minime dei driver CSI supportate da Apigee hybrid.

Crea secret, policy e ruoli Vault

Utilizza l'interfaccia utente o le API di Vault per creare secret e concedere autorizzazioni agli account di servizio Kubernetes utilizzati da Apigee Hybrid per leggere questi secret.

Crea i secret specifici dell'organizzazione e dell'ambiente nel seguente formato:

Chiave segreta Secret Data

Chiave segreta	Secret Data
secret/data/apigee/orgsakeys	{ "cassandraBackup": "*", "cassandraRestore": "", "connectAgent": "", "logger": "", "mart": "", "metrics": "", "mint": "", "udca": "", "watcher": "" } Nota**:`mint` è richiesto solo se utilizzi la monetizzazione per Apigee hybrid (v1.15.1 e versioni successive).
secret/data/apigee/envsakeys-`ENV_NAME`	{ "runtime": "*", "synchronizer": "", "udca": "**". }

secret/data/apigee/orgsakeys

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

Nota:mint è richiesto solo se utilizzi la monetizzazione per Apigee hybrid (v1.15.1 e versioni successive).

secret/data/apigee/envsakeys-ENV_NAME

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

Sostituisci "***" in ogni coppia con i contenuti del file .json per il account di servizio Google corrispondente al componente Apigee. apigee-cassandra-backup e apigee-cassandra-restore utilizzano entrambi il account di servizio apigee-cassandra. Ad esempio:

{
    "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":...
...
}

Concedi l'accesso al secret dell'organizzazione. Crea un file di testo denominato orgsakeys-auth-policy.txt con i seguenti contenuti:
```
path "secret/data/apigee/orgsakeys" {
    capabilities = ["read"]
}
```
In Vault, crea una policy che conceda l'accesso al secret dell'organizzazione:
```
vault policy write apigee-orgsakeys-auth orgsakeys-auth-policy.txt
```
Per ogni ambiente, crea un file di testo denominato envsakeys-ENV_NAME-auth-policy.txt con i seguenti contenuti:
```
path "secret/data/apigee/envsakeys-ENV_NAME" {
    capabilities = ["read"]
}
```
Ripeti questo passaggio per ogni ambiente.
In Vault, crea una policy che conceda l'accesso al secret dell'ambiente:
```
vault policy write apigee-envsakeys-ENV_NAME-auth envsakeys-ENV_NAME-auth-policy.txt
```
Ripeti questo passaggio per ogni ambiente.

Crea uno script denominato generate-encoded-sas.sh con i seguenti contenuti:

# 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:rimuovi apigee-mint-task-scheduler-${ORG_ENCODE} se non utilizzi la monetizzazione per Apigee hybrid.

Esegui lo script per generare l'elenco dei nomi dei account di servizio a cui associare il criterio:

./generate-encoded-sas.sh

L'output deve essere un elenco di nomi di account di servizio Kubernetes separati da virgole, simile al seguente esempio:

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

Copia il testo di output e separalo in elenchi, uno per i nomi dei account di servizio org e un altro per il nome account di servizio env per ogni ambiente. Gli account di servizio org sono i primi nell'elenco di output fino a apigee-logger-apigee-telemetry.

L'elenco dei nomi dei servizi org dell'esempio precedente:

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

I nomi dei account di servizio env hanno il pattern apigee-synchronizer-ORG_NAME-ENV_NAME-HASH_TEXT e apigee-runtime-ORG_NAME-ENV_NAME-HASH_TEXT. Suddividili in elenchi separati per ogni ambiente. Ad esempio, l'output dell'esempio precedente può essere suddiviso nei due elenchi seguenti:

dev environment:

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

prod environment:

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

Utilizzando il criterio, crea un ruolo Vault che associa gli account di servizio Apigee specifici dell'organizzazione:

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

Per ogni ambiente, crea un ruolo Vault per le chiavi del account di servizio:

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

Ripeti questo passaggio per ogni ambiente.

Crea `SecretProviderClass` oggetti

La risorsa SecretProviderClass indica al driver CSI con quale provider comunicare quando richiede i secret. Le chiavi del account di servizio devono essere configurate tramite questo oggetto. La tabella seguente mostra i nomi dei file (objectNames) previsti da Apigee Hybrid:

Service account	Nomi dei file secret previsti
Backup di Cassandra	`cassandraBackup`
Ripristino di Cassandra	`cassandraRestore`
Agente Connect	`connectAgent`
Logger	`logger`
MART	`mart`
Metriche	`metrics`
Monetizzazione (se utilizzi la monetizzazione per Apigee hybrid)	`mint`
Runtime	`runtime`
Sincronizzatore	`synchronizer`
UDCA	`udca`
Watcher	`watcher`

Utilizza il seguente modello SecretProviderClass per configurare questa risorsa per i secret specifici dell'organizzazione:

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:rimuovi le righe objectName: "mint" se non utilizzi la monetizzazione per Apigee hybrid.

VAULT_ADDRESS è l'endpoint in cui è in esecuzione il server Vault. Se Vault è in esecuzione nello stesso cluster di Apigee, il formato sarà in genere http://vault.$APIGEE_NAMESPACE.svc.cluster.local:VAULT_SERVICE_PORT.

Salva il modello in un file denominato spc-org.yaml.

Applica SecretProviderClass specifico dell'organizzazione allo spazio dei nomi apigee:
```
kubectl -n $APIGEE_NAMESPACE apply -f spc-org.yaml
```

Per ogni ambiente, utilizza il seguente modello SecretProviderClass per configurare questa risorsa per i secret specifici dell'ambiente. Ripeti questo passaggio per ogni 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 è l'endpoint in cui è in esecuzione il server Vault. Se Vault è in esecuzione nello stesso cluster e spazio dei nomi di Apigee, il formato sarà in genere http://vault.$APIGEE_NAMESPACE.svc.cluster.local:VAULT_SERVICE_PORT.

Salva il modello in un file denominato spc-env-ENV_NAME.yaml.

Per ogni ambiente, applica SecretProviderClass specifico per l'ambiente allo spazio dei nomi Apigee:
```
kubectl -n $APIGEE_NAMESPACE apply -f spc-env-ENV_NAME.yaml
```
Ripeti questo passaggio per ogni ambiente.
(Facoltativo) Puoi eliminare i file JSON dell'account di servizio dopo aver creato gli oggetti SecretProviderClass.

WIF per GKE

Preparati a configurare Workload Identity Federation for GKE

Verifica che Workload Identity Federation for GKE sia abilitato nel file di override. Deve essere abilitato nel file di override nelle seguenti proprietà.
- namespace è obbligatorio. Ad esempio:
```
instanceID: "hybrid-instance-1"
namespace: "apigee"
```
- Se utilizzi un singolo account di servizio (non di produzione) per tutti i componenti, specificalo con: gcp.workloadIdentity.gsa. Ad esempio:
```
  gcp:
    workloadIdentity:
      enabled: true
      gsa: "apigee-non-prod@my-hybrid-project.iam.gserviceaccount.com"
  
```
- Se utilizzi un account di servizio separato per ogni componente (installazioni di produzione), specifica l'account di servizio con la proprietà gsa del componente. Ad esempio:
```
  logger:
    gsa: "apigee-logger@my-hybrid-project.iam.gserviceaccount.com"
  
```
Vedi: gcp.workloadIdentity.enabled.
Verifica che la configurazione gcloud corrente sia impostata sul tuo ID progetto Google Cloud con il seguente comando:
```
gcloud config get project
```

Se necessario, imposta la configurazione gcloud attuale:

gcloud config set project $PROJECT_ID

Verifica che Workload Identity Federation for GKE sia abilitata per il tuo cluster GKE. Quando hai creato il cluster nel passaggio 1: crea un cluster, il passaggio 6 consisteva nell'abilitare Workload Identity Federation for GKE. Verifica che sia abilitato con il seguente comando:

Cluster a livello di regione

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

Cluster di zona

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

L'output dovrebbe avere l'aspetto seguente:

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

Se nei risultati viene visualizzato null, esegui il seguente comando per abilitare la federazione delle identità per i carichi di lavoro per GKE per il tuo cluster:

Cluster a livello di regione

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

Cluster di zona

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

Abilita la federazione delle identità per i carichi di lavoro per GKE per ogni pool di nodi con i seguenti comandi. Questa operazione può richiedere fino a 30 minuti per nodo:
Cluster a livello di regione
```
gcloud container node-pools update NODE_POOL_NAME \
  --cluster=$CLUSTER_NAME \
  --region $CLUSTER_LOCATION \
  --project $PROJECT_ID \
  --workload-metadata=GKE_METADATA
```
Cluster di zona
```
gcloud container node-pools update NODE_POOL_NAME \
  --cluster=$CLUSTER_NAME \
  --zone $CLUSTER_LOCATION \
  --project $PROJECT_ID \
  --workload-metadata=GKE_METADATA
```
dove NODE_POOL_NAME è il nome di ogni pool di nodi. Nella maggior parte delle installazioni di Apigee Hybrid, i due pool di nodi predefiniti sono denominati apigee-data e apigee-runtime.

Verifica che la federazione delle identità per i carichi di lavoro per GKE sia abilitata nei tuoi pool di nodi con i seguenti comandi:

Cluster a livello di regione

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

Cluster di zona

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

L'output dovrebbe essere simile a questo:

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

Suggerimento:puoi limitare l'output al campo workloadMetadataConfig convogliando l'output tramite grep con il flag -A 1 per includere la riga seguente:

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

WIF su altre piattaforme

Se utilizzi la federazione delle identità per i carichi di lavoro su piattaforme diverse da GKE, puoi utilizzare i seguenti metodi per configurare l'autenticazione SA:

Secret Kubernetes
File JSON del service account
Vault

Nelle istruzioni riportate di seguito, scegli la scheda relativa al metodo di autenticazione che stai utilizzando.

Questa procedura utilizza le due variabili di ambiente seguenti definite nel passaggio 2: scarica i grafici Helm di Apigee. Queste variabili sono facoltative. Se non le hai definite, sostituisci il percorso della directory appropriato per ogni variabile negli esempi di codice.

$APIGEE_HELM_CHARTS_HOME: la directory in cui hai scaricato i grafici Helm di Apigee, definiti nel passaggio 2: scarica i grafici Helm di Apigee.
$PROJECT_ID: l'ID del tuo progetto Google Cloud, definito in Parte 1: Configurazione del progetto e dell'organizzazione - Passaggio 1: attiva le API.

Per le installazioni su AKS, assicurati di aver attivato l'emittente OpenID Connect (OIDC). Devi abilitare questa funzionalità in modo che Workload Identity Federation possa accedere ai metadati OpenID Connect e al set di chiavi web JSON (JWKS) per il cluster.

Configura il cluster in modo che utilizzi la federazione delle identità per i workload.

Verifica che la configurazione gcloud corrente sia impostata sul tuo ID progetto Google Cloud con il seguente comando:
```
gcloud config get project
```

Se necessario, imposta la configurazione gcloud attuale:

gcloud config set project $PROJECT_ID

Abilita l'API Security Token Service:
Verifica che l'API Security Token Service sia abilitata con il seguente comando:
```
gcloud services list --enabled --project $PROJECT_ID | grep sts.googleapis.com
```
Se l'API non è abilitata:
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
Riga di comando

Abilita l'API con il seguente comando:
```
gcloud services enable sts.googleapis.com --project $PROJECT_ID
```
Crea il fornitore e il pool di identità del workload.
Ruoli obbligatori
Per ottenere le autorizzazioni necessarie per configurare la federazione delle identità per i carichi di lavoro, chiedi all'amministratore di concederti i seguenti ruoli IAM sul progetto:
- Amministratore del pool di identità dei carichi di lavoro (roles/iam.workloadIdentityPoolAdmin)
- Amministratore account di servizio (roles/iam.serviceAccountAdmin)
Per ulteriori informazioni sulla concessione dei ruoli, consulta Gestisci l'accesso a progetti, cartelle e organizzazioni.

Potresti anche riuscire a ottenere le autorizzazioni richieste tramite i ruoli personalizzati o altri ruoli predefiniti.

In alternativa, il ruolo di base Proprietario IAM (roles/owner) include anche le autorizzazioni per configurare la federazione delle identità. Non devi concedere ruoli di base in un ambiente di produzione, ma puoi farlo in un ambiente di sviluppo o test.
Per creare un fornitore e un pool di identità del workload:
1. Determina l'URL dell'emittente del tuo cluster AKS:
  AKS
  az aks show -n CLUSTER_NAME -g RESOURCE_GROUP --query "oidcIssuerProfile.issuerUrl" -otsv
  Sostituisci quanto segue:
  - CLUSTER_NAME: il nome del cluster.
  - RESOURCE_GROUP: il gruppo di risorse del cluster.
  Il comando restituisce l'URL dell'emittente. Avrai bisogno dell'URL dell'emittente in uno dei passaggi successivi.
  
  Se il comando non restituisce un URL dell'emittente, verifica di aver attivato la funzionalità Emittente OIDC.
  EKS
  aws eks describe-cluster --name CLUSTER_NAME --query "cluster.identity.oidc.issuer" --output text
  Sostituisci CLUSTER_NAME con il nome del cluster.
  
  Il comando restituisce l'URL dell'emittente. L'URL dell'emittente ti servirà in uno dei passaggi successivi.
  Altri strumenti Kubernetes
  
  Connettiti al cluster Kubernetes e utilizza `kubectl` per determinare l'URL dell'emittente del cluster:
  kubectl get --raw /.well-known/openid-configuration | jq -r .issuer
  L'URL dell'emittente ti servirà in uno dei passaggi successivi.
2. (Facoltativo) Se l'emittente OIDC non è accessibile pubblicamente, scarica il set di chiavi web JSON (JWKS) del cluster:
  Nota: questo passaggio richiede l'accesso kubectl al cluster.
  
  Suggerimento: quando utilizzi il file JWKS, dovrai caricarne uno nuovo ogni volta che ruoti le chiavi di firma per il cluster.
```
kubectl get --raw /openid/v1/jwks > cluster-jwks.json
```
  Per verificare se il tuo provider OIDC è disponibile pubblicamente, dovresti essere in grado di accedere al suo URL con un comando CURL e ricevere una risposta 200.
3. Crea un nuovo pool di identità del workload:
```
gcloud iam workload-identity-pools create POOL_ID \
    --location="global" \
    --description="DESCRIPTION" \
    --display-name="DISPLAY_NAME"
```
  Sostituisci quanto segue:
  - POOL_ID: l'ID univoco del pool.
  - DISPLAY_NAME: (facoltativo) Il nome del pool.
  - DESCRIPTION: (facoltativo) una descrizione del pool che scegli. Questa descrizione viene visualizzata quando concedi l'accesso alle identità del pool.
  Ad esempio:
```
gcloud iam workload-identity-pools create my-wi-pool --display-name="My workload pool" --description="My workload pool description"
```
4. Aggiungi il cluster come provider di pool di identità del workload. Scegli il comando per creare il fornitore a seconda che l'emittente OIDC sia accessibile pubblicamente o non accessibile pubblicamente:
  Pubblicamente accessibile
  
  Se l'emittente OIDC è accessibile pubblicamente, crea il fornitore con il seguente 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"
  Non accessibile pubblicamente
  
  Se l'emittente OIDC non è accessibile pubblicamente, crea il fornitore con il seguente 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 ruoti le chiavi, devi caricare il nuovo JWKS a ogni rotazione della chiave.
  Il comando non convalida il JWKS del cluster. Se il JWKS è danneggiato o scaduto, i successivi tentativi di autenticazione potrebbero non riuscire e restituire il messaggio di errore Error connecting to the given credential's issuer.
  Sostituisci quanto segue:
  - WORKLOAD_PROVIDER_ID: un ID fornitore del pool di identità del workload univoco a tua scelta.
  - POOL_ID: l'ID del pool di identità del workload creato in precedenza.
  - ISSUER: utilizza l'URL dell'emittente che hai determinato in precedenza per l'URI dell'emittente .
  attribute-mapping="google.subject=assertion.sub" mappa il soggetto Kubernetes al soggetto IAM.

Crea i file di configurazione delle credenziali

Per eseguire il deployment di un carico di lavoro Kubernetes che può accedere alle risorse Google Cloud , devi prima creare un file di configurazione delle credenziali per ogni account di servizio IAM:

Elenca i service account IAM (chiamati anche "service account Google") con il seguente comando:
```
gcloud iam service-accounts list --project $PROJECT_ID
```
Nota:molto probabilmente hai già creato i service account IAM (chiamati anche "service account Google") durante l'installazione iniziale di Apigee Hybrid con lo strumento create-service-account. Consulta Informazioni sui service account per un elenco dei service account IAM necessari per Apigee Hybrid. Per la procedura della guida all'installazione per creare i service account IAM, vedi Passaggio 4: crea i service account.

Dovrai creare i file di configurazione delle credenziali per i seguenti service account IAM:
Produzione

Per gli ambienti di produzione:
```
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 utilizzi Monetizzazione per Apigee Hybrid sulla versione v1.15.1 e successive, devi anche creare il file di configurazione delle credenziali per il account di servizio apigee-mint-task-scheduler.
```
DISPLAY NAME                 EMAIL                                                              DISABLED
...
apigee-mint-task-scheduler   apigee-mint-task-scheduler@my_project_id.iam.gserviceaccount.com   False
...
```
Non di produzione

Per gli ambienti non di produzione:
```
DISPLAY NAME         EMAIL                                                      DISABLED
apigee-non-prod      apigee-non-prod@my_project_id.iam.gserviceaccount.com      False
```
Suggerimento:se hai nomi personalizzati per i tuoi service account che non corrispondono facilmente ai nomi dei componenti Apigee, puoi determinare il ruolo di ciascun account di servizio controllando i ruoli assegnati e confrontandoli con i ruoli consigliati in Informazioni sui service account.
Utilizza questo comando per controllare i ruoli assegnati a un account di servizio:
```
gcloud projects get-iam-policy $PROJECT_ID  \
    --flatten="bindings[].members" \
    --format='table(bindings.role)' \
    --filter="SERVICE_ACCOUNT_NAME"
```
Prendi nota di quale account di servizio personalizzato corrisponde a ogni service account IAM elencato nell'elenco precedente.

Crea un file di configurazione delle credenziali per ogni account di servizio IAM nell'elenco precedente.

WIF: secrets

Questo approccio utilizza le configurazioni delle credenziali archiviate nei secret di Kubernetes. Quando crei il file di override nel passaggio 7: crea gli override, fornisci il nome del secret per ogni account di servizio con la proprietà serviceAccountRef o envs.serviceAccountRefs.

Crea i file di configurazione delle credenziali

Produzione

Devi creare i file di configurazione delle credenziali per i seguenti service account:

apigee-cassandra
apigee-mart
apigee-metrics
apigee-mint-task-scheduler Se utilizzi la monetizzazione per Apigee Hybrid.
apigee-runtime
apigee-synchronizer
apigee-udca

Crea una directory per i file di configurazione delle credenziali. La directory può avere qualsiasi nome. Per questa procedura, la directory è denominata credential-configurations:
```
mkdir $APIGEE_HELM_CHARTS_HOME/credential-configurations
```

Crea il file di configurazione delle credenziali per 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

Dove:

PROJECT_NUMBER: Il numero di progetto del progetto contenente il pool di identità del workload. Deve essere il numero di progetto anziché l'ID progetto.
POOL_ID: l'ID del pool di identità del workload
WORKLOAD_PROVIDER_ID: l'ID del fornitore del pool di identità del workload

Importante: credential-source-type deve essere impostato su text.

Crea il file di configurazione delle credenziali per 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

Crea il file di configurazione delle credenziali per 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

Crea il file di configurazione delle credenziali per 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

Crea il file di configurazione delle credenziali per 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

Crea il file di configurazione delle credenziali per 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

Crea il file di configurazione delle credenziali per 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 utilizzi la monetizzazione per Apigee hybrid, devi anche creare il file di configurazione delle credenziali per 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:non creare un file di configurazione delle credenziali per l'account di servizio apigee-logger.

Non di produzione

Crea una directory per il file di configurazione delle credenziali. La directory può avere qualsiasi nome. Per questa procedura, la directory è denominata credential-configurations:
```
mkdir $APIGEE_HELM_CHARTS_HOME/credential-configurations
```
Crea il file di configurazione delle credenziali per il account di servizio apigee-non-prod nella directory credential-configurations con questo 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
```
Dove:
- PROJECT_NUMBER: Il numero di progetto del progetto contenente il pool di identità del workload. Deve essere il numero di progetto anziché l'ID progetto.
- POOL_ID: l'ID del pool di identità del workload
- WORKLOAD_PROVIDER_ID: l'ID del fornitore del pool di identità del workload
Importante: credential-source-type deve essere impostato su text.

Crea i secret Kubernetes

Crea i secret Kubernetes per archiviare i file di configurazione delle credenziali per ogni account di servizio.

Il comando kubectl create secret nei seguenti esempi di codice ha la struttura:

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

Produzione

Crea il file secret per 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

Crea il file secret per 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

Crea il file secret per 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

Crea il file secret per 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

Crea il file secret per 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

Crea il file secret per 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

Crea il file secret per 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 utilizzi la monetizzazione per Apigee hybrid, crea il file secret per 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

Crea il file secret per apigee-non-prod:

Non di produzione

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

Questo approccio utilizza i file di configurazione delle credenziali al posto dei file di chiavi del account di servizio Google. Quando crei il file di override nel passaggio 7: crea gli override, fornisci il percorso del file di configurazione delle credenziali per ogni proprietà serviceAccountPath o envs.serviceAccountPaths.

Produzione

Devi creare i file di configurazione delle credenziali nelle directory dei grafici corrispondenti:

Service account	Directory dei grafici Helm di Apigee
`apigee-cassandra`	`apigee-datastore/`
`apigee-mart`	`apigee-org/`
`apigee-metrics`	`apigee-telemetry/`
`apigee-mint-task-scheduler` (se utilizzi la monetizzazione per Apigee hybrid)	`apigee-org/`
`apigee-runtime`	`apigee-env/`
`apigee-synchronizer`	`apigee-env/`
`apigee-udca`	`apigee-org/` `apigee-env/`
`apigee-watcher`	`apigee-org/`

Crea i file di configurazione delle credenziali con i seguenti comandi:

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

Dove:

PROJECT_NUMBER: Il numero di progetto del progetto contenente il pool di identità del workload. Deve essere il numero di progetto anziché l'ID progetto.
POOL_ID: l'ID del pool di identità del workload
WORKLOAD_PROVIDER_ID: l'ID del fornitore del pool di identità del workload

Importante: credential-source-type deve essere impostato su 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:

Il account di servizio apigee-udca viene utilizzato sia dal grafico apigee-org che da quello apigee-env.

Crea il file di configurazione delle credenziali nella directory del grafico 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

Copia il file di configurazione delle credenziali nella directory del grafico 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 utilizzi href="monetization-for-hybrid">Monetizzazione per Apigee hybrid, devi anche creare il file di configurazione delle credenziali per 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:non creare un file di configurazione delle credenziali per l'account di servizio apigee-logger.

Non di produzione

Dovrai creare il file di configurazione delle credenziali e copiarlo nelle directory dei grafici corrispondenti:

Service account	Grafico Helm di Apigee
`apigee-non-prod`	`apigee-datastore/` `apigee-telemetry/` `apigee-org/` `apigee-env/`

Crea il file di configurazione delle credenziali nella directory del grafico apigee-datastore con il seguente 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
```
Dove:
- PROJECT_NUMBER: Il numero di progetto del progetto contenente il pool di identità del workload. Deve essere il numero di progetto anziché l'ID progetto.
- POOL_ID: l'ID del pool di identità del workload
- WORKLOAD_PROVIDER_ID: l'ID del fornitore del pool di identità del workload
Importante: credential-source-type deve essere impostato su text.

Copia il file di configurazione delle credenziali nella directory dei grafici 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

Questo approccio utilizza le configurazioni delle credenziali archiviate in un gestore dei secret esterno, Hashicorp Vault. Quando crei il file di override nel passaggio 7: crea gli override, fornisci i secret del vault a livello di organizzazione e ambiente con le proprietà serviceAccountSecretProviderClass o envs.serviceAccountSecretProviderClass.

Crea i file di configurazione delle credenziali

Produzione

Devi creare i file di configurazione delle credenziali per i seguenti service account:

apigee-cassandra
apigee-mart
apigee-metrics
apigee-mint-task-scheduler (se utilizzi la monetizzazione per Apigee hybrid)
apigee-runtime
apigee-synchronizer
apigee-udca

Crea una directory per i file di configurazione delle credenziali. La directory può avere qualsiasi nome. Per questa procedura, la directory è denominata credential-configurations:
```
mkdir $APIGEE_HELM_CHARTS_HOME/credential-configurations
```

Crea il file di configurazione delle credenziali per 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

Dove:

PROJECT_NUMBER: Il numero di progetto del progetto contenente il pool di identità del workload. Deve essere il numero di progetto anziché l'ID progetto.
POOL_ID: l'ID del pool di identità del workload
WORKLOAD_PROVIDER_ID: l'ID del fornitore del pool di identità del workload

Importante: credential-source-type deve essere impostato su text.

Crea il file di configurazione delle credenziali per 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

Crea il file di configurazione delle credenziali per 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

Crea il file di configurazione delle credenziali per 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

Crea il file di configurazione delle credenziali per 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

Crea il file di configurazione delle credenziali per 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

Crea il file di configurazione delle credenziali per 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 utilizzi la monetizzazione per Apigee hybrid, devi anche creare il file di configurazione delle credenziali per 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:non creare un file di configurazione delle credenziali per l'account di servizio apigee-logger.

Non di produzione

Crea una directory per il file di configurazione delle credenziali. La directory può avere qualsiasi nome. Per questa procedura, la directory è denominata credential-configurations:
```
mkdir $APIGEE_HELM_CHARTS_HOME/credential-configurations
```
Crea il file di configurazione delle credenziali per il account di servizio apigee-non-prod nella directory credential-configurations con questo 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
```
Dove:
- PROJECT_NUMBER: Il numero di progetto del progetto contenente il pool di identità del workload. Deve essere il numero di progetto anziché l'ID progetto.
  Suggerimento:puoi trovare il numero di progetto con il seguente comando:
```
gcloud projects describe $PROJECT_ID --format="value(projectNumber)"
```
  "
- POOL_ID: l'ID del pool di identità del workload
- WORKLOAD_PROVIDER_ID: l'ID del fornitore del pool di identità del workload
Importante: credential-source-type deve essere impostato su text.

Installa il driver CSI e il provider Vault

Consulta Piattaforme e versioni supportate di Apigee hybrid per le versioni minime dei driver CSI supportate da Apigee hybrid.

Crea secret, policy e ruoli Vault

Utilizza l'interfaccia utente o le API di Vault per creare secret e concedere autorizzazioni agli account di servizio Kubernetes utilizzati da Apigee Hybrid per leggere questi secret.

Crea i secret specifici dell'organizzazione e dell'ambiente nel seguente formato:

Chiave segreta Secret Data

Chiave segreta	Secret Data
secret/data/apigee/orgsakeys	{ "cassandraBackup": "*", "cassandraRestore": "", "connectAgent": "", "logger": "", "mart": "", "metrics": "", "mint": "", "udca": "", "watcher": "" } Nota**:`mint` è richiesto solo se utilizzi la monetizzazione per Apigee hybrid (v1.15.1 e versioni successive).
secret/data/apigee/envsakeys-`ENV_NAME`	{ "runtime": "*", "synchronizer": "", "udca": "**". }

secret/data/apigee/orgsakeys

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

Nota:mint è richiesto solo se utilizzi la monetizzazione per Apigee hybrid (v1.15.1 e versioni successive).

secret/data/apigee/envsakeys-ENV_NAME

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

Produzione

Sostituisci "***" in ogni coppia con i contenuti del file di configurazione delle credenziali per il account di servizio Google corrispondente al componente Apigee. apigee-cassandra-backup e apigee-cassandra-restore utilizzano entrambi il account di servizio apigee-cassandra. Ad esempio:

{
  "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":...
...
}

Non di produzione

Sostituisci "***" in ogni coppia con i contenuti del file di configurazione delle credenziali per il account di servizio apigee-non-prod. apigee-cassandra-backup e apigee-cassandra-restore utilizzano entrambi il account di servizio apigee-cassandra. Ad esempio:

{
  "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":...
...
}

Concedi l'accesso al secret dell'organizzazione. Crea un file di testo denominato orgsakeys-auth-policy.txt con i seguenti contenuti:
```
path "secret/data/apigee/orgsakeys" {
  capabilities = ["read"]
}
```
In Vault, crea una policy che conceda l'accesso al secret dell'organizzazione:
```
vault policy write apigee-orgsakeys-auth orgsakeys-auth-policy.txt
```
Per ogni ambiente, crea un file di testo denominato envsakeys-ENV_NAME-auth-policy.txt con i seguenti contenuti:
```
path "secret/data/apigee/envsakeys-ENV_NAME" {
  capabilities = ["read"]
}
```
Ripeti questo passaggio per ogni ambiente.
In Vault, crea una policy che conceda l'accesso al secret dell'ambiente:
```
vault policy write apigee-envsakeys-ENV_NAME-auth envsakeys-ENV_NAME-auth-policy.txt
```
Ripeti questo passaggio per ogni ambiente.

Crea uno script denominato generate-encoded-sas.sh con i seguenti contenuti:

# 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:rimuovi apigee-mint-task-scheduler-${ORG_ENCODE} se non utilizzi la monetizzazione per Apigee hybrid.

Esegui lo script per generare l'elenco dei nomi dei account di servizio a cui associare il criterio:

./generate-encoded-sas.sh

L'output deve essere un elenco di nomi di account di servizio Kubernetes separati da virgole, simile al seguente esempio:

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

L'elenco dei nomi dei servizi org dell'esempio precedente:

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

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

prod environment:

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

Utilizzando il criterio, crea un ruolo Vault che associa gli account di servizio Apigee specifici dell'organizzazione:

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

Per ogni ambiente, crea un ruolo Vault per le chiavi del account di servizio:

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

Ripeti questo passaggio per ogni ambiente.

Crea `SecretProviderClass` oggetti

Service account	Nomi dei file secret previsti
Backup di Cassandra	`cassandraBackup`
Ripristino di Cassandra	`cassandraRestore`
Agente Connect	`connectAgent`
MART	`mart`
Metriche	`metrics`
Monetizzazione (se utilizzi la monetizzazione per Apigee hybrid)	`mint`
Runtime	`runtime`
Sincronizzatore	`synchronizer`
UDCA	`udca`
Watcher	`watcher`

Utilizza il seguente modello SecretProviderClass per configurare questa risorsa per i secret specifici dell'organizzazione:

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:rimuovi le righe objectName: "mint" se non utilizzi la monetizzazione per Apigee Hybrid.

Salva il modello in un file denominato spc-org.yaml.

Applica SecretProviderClass specifico dell'organizzazione allo spazio dei nomi apigee:
```
kubectl -n $APIGEE_NAMESPACE apply -f spc-org.yaml
```

Per ogni ambiente, utilizza il seguente modello SecretProviderClass per configurare questa risorsa per i secret specifici dell'ambiente. Ripeti questo passaggio per ogni 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: ""

Salva il modello in un file denominato spc-env-ENV_NAME.yaml.

Per ogni ambiente, applica SecretProviderClass specifico per l'ambiente allo spazio dei nomi Apigee:
```
kubectl -n $APIGEE_NAMESPACE apply -f spc-env-ENV_NAME.yaml
```
Ripeti questo passaggio per ogni ambiente.

Passaggio successivo

1 2 3 4 5 (NEXT) Step 6: Create TLS certificates 7 8 9 10 11

Passaggio 5: configura l'autenticazione del account di servizio Mantieni tutto organizzato con le raccolte Salva e classifica i contenuti in base alle tue preferenze.

Panoramica

Secret Kubernetes

Account di servizio

Produzione

Non di produzione

Crea secret Kubernetes

Produzione

Non di produzione

File JSON

Vault

Configurare l'archiviazione dei secret del account di servizio in Vault

Installa il driver CSI e il provider Vault

Crea secret, policy e ruoli Vault

Crea SecretProviderClass oggetti

WIF per GKE

Preparati a configurare Workload Identity Federation for GKE

Cluster a livello di regione

Cluster di zona

Cluster a livello di regione

Cluster di zona

Cluster a livello di regione

Cluster di zona

Cluster a livello di regione

Cluster di zona

WIF su altre piattaforme

Configura il cluster in modo che utilizzi la federazione delle identità per i workload.

Console

Riga di comando

Ruoli obbligatori

AKS

EKS

Altri strumenti Kubernetes

Pubblicamente accessibile

Non accessibile pubblicamente

Crea i file di configurazione delle credenziali

Produzione

Non di produzione

WIF: secrets

Crea i file di configurazione delle credenziali

Produzione

Non di produzione

Crea i secret Kubernetes

Produzione

Non di produzione

WIF: file

Produzione

Non di produzione

WIF: Vault

Crea i file di configurazione delle credenziali

Produzione

Non di produzione

Installa il driver CSI e il provider Vault

Crea secret, policy e ruoli Vault

Produzione

Non di produzione

Crea SecretProviderClass oggetti

Passaggio successivo

Passaggio 5: configura l'autenticazione del account di servizio

Crea `SecretProviderClass` oggetti

Crea `SecretProviderClass` oggetti