Accedere ai cluster Google Kubernetes Engine privati dai pool privati di Cloud Build utilizzando Identity Service per GKE

---

Questo tutorial descrive come accedere al piano di controllo di un cluster Google Kubernetes Engine (GKE) privato utilizzando i pool privati di Cloud Build. Questo accesso ti consente di utilizzare Cloud Build per eseguire il deployment di applicazioni e gestire le risorse su un cluster GKE privato. Questo tutorial è rivolto ad amministratori della piattaforma, amministratori di cluster e sviluppatori. Si presume che tu abbia dimestichezza con GKE, Cloud Build, OpenID Connect e lo strumento a riga di comando gcloud.

I pool privati di Cloud Build e i piani di controllo dei cluster GKE vengono eseguiti entrambi nelle reti Virtual Private Cloud (VPC) di proprietà di Google. Queste reti VPC sono in peering con la tua rete VPC su Google Cloud. Tuttavia, il peering di rete VPC non supporta il peering transitivo, il che può essere una limitazione quando utilizzi i pool privati di Cloud Build. Questo tutorial presenta una soluzione che utilizza Identity Service per GKE per consentire ai worker di un pool privato di Cloud Build di accedere al piano di controllo di un cluster GKE privato.

Panoramica dell'architettura

Identity Service for GKE è un proxy di autenticazione per i piani di controllo dei cluster GKE. Esegue il proxy delle richieste al server API e convalida i token ID emessi dai provider di identità OpenID Connect (OIDC). Dopo aver convalidato correttamente un token ID, il proxy aggiunge le intestazioni HTTP di rappresentazione dell'utente alla richiesta originale e la inoltra al server API. Il proxy viene eseguito come account di servizio Kubernetes che dispone delle autorizzazioni per rubare l'identità di utenti e gruppi.

Il proxy Identity Service per GKE viene eseguito come pod sui nodi del cluster. Un servizio Kubernetes di tipo LoadBalancer espone il proxy all'esterno del cluster. Se Identity Service for GKE è abilitato su un cluster privato, il programma di installazione aggiunge un'annotazione al servizio Kubernetes per eseguire il provisioning di un bilanciatore del carico di rete passthrough interno. Poiché il proxy viene eseguito sui nodi del cluster nella rete VPC, è possibile accedervi tramite il bilanciatore del carico tramite una connessione di peering di rete VPC, ad esempio da un pool privato Cloud Build.

Puoi configurare Google come provider di identità OpenID Connect in Identity Service for GKE perché il sistema di autenticazione OAuth 2.0 di Google è conforme alla specifica OpenID Connect. Per ottenere token ID per un account di servizio Google, puoi utilizzare il metodo generateIdToken dell'API Service Account Credentials. I token di identità vengono emessi e firmati da Google.

Nel complesso, questa soluzione consente di accedere al piano di controllo del cluster GKE privato utilizzando il proxy Identity Service for GKE. Le build eseguite in un pool privato di Cloud Build si connettono al proxy tramite una connessione di peering di rete VPC. La build in esecuzione nel pool privato di Cloud Build viene eseguita come account di servizio Google. Questo account di servizio Google può ottenere un token ID per l'autenticazione al proxy dall'API Credenziali account di servizio.

Il seguente diagramma mostra l'architettura descritta nel testo precedente:

Tutte le comunicazioni in questa soluzione avvengono nello spazio degli indirizzi IP interni. I worker nel pool privato non richiedono connettività a internet pubblica.

Le autorizzazioni Identity and Access Management (IAM) concesse agli account utente e agli account di servizio Google non vengono applicate quando si autenticano utilizzando Identity Service per GKE. Utilizza invece il controllo degli accessi basato su ruoli (RBAC) di Kubernetes per gestire le autorizzazioni del cluster per questi account.

Prima di iniziare

1. Sign in to your Google Cloud account. If you're new to Google Cloud, create an account to evaluate how our products perform in real-world scenarios. New customers also get $300 in free credits to run, test, and deploy workloads.
2. Install the Google Cloud CLI.

3. To initialize the gcloud CLI, run the following command:

   gcloud init

4. Create or select a Google Cloud project.

   Note: If you don't plan to keep the resources that you create in this procedure, create a project instead of selecting an existing project. After you finish these steps, you can delete the project, removing all resources associated with the project.

   • Create a Google Cloud project:

     gcloud projects create PROJECT_ID

     Replace PROJECT_ID with a name for the Google Cloud project you are creating.

   • Select the Google Cloud project that you created:

     gcloud config set project PROJECT_ID

     Replace PROJECT_ID with your Google Cloud project name.

5. Make sure that billing is enabled for your Google Cloud project.

6. Enable the Cloud Build, GKE, Identity-Aware Proxy (IAP), and Service Networking APIs APIs:

   gcloud services enable cloudbuild.googleapis.com container.googleapis.com iap.googleapis.com servicenetworking.googleapis.com

7. Install the Google Cloud CLI.

8. To initialize the gcloud CLI, run the following command:

   gcloud init

9. Create or select a Google Cloud project.

   Note: If you don't plan to keep the resources that you create in this procedure, create a project instead of selecting an existing project. After you finish these steps, you can delete the project, removing all resources associated with the project.

   • Create a Google Cloud project:

     gcloud projects create PROJECT_ID

     Replace PROJECT_ID with a name for the Google Cloud project you are creating.

   • Select the Google Cloud project that you created:

     gcloud config set project PROJECT_ID

     Replace PROJECT_ID with your Google Cloud project name.

