Attivazione della federazione delle identità per i carichi di lavoro su AKS ed EKS

Questo argomento spiega come attivare Workload Identity Federation per le installazioni di Apigee hybrid sulle piattaforme AKS ed EKS.

Per le installazioni su GKE, segui le istruzioni riportate in Abilitazione di Workload Identity su GKE.

Panoramica

La federazione delle identità per i carichi di lavoro consente alle applicazioni in esecuzione all'esterno di Google Cloud di rubare l'identità di un account di servizio della piattaforma Google Cloud utilizzando le credenziali di un provider di identità esterno.

L'utilizzo della federazione delle identità per i workload può aiutarti a migliorare la sicurezza consentendo alle applicazioni di utilizzare i meccanismi di autenticazione forniti dall'ambiente esterno e può aiutarti a sostituire le chiavi degli account di servizio.

Per una panoramica, consulta le best practice per l'utilizzo della federazione delle identità di lavoro.

Configurare la federazione delle identità per i carichi di lavoro

Per utilizzare la federazione delle identità per i carichi di lavoro con Apigee hybrid, configura prima il cluster e poi applica la funzionalità all'installazione di Apigee hybrid.

Prima di iniziare

Queste istruzioni presuppongono che tu abbia già configurato l'installazione di Apigee hybrid. Gli account di servizio IAM e gli account di servizio Kubernetes vengono creati durante l'installazione iniziale. Consulta la sezione Panoramica per una panoramica dell'installazione di Apigee hybrid.

Per le installazioni su AKS, assicurati di aver attivato l'emittente OpenID Connect (OIDC). Devi attivare questa funzionalità in modo che la federazione delle identità per i workload 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 carichi di lavoro.

  1. Verifica che la configurazione gcloud corrente sia impostata sull'ID progetto Google Cloud con il seguente comando: 
    gcloud config get project

    2. Se necessario, imposta la configurazione attuale di gcloud:

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

    Enable the API

    Riga di comando

    Abilita l'API con il seguente comando: 

    gcloud services enable sts.googleapis.com --project PROJECT_ID
  3. Crea il provider e il pool di identità del workload.

    Ruoli obbligatori

    Per ottenere le autorizzazioni necessarie per configurare la federazione di Workload Identity, chiedi all'amministratore di concederti i seguenti ruoli IAM nel progetto:

    Per saperne di più sulla concessione dei ruoli, consulta Gestire 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 dovresti concedere ruoli di base in un ambiente di produzione, ma puoi farlo in un ambiente di sviluppo o di 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 NAME -g RESOURCE_GROUP --query "oidcIssuerProfile.issuerUrl" -otsv

      Sostituisci quanto segue:

      • NAME: il nome del cluster.
      • RESOURCE_GROUP: il gruppo di risorse del cluster.

      Il comando restituisce l'URL dell'emittente. L'URL dell'emittente ti servirà in uno dei passaggi successivi.

      Se il comando non restituisce un URL emittente, verifica di aver attivato la funzionalità Emittente OIDC.

      EKS

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

      Sostituisci NAME con il nome del cluster.

      Il comando restituisce l'URL dell'emittente. L'URL dell'emittente è necessario in uno dei passaggi successivi.

      Altri Kubernetes

      1. Connettiti al tuo 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: 
      kubectl get --raw /openid/v1/jwks > cluster-jwks.json

      Per verificare se il tuo provider OIDC è disponibile pubblicamente, dovresti essere in grado di accedere all'URL del provider 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 scelto. 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 del pool di identità del workload. Scegli il comando per creare il provider a seconda che l'emittente OIDC sia accessibile pubblicamente o non accessibile pubblicamente:

      Pubblicamente accessibile

      Se l'emittente OIDC è accessibile pubblicamente, crea il provider 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 al pubblico

      Se l'emittente OIDC non è accessibile pubblicamente, crea il provider 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"

      Sostituisci quanto segue:

      • WORKLOAD_PROVIDER_ID: un ID fornitore del pool di identità del workload scelto da te.
      • POOL_ID: l'ID 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:

  1. Elenca gli account di servizio IAM (chiamati anche "account di servizio Google") con il seguente comando: 
    gcloud iam service-accounts list --project PROJECT_ID

    Dovrai creare i file di configurazione delle credenziali per i seguenti account di servizio 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

    Non prod

    Per gli ambienti non di produzione:

    DISPLAY NAME         EMAIL                                                      DISABLED
