Accedi ai cluster Google Kubernetes Engine privati dai pool privati di Cloud Build utilizzando Identity Service for 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 è destinato agli amministratori di piattaforma, agli amministratori di cluster e agli sviluppatori. Si presume che tu abbia familiarità 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 alla tua rete VPC su Google Cloud. Tuttavia, il peering di rete VPC non supporta il peering transitivo, che potrebbe essere una limitazione quando utilizzi i pool privati di Cloud Build. Questo tutorial illustra una soluzione che utilizza Identity Service per GKE per consentire ai worker in 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 impersonare 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. È possibile accedere al proxy tramite il bilanciatore del carico su una connessione di peering di rete VPC, ad esempio da un pool privato di Cloud Build, perché il proxy viene eseguito su nodi cluster nella tua rete VPC.

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

Complessivamente, questa soluzione consente l'accesso 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 sul 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:

Accedi ai cluster GKE privati utilizzando Identity Service for GKE

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

Le autorizzazioni IAM (Identity and Access Management) concesse agli account utente e agli account di servizio Google non si applicano quando eseguono l'autenticazione utilizzando Identity Service for GKE. Utilizza invece il controllo controllo dell'accesso basato su ruoli (RBAC) di Kubernetes per gestire le autorizzazioni dei 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.

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

    • 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 client accesso all'endpoint pubblico del piano di controllo in cui è installato Identity Service for 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 piano di controllo. 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 ID progetto Google Cloud.
    • 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 Federazione delle identità per 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) di Kubernetes utilizzato da Identity Service per GKE per configurare la modalità di interazione con i provider di identità.

Registra Identity Service per 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 schermata per il consenso. Segui la documentazione sulla configurazione della schermata del consenso. Per questo tutorial, imposta i seguenti valori:

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

    Al termine della configurazione della schermata per il consenso, fai clic su Torna alla dashboard e 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, usa 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'attributo forzato secondario (soggetto). L'utilizzo di questo identificatore opaco nelle associazioni di ruoli rende difficile identificare l'oggetto di un'associazione di ruolo. 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 dell'email viene aggiunto in modo che i token ID emessi includano la rivendicazione via 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 eseguono l'autenticazione nel cluster. Il campo kubectl RedirectURI è obbligatorio.

    • Il campo userPrefix è un prefisso per gli utenti che effettuano l'autenticazione utilizzando il provider di identità configurato. Il valore '-' indica nessun prefisso.

    • Il campo spec.authentication è un array. Puoi utilizzare più provider di identità OpenID Connect con Identity Service per 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 saperne di più sui campi di questa configurazione, consulta Utilizzare provider di identità esterni per l'autenticazione su GKE.

Crea un account di servizio Google per configurare Identity Service per 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 Identity Service per il controllo dell'accesso basato sui ruoli di GKE e Kubernetes sul cluster.

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

    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 eseguire le attività seguenti 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.

Configura Identity Service per 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, puoi utilizzare l'inoltro TCP con Identity-Aware Proxy (IAP). Questa funzionalità abilita l'accesso SSH senza che l'istanza VM abbia un indirizzo IP pubblico.

  1. In Cloud Shell, crea una regola firewall che consenta l'accesso SSH utilizzando Inoltro TCP IAP a tutte le istanze VM che hanno 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 che IAP utilizza 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 abilita OS Login sull'istanza VM. OS Login consente di gestire l'accesso SSH alle istanze VM tramite 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 tunneling 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 di 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) Verificare 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 di questa sezione dalla sessione SSH.

  3. Richiedi un token di accesso OAuth 2.0 dal server dei metadati per l'account di servizio Google collegato all'istanza VM, utilizzando l'ID client OAuth come richiesta di attestazione aud (pubblico):

    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 dal 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 in merito al 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 nell'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

    Questo errore è previsto. Sebbene all'account di servizio Google siano state concesse autorizzazioni IAM sui cluster GKE del progetto, le autorizzazioni IAM non si applicano quando esegui l'autenticazione utilizzando Identity Service for 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 esegue l'autenticazione 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

Crea 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 creerai un file kubeconfig contenente un contesto. Il contesto include i dettagli sulla connettività del proxy Identity Service per GKE per il cluster. Non dovrai aggiungere 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 seguito 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 sulla 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 Creatore token di identità OpenID Connect dell'account di servizio nell'account di servizio Google all'account di servizio 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 di 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 esegue l'autenticazione 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 del cluster cluster-admin concede autorizzazioni estese 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 di Cloud Build

  1. In Cloud Shell, alloca un intervallo di indirizzi IP nella tua 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 / (barra) iniziale.

  2. Crea una regola firewall per consentire il traffico in entrata dall'intervallo di indirizzi IP riservati ad altre risorse nella tua 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 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 allocato di indirizzi IP interni, 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.

    Il flag --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 dispongano di connettività a internet tramite 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.

Verifica 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 della build 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 per generare il token ID viene autenticata utilizzando il token di accesso. La rivendicazione aud (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 delle sostituzioni. $$ viene utilizzato per l'espansione dei parametri bash e la sostituzione dei comandi.

    • Le sostituzioni _KUBECONFIG e _KUBECTL_CONTEXT consentono di specificare diversi file kubeconfig e contesti diversi quando esegui una build. 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 build.

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

    • Il passaggio di build utilizza l'immagine del builder gcr.io/google.com/cloudsdktool/google-cloud-cli. Questa è un'immagine container di grandi dimensioni e richiede del tempo per eseguire il pull dal registry al worker del pool privato. Per ridurre il tempo necessario per eseguire il pull dell'immagine del builder, puoi creare un'immagine del builder personalizzata che contenga solo gli strumenti necessari per il passaggio di build, ad esempio 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 attuale:

    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

    Questa uscita 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 tramite 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 la regola firewall esista:

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

Se non riesci ad autenticarti con il proxy Identity Service for GKE, cerca gli errori nei log dei pod del 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:

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

    Delete a Google Cloud project:

    gcloud projects delete PROJECT_ID

Elimina le risorse

Se vuoi conservare 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

Elimina l'ID client OAuth 2.0

  1. Vai alla pagina Credenziali nella console Google Cloud:

    Apri la pagina Credenziali

  2. Seleziona il tuo progetto dall'elenco del selettore di progetti.

  3. Nella tabella ID client OAuth 2.0, trova la riga Identity Service for GKE (Servizio di identità per GKE), quindi fai clic sull'icona Elimina client OAuth.

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

Passaggi successivi