10. Make sure that billing is enabled for your Google Cloud project.

11. Enable the Cloud Build, GKE, Identity-Aware Proxy (IAP), and Service Networking APIs APIs:

    gcloud services enable cloudbuild.googleapis.com container.googleapis.com iap.googleapis.com servicenetworking.googleapis.com

Crea un cluster GKE privato

1. In Cloud Shell, crea un cluster GKE senza accesso dei client all'endpoint pubblico del piano di controllo e su cui è installato Identity Service per GKE:

   gcloud container clusters create CLUSTER  \
     --enable-identity-service \
     --enable-ip-alias \
     --enable-master-authorized-networks \
     --enable-private-endpoint \
     --enable-private-nodes \
     --master-ipv4-cidr CONTROL_PANE_CIDR \
     --network NETWORK\
     --release-channel regular \
     --scopes cloud-platform \
     --subnetwork SUBNET \
     --tags NODE_TAGS \
     --workload-pool PROJECT_ID.svc.id.goog \
     --zone ZONE
   

   Sostituisci quanto segue:

   • CLUSTER: il nome del cluster. Per questo tutorial, utilizza private-cluster.
   • CONTROL_PANE_CIDR: l'intervallo di indirizzi IP del control plane. Deve avere un prefisso /28. Per questo tutorial, puoi utilizzare 172.16.0.32/28.
   • NETWORK: la rete VPC a cui si connette il piano di controllo. Per questo tutorial, utilizza default.
   • SUBNET: la sottorete a cui si connette il piano di controllo del cluster GKE. La subnet deve appartenere alla rete VPC specificata da NETWORK. Per questo tutorial, utilizza default.
   • NODE_TAGS: un elenco separato da virgole di tag di rete da applicare ai nodi. Per questo tutorial, utilizza private-cluster-node.
   • PROJECT_ID: il tuo Google Cloud ID progetto.
   • ZONE: la zona per il cluster GKE. Per questo tutorial, utilizza us-central1-f.

   Tieni presente quanto segue sul comando:

   • Il flag --enable-identity-service abilita Identity Service for GKE sul cluster. Nel tuo ambiente, puoi abilitare Identity Service per GKE su un cluster esistente.

   • Il flag --enable-private-endpoint configura il control plane in modo che sia accessibile solo utilizzando indirizzi IP interni.

   • Il flag --enable-private-nodes configura i nodi del cluster in modo che abbiano solo indirizzi IP interni.

   • I flag --enable-master-authorized-networks e --enable-private-nodes consentono di accedere al server API solo dalle reti private specificate dal flag --network.

   • Il flag facoltativo --workload-pool abilita la federazione delle identità per i carichi di lavoro per GKE. Non è necessario per questo tutorial.

2. Aggiungi una regola firewall che consenta al control plane del cluster GKE di connettersi al webhook di ammissione con convalida per le risorse ClientConfig:

   gcloud compute firewall-rules create allow-control-plane-clientconfig-webhook \
     --allow tcp:15000 \
     --network NETWORK\
     --source-ranges CONTROL_PANE_CIDR\
     --target-tags NODE_TAGS
   

   ClientConfig è un tipo di risorsa personalizzata (CRD) Kubernetes utilizzato da Identity Service per GKE per configurare la modalità di interazione con i provider di identità.

Registra Identity Service for GKE come applicazione client OAuth 2.0

In questa sezione registri Identity Service per GKE come applicazione client utilizzando il sistema di autenticazione OAuth 2.0 di Google.

1. Apri la pagina Credenziali nella console Google Cloud.

   Apri la pagina Credenziali

2. Fai clic su Crea credenziali.

3. Seleziona ID client OAuth.

   Se la schermata per il consenso non è già stata configurata per il progetto Google Cloud, fai clic su Configura la schermata per il consenso. Segui la documentazione sulla configurazione della schermata del consenso. Per questo tutorial, imposta i seguenti valori:

   • Tipo di utente può essere Interno o Esterno. Per questo tutorial, puoi selezionare Interno.
   • I valori di Nome dell'app, Email per l'assistenza utente e Dati di contatto dello sviluppatore sono obbligatori e possono essere di qualsiasi valore.
   • Per questo tutorial non è necessario aggiungere ambiti.

   Al termine della configurazione della schermata del consenso, fai clic su Torna alla dashboard e poi ricomincia dal passaggio 1 della procedura corrente.

4. Nell'elenco Tipo di applicazione, seleziona Applicazione web.

5. Nel campo Nome, inserisci un nome per l'ID client. Per questo tutorial, utilizza Identity Service for GKE.

6. Fai clic su Crea.

   Viene visualizzata una finestra di dialogo. Copia il valore di Il tuo ID client, ti servirà più avanti in questa procedura.

7. Fai clic su OK per chiudere la finestra di dialogo.

8. In Cloud Shell, crea una directory sotto la tua home directory denominata cloud-build-private-pools-gke-tutorial e poi vai a quella directory:

   mkdir -p ~/cloud-build-private-pools-gke-tutorial cd ~/cloud-build-private-pools-gke-tutorial