apigee-non-prod      apigee-non-prod@my_project_id.iam.gserviceaccount.com      False
  2. Crea un file di configurazione delle credenziali per ogni account di servizio IAM nell'elenco precedente. Per configurare Apigee hybrid in modo che utilizzi la federazione delle identità di lavoro, sono necessari questi file di configurazione delle credenziali:

    Codice 

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

    Esempio 

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

    Dove:

    • PROJECT_NUMBER: il numero del progetto contenente il pool di identità del workload. Deve essere il numero del progetto anziché l'ID progetto.
    • POOL_ID: l'ID del pool di identità del workload
    • WORKLOAD_PROVIDER_ID: l'ID del provider del pool di identità del workload
    • SERVICE_ACCOUNT_EMAIL: indirizzo email dell'account di servizio, se hai configurato il tuo account di servizio Kubernetes per utilizzare l'usurpazione dell'identità dell'account di servizio IAM.

    Il file di configurazione delle credenziali consente alle [librerie client Cloud](/apis/docs/cloud-client-libraries), all'interfaccia a riga di comando gcloud e a Terraform di determinare quanto segue:

    • Da dove ottenere le credenziali esterne
    • Quale provider e pool di identità per i carichi di lavoro utilizzare
    • Quale account di servizio rappresentare

    Configurare Apigee hybrid per utilizzare la federazione delle identità per i carichi di lavoro

    1. Copia o sposta ogni file di output (SERVICE_ACCOUNT_NAME-credential-configuration.json) nelle seguenti directory dei grafici (o nelle relative sottodirectory). Si tratta dei file che hai creato nel passaggio Creare i file di configurazione delle credenziali.

      Produzione

      Service account Directory dei grafici Helm di Apigee
      apigee-cassandra apigee-datastore/
      apigee-mart apigee-org/
      apigee-metrics apigee-telemetry/
      apigee-runtime apigee-env/
      apigee-synchronizer apigee-env/
      apigee-udca apigee-org/
      apigee-env/
      apigee-watcher apigee-org/

      Non prod

      Service account Grafico Helm di Apigee
      apigee-non-prod apigee-datastore/
      apigee-telemetry/
      apigee-org/
      apigee-env/
    2. Apporta le seguenti modifiche globali al file delle sostituzioni del cluster:

      Codice

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

      Esempio

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

      Dove: AUDIENCE è il pubblico consentito del provider di identità del workload. Puoi trovare il valore cercando il termine audience: in uno dei file di configurazione delle credenziali. Il valore del segmento di pubblico è lo stesso in ogni file di configurazione delle credenziali.

      Ad esempio, nel seguente file apigee-udca-credential-configuration.json di esempio:

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

      Il valore del segmento di pubblico è //iam.googleapis.com/projects/123123123123/locations/global/workloadIdentityPools/my-wi-pool/providers/my-wi-provider.

    3. Configura le sostituzioni per ogni componente utilizzando la federazione delle identità per i carichi di lavoro. Seleziona le istruzioni per i file di certificati, i secret di Kubernetes o Vault in base alla tua installazione.

      File del certificato

      Sostituisci il valore di serviceAccountPath con il file di origine delle credenziali per l'account di servizio IAM corrispondente. Deve essere il percorso relativo alla directory del grafico. Ad esempio:

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

mart:
  serviceAccountPath: mart-credential-configuration.json

connectAgent:
  serviceAccountPath: mart-credential-configuration.json

metrics:
  serviceAccountPath: metrics-credential-configuration.json

udca:
  serviceAccountPath: UDCA_SERVICE_ACCOUNT_FILEPATH