9. Nella nuova directory, crea un file YAML denominato client-config-patch.yaml contenente i valori di cui avrai bisogno in un secondo momento per applicare la patch alla risorsa ClientConfig di Identity Service per GKE:

   cat << EOF > client-config-patch.yaml
   spec:
     authentication:
     - name: google-oidc
       oidc:
         clientID: CLIENT_ID
         cloudConsoleRedirectURI: https://console.cloud.google.com/kubernetes/oidc
         extraParams: prompt=consent,access_type=offline
         issuerURI: https://accounts.google.com
         kubectlRedirectURI: http://localhost:10000/callback
         scopes: email
         userClaim: email
         userPrefix: '-'
   EOF
   

   Sostituisci CLIENT_ID con l'ID client OAuth del passaggio precedente.

   Tieni presente quanto segue sulla patch:

   • I token di identità emessi dal sistema di autenticazione OAuth 2.0 di Google contengono un identificatore numerico univoco nell'assert soggetto (sub). L'utilizzo di questo identificatore opaco nelle associazioni di ruoli rende difficile identificare il soggetto di un'associazione di ruoli. Questa patch configura quindi Identity Service per GKE in modo che utilizzi l'assert email dei token ID per identificare gli utenti anziché l'assert secondario predefinito.

   • L'ambito email viene aggiunto in modo che i token ID emessi includano la rivendicazione email.

   • I campi cloudConsoleRedirectURI, extraParams, kubectlRedirectURI e ambiti vengono utilizzati quando gli sviluppatori si autenticano nel cluster utilizzando Identity Service per GKE. Non vengono utilizzati quando gli account di servizio Google si autenticano nel cluster. Il campo kubectlRedirectURI è obbligatorio.

   • Il campo userPrefix è un prefisso per gli utenti che si autenticano utilizzando il provider di identità configurato. Il valore '-' indica che non è presente alcun prefisso.

   • Il campo spec.authentication è un array. Puoi utilizzare più provider di identità OpenID Connect con Identity Service for GKE. Ad esempio, puoi utilizzare Google come provider di identità per autenticare gli account di servizio Google e un provider di identità diverso per autenticare gli sviluppatori.

   Per ulteriori informazioni sui campi di questa configurazione, vedi Utilizzare provider di identità esterni per l'autenticazione in GKE.

Crea un account di servizio Google per configurare Identity Service for GKE

1. In Cloud Shell, crea un account di servizio Google:

   gcloud iam service-accounts create ISG_GSA \
     --display-name "Configure Identity Service for GKE"
   

   Sostituisci ISG_GSA con il nome che vuoi utilizzare per l'account di servizio Google. Per questo tutorial, utilizza identity-service-for-gke.

   Assegna questo account di servizio Google a un'istanza VM Compute Engine per configurare il servizio Identity per il controllo degli accessi basato su ruoli di GKE e Kubernetes sul cluster.

2. Concedi il ruolo Amministratore Kubernetes Engine nel progetto all'account di servizio Google:

   gcloud projects add-iam-policy-binding PROJECT_ID \
     --member serviceAccount:ISG_GSA@PROJECT_ID.iam.gserviceaccount.com \
     --role roles/container.admin
   

   Questo ruolo fornisce le autorizzazioni necessarie per svolgere le seguenti attività in questo tutorial:

   • Configura le impostazioni di Identity Service per GKE sui cluster del progetto.
   • Crea associazioni di ruoli e associazioni di ruoli cluster nel cluster.

Configurare Identity Service for GKE

Per configurare Identity Service per GKE, devi avere accesso al control plane del cluster. In questo tutorial, crei un'istanza VM di Compute Engine per accedere al control plane.

Devi disporre dell'accesso SSH all'istanza VM. Per abilitare l'accesso SSH autenticato e autorizzato dall'esterno della rete VPC all'istanza VM, utilizza l'inoltro TCP con Identity-Aware Proxy (IAP). Questa funzionalità consente l'accesso SSH senza richiedere che l'istanza VM abbia un indirizzo IP pubblico.

1. In Cloud Shell, crea una regola firewall che consenta l'accesso SSH utilizzando il forwarding TCP IAP a qualsiasi istanza VM con il tag di rete ssh-iap:

   gcloud compute firewall-rules create allow-ssh-ingress-from-iap \
     --allow tcp:22 \
     --description "Allow SSH tunneling using Identity-Aware Proxy" \
     --network NETWORK \
     --source-ranges 35.235.240.0/20 \
     --target-tags ssh-iap
   

   L'intervallo di origine contiene gli indirizzi IP utilizzati da IAP per l'inoltro TCP.

2. Crea un'istanza VM Compute Engine nella stessa rete VPC del cluster GKE:

   gcloud compute instances create VM \
     --metadata enable-oslogin=TRUE \
     --network NETWORK \
     --no-address \
     --scopes cloud-platform,userinfo-email \
     --service-account ISG_GSA@PROJECT_ID.iam.gserviceaccount.com \
     --subnet SUBNET  \
     --tags ssh-iap \
     --zone ZONE
   

   Sostituisci VM con il nome che vuoi utilizzare per l'istanza VM. Per questo tutorial, utilizza identity-service-for-gke-configuration.

   Tieni presente quanto segue sul comando riportato sopra:

   • Il flag --service-account associa l'account di servizio Google all'istanza VM.

   • L'ambito cloud-platform è necessario per accedere all'API Service Account Credentials.

   • L'ambito userinfo-email è utile per creare un'istanza VM per la gestione del controllo dell'accesso basato sui ruoli di Kubernetes. È facoltativo per questo tutorial.

   • Il flag --no-address indica che l'istanza VM viene creata senza un indirizzo IP esterno.

   • Il valore facoltativo dei metadati dell'istanza enable-oslogin attiva OS Login nell'istanza VM. L'accesso del sistema operativo consente la gestione dell'accesso SSH alle istanze VM utilizzando IAM.

3. Copia il file patch ClientConfig nell'istanza VM:

   gcloud compute scp client-config-patch.yaml VM:~ --tunnel-through-iap --zone ZONE
   

   Il flag --tunnel-through-iap indica a gcloud di eseguire il tunnel della connessione tramite IAP.

4. Connettiti all'istanza VM tramite SSH:

   gcloud compute ssh VM --tunnel-through-iap --zone ZONE
   

   Esegui il resto dei comandi in questa sezione dalla sessione SSH.

5. Installa lo strumento a riga di comando kubectl e il file binario gke-gcloud-auth-plugin nell'istanza VM:

   sudo apt-get install -y kubectl google-cloud-sdk-gke-gcloud-auth-plugin
   

6. Recupera le credenziali per il cluster GKE:

   export USE_GKE_GCLOUD_AUTH_PLUGIN=True
   gcloud container clusters get-credentials CLUSTER --zone ZONE
   

7. Esegui il patching della risorsa ClientConfig predefinita:

   kubectl patch clientconfig default \
       --namespace kube-public \
       --patch-file client-config-patch.yaml \
       --type merge
   

8. Estrai il campo certificateAuthorityData dalla risorsa ClientConfig predefinita con patch e memorizzalo in un file denominato certificateAuthorityData.pem:

   kubectl get clientconfig default \
        --namespace kube-public \
        --output jsonpath='{.spec.certificateAuthorityData}' \
        | base64 --decode > certificateAuthorityData.pem
   

9. Estrai il campo server dalla risorsa ClientConfig predefinita con patch e salvalo in un file denominato server.txt:

   kubectl get clientconfig default \
        --namespace kube-public \
        --output jsonpath='{.spec.server}' > server.txt
   

10. Esci dalla sessione SSH:

    exit
    

(Facoltativo) Verifica la configurazione del cluster

Prima di procedere, puoi verificare che Identity Service for GKE sia stato configurato correttamente nel cluster. Verifica la configurazione utilizzando l'account di servizio Google associato all'istanza VM per autenticarti al cluster utilizzando Identity Service for GKE.

1. In Cloud Shell, concedi il ruolo Service Account OpenID Connect Identity Token Creator all'account di servizio Google stesso:

   gcloud iam service-accounts add-iam-policy-binding \
     ISG_GSA@PROJECT_ID.iam.gserviceaccount.com \
     --member serviceAccount:ISG_GSA@PROJECT_ID.iam.gserviceaccount.com \
     --role roles/iam.serviceAccountOpenIdTokenCreator
   

   Questo ruolo fornisce l'autorizzazione iam.serviceAccounts.getOpenIdToken necessaria per richiedere token ID per l'account di servizio dall'API Credentials for Service Account.

2. Connettiti all'istanza VM tramite SSH:

   gcloud compute ssh VM --tunnel-through-iap --zone ZONE
   

   Esegui il resto dei comandi in questa sezione dalla sessione SSH.

3. Richiedi un token di accesso OAuth 2.0 dal server di metadati per l'account di servizio Google associato all'istanza VM, utilizzando l'ID client OAuth come claim aud (segmento di pubblico) richiesto:

   ACCESS_TOKEN=$(curl --silent --header "Metadata-Flavor: Google" \
   http://metadata.google.internal/computeMetadata/v1/instance/service-accounts/default/token \
          | python3 -c 'import json, sys; print(json.load(sys.stdin).get("access_token"))')
   

   Il corpo della risposta del server di metadati è un documento JSON. Il comando utilizza uno script Python in linea per estrarre il campo access_token dal corpo della risposta.

4. Richiedi un token ID dall'API Credentials for Service Account per l'account di servizio Google associato all'istanza VM:

   ID_TOKEN=$(curl --silent --request POST \
       --data '{"audience": "CLIENT_ID", "includeEmail": true}' \
       --header "Authorization: Bearer $ACCESS_TOKEN" \
       --header "Content-Type: application/json; charset=utf-8" \
   "https://iamcredentials.googleapis.com/v1/projects/-/serviceAccounts/ISG_GSA@PROJECT_ID.iam.gserviceaccount.com:generateIdToken" \
          | python3 -c 'import json, sys; print(json.load(sys.stdin).get("token"))')
   

   Tieni presente quanto segue sul comando riportato sopra:

   • Il campo audience nel corpo JSON della richiesta specifica l'affermazione aud (segmento di pubblico) richiesta del token ID.
   • Il token di accesso del passaggio precedente viene utilizzato per l'autenticazione all'API.

5. Visualizza le rivendicazioni nel token ID:

   echo $ID_TOKEN \
       | cut -d. -f2 \
       | base64 --decode --ignore-garbage 2> /dev/null \
       | python3 -m json.tool
   

   Verifica che la rivendicazione email contenga l'indirizzo email dell'account di servizio Google.