watcher:
  serviceAccountPath: WATCHER_SERVICE_ACCOUNT_FILEPATH

      Secret K8s

      1. Crea un nuovo secret Kubernetes utilizzando il file di origine delle credenziali per ogni file di configurazione delle credenziali. 
        kubectl create secret -n APIGEE_NAMESPACE generic SECRET_NAME --from-file="client_secret.json=CREDENTIAL_CONFIGURATION_FILE"

        Ad esempio:

        kubectl create secret -n apigee generic udca-workoad-identity-secret --from-file="client_secret.json=./apigee-udca-credential-configuration.json"
      2. Sostituisci il valore di serviceAccountRef con il nuovo secret. Ad esempio: 
        udca:
  serviceAccountRef: udca-workoad-identity-secret

      Vault

      Aggiorna la chiave dell'account di servizio SAKEY per ogni account di servizio in Vault con il file di origine delle credenziali corrispondente. La procedura è simile per tutti i componenti. Ad esempio, per UDCA: 

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

      Per ulteriori informazioni, visita la pagina Storing service account keys in Hashicorp Vault.
    4. Applica le modifiche a ogni componente interessato con il comando helm upgrade:

      Se hai aggiornato le chiavi del service account di Vault, aggiorna il grafico apigee-operator. 

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

      Aggiorna gli altri grafici interessati nel seguente ordine: 

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

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

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

      Aggiorna il grafico apigee-env per ogni ambiente, sostituendo ogni volta $ENV_RELEASE_NAME e ENV_NAME: 

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

      Consulta la documentazione di riferimento di Helm per Apigee hybrid per un elenco dei componenti e dei relativi grafici.

    Concedi l'accesso agli account di servizio Kubernetes

    1. Elenca gli account di servizio Kubernetes con il seguente comando: 
      kubectl get sa -n APIGEE_NAMESPACE
    2. Concedi agli account di servizio Kubernetes l'accesso per rubare l'identità degli account di servizio IAM associati, come mostrato nella tabella seguente. La tabella mostra i nomi degli account di servizio IAM Apigee predefiniti. Se utilizzi nomi di account di servizio personalizzati, utilizza gli account di servizio IAM corrispondenti:
      Account di servizio Kubernetes Service account IAM
      Account di servizio Kubernetes a livello di organizzazione
      apigee-connect-agent-ORG_NAME-ORG_HASH_ID apigee-mart
      apigee-mart-ORG_NAME-ORG_HASH_ID apigee-mart
      apigee-metrics-apigee-telemetry apigee-metrics
      apigee-open-telemetry-collector-apigee-telemetry apigee-metrics
      apigee-udca-ORG_NAME-ORG_HASH_ID apigee-udca
      apigee-watcher-ORG_NAME-ORG_HASH_ID apigee-watcher
      Account di servizio Kubernetes a livello di ambiente
      apigee-runtime-ORG_NAME-ENV_NAME-ENV_HASH_ID apigee-runtime
      apigee-synchronizer-ORG_NAME-ENV_NAME-ENV_HASH_ID apigee-synchronizer
      Backup e ripristino di Cassandra (se abilitato)
      apigee-cassandra-backup-sa apigee-cassandra
      apigee-cassandra-restore-sa apigee-cassandra

      Dove:

      • ORG_NAME: i primi 15 caratteri del nome della tua organizzazione.
      • ORG_HASH_ID: un ID hash univoco del nome completo dell'organizzazione.
      • ENV_NAME: i primi 15 caratteri del nome dell'ambiente.
      • ENV_HASH_ID: un ID hash univoco dei nomi dell'organizzazione e dell'ambiente.

      Ad esempio:

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

      Concedi a ogni account di servizio Kubernetes l'accesso per rubare l'identità dell'account di servizio IAM appropriato con il seguente comando:

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

      Dove:

      • IAM_SA_NAME: il nome dell'account di servizio.
      • PROJECT_ID: l'ID del progetto associato all'organizzazione Apigee.
      • PROJECT_NUMBER: il numero di progetto del progetto in cui hai creato il pool di identità del workload.
      • POOL_ID: l'ID del pool di identità del workload.
      • MAPPED_SUBJECT: l'account di servizio Kubernetes dal claim nel token di identità che hai mappato a google.subject. Ad esempio, se hai mappato google.subject=assertions.sub e il tuo token ID contiene "sub": "system:serviceaccount:default:my-kubernetes-serviceaccount", allora MAPPED_SUBJECT è system:serviceaccount:default:my-kubernetes-serviceaccount.

    Per ulteriori informazioni sulla federazione delle identità per i workload e sulle best practice, consulta Best practice per l'utilizzo della federazione delle identità per i workload.