6. Utilizza il token ID per autenticarti nel piano di controllo utilizzando Identity Service for GKE:

   kubectl get namespaces \
       --certificate-authority certificateAuthorityData.pem \
       --server $(cat server.txt) \
       --token $ID_TOKEN
   

   L'output è simile al seguente:

     Error from server (Forbidden): namespaces is forbidden: User "ISG_GSA@PROJECT_ID.iam.gserviceaccount.com" cannot list resource "namespaces" in API group "" at the cluster scope
   

   Si tratta di un errore previsto. Sebbene al service account Google siano state concesse autorizzazioni IAM sui cluster GKE del progetto, le autorizzazioni IAM non vengono applicate quando esegui l'autenticazione utilizzando Identity Service per GKE. Devi invece configurare l'accesso utilizzando il controllo dell'accesso basato sui ruoli (RBAC) di Kubernetes.

7. Crea un'associazione del ruolo del cluster che conceda il ruolo del cluster view all'account di servizio Google quando l'account di servizio si autentica nel cluster utilizzando il provider OpenID Connect di Google:

   kubectl create clusterrolebinding ISG_GSA-cluster-view \
       --clusterrole view \
       --user ISG_GSA@PROJECT_ID.iam.gserviceaccount.com
   

   Se imposti un valore userPrefix diverso da - in ClientConfig nel tuo ambiente, aggiungi il prefisso al valore del flag --user in questo comando.

8. Accedi al cluster GKE utilizzando Identity Service for GKE:

   kubectl get namespaces \
       --certificate-authority certificateAuthorityData.pem \
       --server $(cat server.txt) \
       --token $ID_TOKEN
   

   L'output è simile al seguente:

   NAME                      STATUS   AGE
   anthos-identity-service   Active   1h
   default                   Active   1h
   kube-node-lease           Active   1h
   kube-public               Active   1h
   kube-system               Active   1h
   

9. Esci dalla sessione SSH:

   exit
   

Creare un contesto per lo strumento kubectl

Il comando kubectl può utilizzare un file kubeconfig per configurare l'accesso ai cluster. Un file kubeconfig contiene uno o più contesti. Ogni contesto ha un nome e, facoltativamente, include informazioni sulla connettività del cluster, le credenziali utilizzate per l'autenticazione al cluster e uno spazio dei nomi predefinito.

In questa sezione, crei un file kubeconfig con un contesto. Il contesto include i dettagli di connettività del proxy del servizio di identità per GKE per il tuo cluster. Non aggiungi credenziali utente al file kubeconfig.

1. In Cloud Shell, copia i file che contengono i dati dell'autorità di certificazione e l'URL del server dall'istanza VM alla directory corrente:

   gcloud compute scp VM:~/certificateAuthorityData.pem VM:~/server.txt . \
       --tunnel-through-iap --zone ZONE
   

2. Crea un contesto e una configurazione del cluster che utilizzerai in un secondo momento per connetterti al cluster GKE da Cloud Build:

   kubectl config set-context private-cluster \
       --cluster private-cluster \
       --kubeconfig kubeconfig
   

   Il flag --kubeconfig crea il contesto e la configurazione del cluster in un nuovo file denominato kubeconfig nella directory corrente.

   Questo comando utilizza il nome del cluster GKE come nome della configurazione del cluster per il contesto. Nel tuo ambiente, puoi utilizzare un nome di configurazione del cluster diverso nel contesto.

3. Imposta il campo certificateAuthorityData nella configurazione del cluster:

   kubectl config set-cluster private-cluster \
       --certificate-authority certificateAuthorityData.pem \
       --embed-certs \
       --kubeconfig kubeconfig
   

4. Imposta il campo server nella configurazione del cluster:

   kubectl config set-cluster private-cluster \
       --kubeconfig kubeconfig \
       --server $(cat server.txt)
   

Crea un account di servizio Google per Cloud Build

1. In Cloud Shell, crea un account di servizio Google per eseguire le build nel pool privato Cloud Build:

   gcloud iam service-accounts create CB_GSA \
     --description "Runs builds on Cloud Build private pools" \
     --display-name "Cloud Build private pool"
   

   Sostituisci CB_GSA con il nome che vuoi utilizzare per l'account di servizio Google. Per questo tutorial, utilizza cloud-build-private-pool.

2. Concedi il ruolo Account di servizio Cloud Build nel progetto all'account di servizio Google:

   gcloud projects add-iam-policy-binding PROJECT_ID \
       --member serviceAccount:CB_GSA@PROJECT_ID.iam.gserviceaccount.com \
       --role roles/cloudbuild.builds.builder
   

   Questo ruolo fornisce le autorizzazioni predefinite dell'account di servizio Cloud Build gestito da Google.

3. Concedi il ruolo Service Account OpenID Connect Identity Token Creator all'account di servizio Google stesso:

   gcloud iam service-accounts add-iam-policy-binding \
       CB_GSA@PROJECT_ID.iam.gserviceaccount.com \
       --member serviceAccount:CB_GSA@PROJECT_ID.iam.gserviceaccount.com \
       --role roles/iam.serviceAccountOpenIdTokenCreator
   

   Questo ruolo fornisce l'autorizzazione iam.serviceAccounts.getOpenIdToken necessaria per richiedere token ID per l'account di servizio dall'API Credentials for Service Account.

4. Connettiti all'istanza VM tramite SSH:

   gcloud compute ssh VM --tunnel-through-iap --zone ZONE
   

   Esegui il resto dei comandi in questa sezione dalla sessione SSH.

5. Nella sessione SSH, crea un'associazione del ruolo del cluster Kubernetes che conceda il ruolo del cluster cluster-admin all'account di servizio Google quando l'account di servizio si autentica nel cluster utilizzando il provider OpenID Connect di Google:

   kubectl create clusterrolebinding CB_GSA-cluster-admin \
       --clusterrole cluster-admin \
       --user CB_GSA@PROJECT_ID.iam.gserviceaccount.com
   

   Il ruolo cluster cluster-admin concede autorizzazioni ampie a livello di cluster. Nel tuo ambiente, puoi utilizzare un ruolo cluster che fornisce solo le autorizzazioni necessarie per le attività eseguite da Cloud Build. Puoi anche utilizzare le associazioni di ruoli per concedere autorizzazioni solo a spazi dei nomi specifici.

   Se imposti un userPrefix in ClientConfig nel tuo ambiente, devi aggiungere questo prefisso al valore del flag --user in questo comando.

6. Esci dalla sessione SSH:

   exit
   

Crea un pool privato Cloud Build

1. In Cloud Shell, alloca un intervallo di indirizzi IP nella rete VPC per la connessione con il pool privato:

   gcloud compute addresses create RESERVED_RANGE_NAME \
   --addresses RESERVED_RANGE_START_IP\
       --description "Cloud Build private pool reserved range" \
       --global \
       --network NETWORK \
       --prefix-length RESERVED_RANGE_PREFIX_LENGTH \
       --purpose VPC_PEERING
   

   Sostituisci quanto segue:

   • RESERVED_RANGE_NAME: il nome dell'intervallo di indirizzi IP allocato che ospita il pool privato di Cloud Build. Per questo tutorial, utilizza cloud-build-private-pool.
   • RESERVED_RANGE_START_IP: il primo indirizzo IP dell'intervallo di indirizzi IP allocato. Per questo tutorial, utilizza 192.168.12.0.
   • RESERVED_RANGE_PREFIX_LENGTH: la lunghezza del prefisso (subnet mask) dell'intervallo di indirizzi IP allocati. La lunghezza del prefisso deve essere /23 o un numero inferiore, ad esempio /22 o /21. Un numero inferiore indica un intervallo di indirizzi più ampio. Per questo tutorial, utilizza 23 e non inserire il carattere / iniziale (barra).

2. Crea una regola firewall per consentire il traffico in entrata dall'intervallo di indirizzi IP riservato ad altre risorse nella rete VPC:

   gcloud compute firewall-rules create allow-private-pools-ingress \
       --allow all \
       --network NETWORK \
       --source-ranges RESERVED_RANGE_START_IP/RESERVED_RANGE_PREFIX_LENGTH
   

3. Crea una connessione di servizio privata per collegare la tua rete VPC al servizio Service Networking:

   gcloud services vpc-peerings connect \
       --network NETWORK \
       --ranges RESERVED_RANGE_NAME \
       --service servicenetworking.googleapis.com
   

   I pool privati di Cloud Build eseguono i worker utilizzando la rete di servizi. La connessione privata ai servizi consente alla rete VPC di comunicare con il pool privato nell'intervallo di indirizzi IP interni allocati utilizzando una connessione di peering di rete VPC.

   La creazione della connessione privata ai servizi può richiedere alcuni minuti.

   Se utilizzi un VPC condiviso nel tuo ambiente, per informazioni su ulteriori passaggi per creare la connessione di servizio privato, consulta Configurare l'ambiente.

4. Crea un pool privato Cloud Build in una rete VPC di proprietà di Google in peering con la tua rete VPC:

   gcloud builds worker-pools create PRIVATE_POOL_NAME \
      --no-public-egress \
      --peered-network projects/PROJECT_ID/global/networks/NETWORK \
      --region REGION
   

   Sostituisci quanto segue:

   • PRIVATE_POOL_NAME: il nome del pool privato. Per questo tutorial, utilizza private-pool.
   • REGION: la regione da utilizzare per il pool privato. Per questo tutorial, utilizza us-central1.

   L'indicatore --no-public-egress indica che i worker nel pool privato non hanno indirizzi IP pubblici. Nel tuo ambiente, puoi rimuovere questo flag se vuoi che i worker nel pool privato abbiano connettività a internet utilizzando indirizzi IP pubblici.

   Per informazioni su opzioni di configurazione aggiuntive, come il tipo di macchina e le dimensioni del disco per i worker nel pool privato, consulta Creare e gestire i pool privati.

Verificare la soluzione

In questa sezione, verifichi la soluzione eseguendo una build nel pool privato di Cloud Build. La compilazione accede al cluster GKE privato.

1. In Cloud Shell, crea un bucket Cloud Storage per archiviare i log di compilazione di Cloud Build:

   gcloud storage buckets create gs://PROJECT_ID-build-logs --location=REGION
   

2. Crea un file di configurazione di compilazione per Cloud Build:

   cat << "EOF" > cloudbuild.yaml
   steps:
   - id: list-services
     name: gcr.io/google.com/cloudsdktool/google-cloud-cli
     entrypoint: bash
     args:
     - -eEuo
     - pipefail
     - -c
     - |-
       kubectl config use-context $_KUBECTL_CONTEXT
   
       ACCESS_TOKEN=$$(curl --silent \
           --header "Metadata-Flavor: Google" \
           http://metadata.google.internal/computeMetadata/v1/instance/service-accounts/default/token \
           | python3 -c 'import json, sys; print(json.load(sys.stdin).get("access_token"))')
   
       ID_TOKEN=$$(curl --silent --request POST \
           --data '{"audience": "CLIENT_ID", "includeEmail": true}' \
           --header "Authorization: Bearer $$ACCESS_TOKEN" \
           --header "Content-Type: application/json; charset=utf-8" \
           "https://iamcredentials.googleapis.com/v1/projects/-/serviceAccounts/$_SERVICE_ACCOUNT:generateIdToken" \
           | python3 -c 'import json, sys; print(json.load(sys.stdin).get("token"))')
   
       kubectl get services --namespace $_NAMESPACE --token $$ID_TOKEN
   
   logsBucket: gs://PROJECT_ID-build-logs
   
   options:
     env:
     - KUBECONFIG=/workspace/$_KUBECONFIG
   
   substitutions:
     _KUBECONFIG: kubeconfig
     _KUBECTL_CONTEXT: private-cluster
     _NAMESPACE: default
   
   serviceAccount: projects/$PROJECT_ID/serviceAccounts/$_SERVICE_ACCOUNT
   EOF
   

   Il passaggio nel file di configurazione di compilazione esegue le seguenti operazioni:

   1. Passa al contesto kubectl specificato dalla sostituzione _KUBECTL_CONTEXT. Il valore di sostituzione predefinito è private-cluster.

   2. Recupera un token di accesso dal server dei metadati. Il token di accesso viene emesso per l'account di servizio Google che esegue la compilazione.

   3. Genera un token ID utilizzando l'API Service Account Credentials. La richiesta di generazione del token ID viene autenticata utilizzando il token di accesso. L'affermazione aud (segmento di pubblico) richiesta del token ID è l'ID client OAuth 2.0 specificato dalla sostituzione _CLIENT_ID.

   4. Elenca i servizi Kubernetes nello spazio dei nomi specificato dalla sostituzione _NAMESPACE. Il valore di sostituzione predefinito è default. La richiesta viene autenticata utilizzando il token ID generato nel comando precedente.

   Tieni presente quanto segue sul file di configurazione di compilazione:

   • Il carattere $ è il prefisso per le sostituzione. $$ viene utilizzato per l'espansione dei parametri bash e la sostituzione dei comandi.

   • Le sostituzioni _KUBECONFIG e _KUBECTL_CONTEXT consentono di specificare file kubeconfig e contesti diversi quando esegui una compilazione. Queste sostituzioni ti consentono di gestire più configurazioni di cluster utilizzando un singolo file kubeconfig con più contesti o più file kubeconfig.

   • La sostituzione _SERVICE_ACCOUNT non ha un valore predefinito. Devi fornire un valore per questa sostituzione quando esegui una compilazione.

   • Il blocco options imposta la variabile di ambiente KUBECONFIG per tutti i passaggi della compilazione.

   • Il passaggio di compilazione utilizza l'immagine del generatore gcr.io/google.com/cloudsdktool/google-cloud-cli. Si tratta di un'immagine container di grandi dimensioni e l'estrazione dal registry al worker del pool privato richiede del tempo. Per ridurre il tempo necessario per estrarre l'immagine del generatore, puoi creare un'immagine del generatore personalizzata contenente solo gli strumenti necessari per il passaggio di compilazione, come curl, kubectl e Python.

   Per ulteriori informazioni sugli script shell in linea nei file di configurazione build, consulta Eseguire script bash.

3. Esegui una build utilizzando il file di configurazione della build e i file nella directory corrente:

   gcloud builds submit \
       --config cloudbuild.yaml \
       --region REGION \
       --substitutions _SERVICE_ACCOUNT=CB_GSA@PROJECT_ID.iam.gserviceaccount.com \
       --worker-pool projects/PROJECT_ID/locations/REGION/workerPools/PRIVATE_POOL_NAME
   

   Il comando carica tutti i file nella directory corrente su Cloud Storage per l'utilizzo da parte di Cloud Build. Il passaggio di compilazione utilizza il file kubeconfig per connettersi al cluster GKE.

   Verso la fine dell'output, vedrai righe simili alle seguenti:

   NAME         TYPE        CLUSTER-IP   EXTERNAL-IP   PORT(S)   AGE
   kubernetes   ClusterIP   10.0.0.1     <none>        443/TCP   2h
   

   Questo output mostra che il worker del pool privato si è connesso al piano di controllo del cluster utilizzando il proxy di autenticazione di Identity Service for GKE.

Risoluzione dei problemi

Se non riesci a connetterti all'istanza VM utilizzando SSH, aggiungi il flag --troubleshoot per scoprire la causa dei problemi di connettività:

gcloud compute ssh VM --tunnel-through-iap --zone ZONE --troubleshoot

Se ricevi il messaggio Error from server (NotFound): clientconfigs.authentication.gke.io "default" not found quando esegui la patch di ClientConfig predefinito sul cluster GKE, assicurati di aver creato la regola firewall come descritto nella sezione Creazione di un cluster GKE privato. Verifica che esista la regola firewall:

gcloud compute firewall-rules describe allow-control-plane-clientconfig-webhook

Se non riesci ad autenticarti al proxy di Identity Service for GKE, cerca gli errori nei log dei pod nel deployment gke-oidc-service:

gcloud compute ssh VM --tunnel-through-iap --zone ZONE --command \
    'kubectl logs deployment/gke-oidc-service \
         --namespace anthos-identity-service --all-containers'

Se riscontri altri problemi con questo tutorial, ti consigliamo di consultare questi documenti:

• Risoluzione dei problemi di GKE
• Risoluzione dei problemi relativi ai cluster Kubernetes

Esegui la pulizia

Per evitare che al tuo account Google Cloud vengano addebitati costi relativi alle risorse utilizzate in questo tutorial, elimina il progetto che contiene le risorse oppure mantieni il progetto ed elimina le singole risorse.

Elimina il progetto

Attenzione: l'eliminazione di un progetto ha i seguenti effetti:

• L'intero contenuto del progetto viene eliminato. Se hai utilizzato un progetto esistente per le attività descritte in questo documento, quando lo elimini elimini anche tutto il lavoro svolto nel progetto.
• Gli ID progetto personalizzati non sono più disponibili. Quando hai creato questo progetto, potresti aver creato un ID progetto personalizzato che vuoi utilizzare in futuro. Per conservare gli URL che utilizzano l'ID progetto, ad esempio un URL appspot.com, elimina le risorse selezionate all'interno del progetto anziché eliminare l'intero progetto.

Se intendi esplorare più architetture, tutorial o guide rapide, il riuso dei progetti può aiutarti a non superare i limiti di quota.

Delete a Google Cloud project:

gcloud projects delete PROJECT_ID

Elimina le risorse

Se vuoi mantenere il progetto utilizzato in questo tutorial, elimina le singole risorse:

1. In Cloud Shell, elimina il pool privato di Cloud Build:

   gcloud builds worker-pools delete PRIVATE_POOL_NAME --region REGION --quiet
   

2. Elimina la connessione di servizio privata a Service Networking:

   gcloud services vpc-peerings delete --network NETWORK \
     --service servicenetworking.googleapis.com --quiet --async
   

3. Elimina l'intervallo di indirizzi IP allocato ai pool privati di Cloud Build:

   gcloud compute addresses delete RESERVED_RANGE_NAME --global --quiet
   

4. Elimina il bucket Cloud Storage e tutti i relativi contenuti:

   gcloud storage rm gs://PROJECT_ID-build-logs --recursive
   

5. Elimina il cluster GKE:

   gcloud container clusters delete CLUSTER --zone ZONE --quiet --async
   

6. Elimina l'istanza VM di Compute Engine:

   gcloud compute instances delete VM --zone ZONE --quiet
   

7. Elimina le regole firewall:

   gcloud compute firewall-rules delete allow-private-pools-ingress --quiet
   
   gcloud compute firewall-rules delete allow-ssh-ingress-from-iap --quiet
   
   gcloud compute firewall-rules delete allow-control-plane-clientconfig-webhook --quiet
   

8. Rimuovi le associazioni dei ruoli IAM:

   gcloud projects remove-iam-policy-binding PROJECT_ID \
       --member serviceAccount:CB_GSA@PROJECT_ID.iam.gserviceaccount.com \
       --role roles/cloudbuild.builds.builder
   
   gcloud projects remove-iam-policy-binding PROJECT_ID \
       --member serviceAccount:ISG_GSA@PROJECT_ID.iam.gserviceaccount.com \
       --role roles/container.admin
   
   gcloud iam service-accounts remove-iam-policy-binding \
       CB_GSA@PROJECT_ID.iam.gserviceaccount.com \
       --member serviceAccount:CB_GSA@PROJECT_ID.iam.gserviceaccount.com \
       --role roles/iam.serviceAccountOpenIdTokenCreator
   
   gcloud iam service-accounts remove-iam-policy-binding \
       ISG_GSA@PROJECT_ID.iam.gserviceaccount.com \
       --member serviceAccount:ISG_GSA@PROJECT_ID.iam.gserviceaccount.com \
       --role roles/iam.serviceAccountOpenIdTokenCreator
   

9. Elimina gli account di servizio Google:

   gcloud iam service-accounts delete CB_GSA@PROJECT_ID.iam.gserviceaccount.com \
      --quiet
   
   gcloud iam service-accounts delete ISG_GSA@PROJECT_ID.iam.gserviceaccount.com \
      --quiet
   

Eliminare l'ID client OAuth 2.0

1. Vai alla pagina Credenziali nella console Google Cloud:

   Apri la pagina Credenziali

2. Seleziona il progetto dall'elenco del selettore dei progetti.

3. Nella tabella degli ID client OAuth 2.0, individua la riga relativa a Identity Service for GKE e fai clic sull'icona Elimina client OAuth.

4. Nella finestra di dialogo, fai clic su Elimina.

Passaggi successivi

• Scopri come accedere ai cluster Anthos da Cloud Build con il gateway di connessione.
• Scopri come accedere ai cluster GKE privati con i pool privati di Cloud Build utilizzando Cloud VPN.
• Scopri come creare cluster GKE privati con proxy di rete per l'accesso al piano di controllo.
• Scopri come accedere alle risorse esterne in una rete privata utilizzando un IP esterno statico.
• Scopri GKE Identity Service. GKE Identity Service ti consente di gestire l'autenticazione dei provider di identità esterni in un parco risorse di cluster Anthos.