Integrazione di IAP con Anthos Service Mesh

Questo tutorial descrive come integrare Identity-Aware Proxy (IAP) con Anthos Service Mesh. L'integrazione di IAP con Anthos Service Mesh ti consente di accedere in modo sicuro ai servizi in base ai principi di BeyondCorp di Google. IAP verifica l'identità dell'utente e il contesto della richiesta per determinare se un utente può essere autorizzato ad accedere a un'applicazione o risorsa. L'integrazione di IAP con Anthos Service Mesh offre i seguenti vantaggi:

  • Completa il controllo dell'accesso sensibile al contesto ai carichi di lavoro in esecuzione su Anthos Service Mesh. Puoi impostare criteri di accesso granulari in base agli attributi della richiesta di origine, come l'identità dell'utente, l'indirizzo IP e il tipo di dispositivo. Puoi combinare i criteri di accesso con le restrizioni in base al nome host e al percorso di un URL di richiesta.

  • Attiva il supporto per le rivendicazioni sensibili al contesto nell'autorizzazione Anthos Service Mesh.

  • Accesso scalabile, sicuro e ad alta disponibilità all'applicazione tramite un bilanciatore del carico Google Cloud. Il bilanciamento del carico ad alte prestazioni offre la protezione integrata degli attacchi denial of service (DDoS) distribuiti e supporto per l'indirizzo IP anycast globale.

Obiettivi

  • Avvia la configurazione:
    1. Configurare il progetto Google Cloud per concedere le autorizzazioni e abilitare le API di Google richieste da IAP.
    2. Prenotare un indirizzo IP statico esterno e configurare un nome di dominio per utilizzare l'indirizzo IP necessario al bilanciatore del carico.
    3. Configurare un nuovo cluster Google Kubernetes Engine (GKE) con le opzioni necessarie per integrare IAP con Anthos Service Mesh.
    4. Installa Anthos Service Mesh con le opzioni richieste per l'integrazione.
    5. Eseguire il deployment di un'applicazione di esempio.
    6. Eseguire il deployment del bilanciatore del carico.

  • Abilitare IAP.

  • Attiva il supporto RCToken sul mesh di servizi.

Costi

In questo documento utilizzi i seguenti componenti fatturabili di Google Cloud:

Per generare una stima dei costi basata sull'utilizzo previsto, utilizza il Calcolatore prezzi. I nuovi utenti di Google Cloud potrebbero essere idonei per una prova gratuita.

Una volta completate le attività descritte in questo documento, puoi evitare la fatturazione continua eliminando le risorse che hai creato. Per ulteriori informazioni, consulta la pagina Pulizia.

Prima di iniziare

Requisiti

  • Devi avere una licenza di prova o un abbonamento Anthos. Per i dettagli, consulta la guida ai prezzi di Anthos.

  • Il cluster GKE deve soddisfare i seguenti requisiti:

  • Per essere incluse nel mesh di servizi, le porte di servizio devono avere un nome e il nome deve includere il protocollo della porta nella seguente sintassi: name: protocol[-suffix]in cui le parentesi quadre indicano un suffisso facoltativo che deve iniziare con un trattino. Per ulteriori informazioni, vedi Denominazione delle porte dei servizi.

  • Se installi Anthos Service Mesh su un cluster privato, devi aggiungere una regola firewall per aprire la porta 15017 se vuoi utilizzare l'iniezione automatica di sidecar. Se non aggiungi la regola firewall e l'inserimento automatico del sidecar è abilitato, ricevi un errore quando esegui il deployment dei carichi di lavoro. Per informazioni dettagliate sull'aggiunta di una regola firewall, consulta Aggiunta di regole firewall per casi d'uso specifici.

  • Se hai creato un perimetro di servizio nella tua organizzazione, potresti dover aggiungere il servizio Mesh CA al perimetro. Per ulteriori informazioni, consulta la sezione Aggiungere CA CA a un perimetro di servizio.

Configurazione dell'ambiente

Per le installazioni su Google Kubernetes Engine, puoi seguire le guide all'installazione utilizzando Cloud Shell, un'interfaccia a riga di comando nel browser per le tue risorse Google Cloud, o il tuo computer che esegue Linux o macOS.

Opzione A: utilizza Cloud Shell

Cloud Shell esegue il provisioning di una macchina virtuale (VM) g1-small Compute Engine che esegue un sistema operativo Linux basato su Debian. I vantaggi dell'utilizzo di Cloud Shell sono:

  • Cloud Shell include gli strumenti a riga di comando gcloud, kubectl e helm necessari.

  • La directory $HOME di Cloud Shell dispone di 5 GB di spazio di archiviazione permanente.

  • Puoi scegliere tra editor di testo:

    • Editor di codice, a cui puoi accedere facendo clic su nella parte superiore della finestra di Cloud Shell.

    • Emacs, Vim o Nano, a cui puoi accedere dalla riga di comando in Cloud Shell.

Per utilizzare Cloud Shell:

  1. Vai alla console Google Cloud.
  2. Selezionare il tuo progetto Google Cloud.

  3. Fai clic sul pulsante Attiva Cloud Shell nella parte superiore della finestra della console Google Cloud.

    Console di Google Cloud Platform

    Una sessione di Cloud Shell si apre all'interno di un nuovo frame nella parte inferiore della console Google Cloud e mostra un prompt della riga di comando.

    Sessione di Cloud Shell

  4. Aggiorna i componenti:

    gcloud components update

    Il comando risponde con un output simile al seguente:

    ERROR: (gcloud.components.update)
You cannot perform this action because the gcloud CLI component manager
is disabled for this installation. You can run the following command
to achieve the same result for this installation:

sudo apt-get update && sudo apt-get --only-upgrade install ...

  5. Copia il comando lungo e incollalo per aggiornare i componenti.

  6. Installa kubectl:

    sudo apt-get install kubectl

  7. Installa kpt:

    sudo apt-get install google-cloud-sdk-kpt

Opzione B: utilizza gli strumenti a riga di comando localmente

Sul tuo computer locale, installa e inizializza l'interfaccia a riga di comando gcloud.

  1. Esegui l'autenticazione con Google Cloud CLI:

    gcloud auth login

  2. Aggiorna i componenti:

    gcloud components update

  3. Installa kubectl:

    gcloud components install kubectl

  4. Installa kpt:

    gcloud components install kpt

Configurazione del progetto in corso…

  1. Ottieni l'ID del progetto in cui verrà creato il cluster:

    gcloud

    gcloud projects list

    Console

    1. Nella console Google Cloud, vai alla pagina Dashboard:

      Vai alla pagina Dashboard

    2. Fai clic sull'elenco a discesa Seleziona da nella parte superiore della pagina. Nella finestra Seleziona da che viene visualizzata, seleziona il progetto.

      L'ID progetto viene visualizzato nella scheda Informazioni sul progetto della dashboard del progetto.

  2. Crea una variabile di ambiente per l'ID progetto: 
    export PROJECT_ID=YOUR_PROJECT_ID
  3. Imposta l'ID progetto predefinito per lo strumento a riga di comando gcloud: 
    gcloud config set project ${PROJECT_ID}
  4. Crea una variabile di ambiente per il numero di progetto: 
    export PROJECT_NUMBER=$(gcloud projects describe ${PROJECT_ID} --format="value(projectNumber)")

  5. Impostare i ruoli IAM (Identity and Access Management). Se sei un proprietario del progetto, disponi di tutte le autorizzazioni necessarie per completare l'installazione e registrare il tuo cluster nell'ambiente. Se non sei un proprietario del progetto, devi chiedere a qualcuno che ti conceda i seguenti ruoli IAM specifici. Nel comando seguente, cambia GCP_EMAIL_ADDRESS con l'account che utilizzi per accedere a Google Cloud. 
    gcloud projects add-iam-policy-binding ${PROJECT_ID} \
     --member user:GCP_EMAIL_ADDRESS \
     --role=roles/editor \
     --role=roles/compute.admin \
     --role=roles/container.admin \
     --role=roles/resourcemanager.projectIamAdmin \
     --role=roles/iam.serviceAccountAdmin \
     --role=roles/iam.serviceAccountKeyAdmin \
     --role=roles/gkehub.admin

    Per scoprire di più su come concedere i ruoli IAM, consulta Concessione, modifica e revoca dell'accesso alle risorse. Per una descrizione di questi ruoli, vedi Autorizzazioni richieste per installare Anthos Service Mesh

  6. Abilita le seguenti API: 
    gcloud services enable \
    container.googleapis.com \
    compute.googleapis.com \
    monitoring.googleapis.com \
    logging.googleapis.com \
    cloudtrace.googleapis.com \
    meshca.googleapis.com \
    meshtelemetry.googleapis.com \
    meshconfig.googleapis.com \
    iamcredentials.googleapis.com \
    anthos.googleapis.com \
    gkeconnect.googleapis.com \
    gkehub.googleapis.com \
    cloudresourcemanager.googleapis.com \
    iap.googleapis.com

    L'abilitazione delle API può richiedere un minuto o più. Quando le API sono abilitate, visualizzi un output simile al seguente:

    Operation "operations/acf.601db672-88e6-4f98-8ceb-aa3b5725533c" finished
successfully.

Prenota un indirizzo IP statico e configura il DNS

Per integrare Identity-Aware Proxy con Anthos Service Mesh, devi configurare un bilanciatore del carico HTTP(S) Google Cloud, che richiede un nome di dominio che indirizzi a un indirizzo IP statico. Puoi prenotare un indirizzo IP esterno statico, che assegna l'indirizzo al progetto a tempo indeterminato finché non lo rilasci esplicitamente.

  1. Prenota un indirizzo IP esterno statico:

    gcloud compute addresses create example-static-ip --global

  2. Recupera l'indirizzo IP statico:

    gcloud compute addresses describe example-static-ip --global

  3. Nel registrar del nome di dominio, configura un nome di dominio completo (FQDN) con l'indirizzo IP statico. In genere, si aggiunge un record A alle impostazioni DNS. I passaggi di configurazione e la terminologia per aggiungere un record A per un nome di dominio completo variano a seconda del registrar del nome di dominio.

  4. Imposta il nome di dominio in una variabile di ambiente:

    export DOMAIN_NAME=YOUR_DOMAIN_NAME

    La propagazione dell'impostazione DNS può richiedere da 24 a 48 ore. Puoi continuare a configurare tutto in questo tutorial, ma non potrai testare la configurazione fino a quando le impostazioni DNS non saranno state propagate.

Configurazione di un nuovo cluster GKE

Per configurare un nuovo cluster:

  1. Seleziona una zona, un tipo di macchina e un canale di rilascio GKE per il nuovo cluster. Il tipo di macchina minimo richiesto da Anthos Service Mesh è n1-standard-4. Puoi utilizzare qualsiasi opzione del canale di rilascio.

    • Per visualizzare un elenco delle zone GCP disponibili:

      gcloud compute zones list

    • Per visualizzare un elenco dei tipi di macchine:

      gcloud compute machine-types list | more

  2. Crea le seguenti variabili di ambiente:

    • Imposta il nome del cluster:

      export CLUSTER_NAME=YOUR_CLUSTER_NAME

      Il nome del cluster deve contenere solo caratteri alfanumerici minuscoli e "-", deve iniziare con una lettera e terminare con un carattere alfanumerico e non deve superare i 40 caratteri.

    • Imposta CLUSTER_LOCATION sulla zona del cluster:

      export CLUSTER_LOCATION=YOUR_ZONE

    • Imposta il pool di carichi di lavoro:

      export WORKLOAD_POOL=${PROJECT_ID}.svc.id.goog

    • Imposta l'ID mesh:

      export MESH_ID="proj-${PROJECT_NUMBER}"

  3. Crea il cluster con le opzioni richieste da Anthos Service Mesh. Il comando seguente crea un cluster contenente 4 nodi di tipo di macchina n1-standard-4, con 4 vCPU. Questo è il tipo di macchina minimo e il numero di nodi richiesti per Anthos Service Mesh. Puoi specificare un altro tipo di macchina purché abbia almeno 4 vCPU e puoi aumentare il numero di nodi in base alle tue esigenze in termini di sistema.

    gcloud beta container clusters create ${CLUSTER_NAME} \
    --project=${PROJECT_ID} \
    --zone=${CLUSTER_LOCATION} \
    --machine-type=n1-standard-4 \
    --num-nodes=4 \
    --workload-pool=${WORKLOAD_POOL} \
    --enable-stackdriver-kubernetes \
    --subnetwork=default \
    --labels mesh_id=${MESH_ID} \
    --addons=HttpLoadBalancing \
    --release-channel=regular

    Il comando clusters create include:

    • workload-pool=${WORKLOAD_POOL}: abilita Workload Identity, che è il modo consigliato per accedere in modo sicuro ai servizi Google Cloud dalle applicazioni GKE.

    • enable-stackdriver-kubernetes: abilita Cloud Monitoring e Cloud Logging su GKE.

    • subnetwork=default: crea una subnet predefinita.

    • labels mesh_id=${MESH_ID}: imposta l'etichetta mesh_id nel cluster, necessaria per visualizzare le metriche nella dashboard di Anthos Service Mesh nella console Google Cloud.

    • Il componente aggiuntivo HttpLoadBalancing, che abilita un controller di bilanciamento del carico HTTP (L7) per il cluster.

    • release-channel regular: registra il cluster nel canale di rilascio regular, ma puoi scegliere stable se hai bisogno di maggiore stabilità o rapid se vuoi provare nuove funzionalità GKE (non supportate).

Impostazione di credenziali e autorizzazioni

  1. Inizializza il tuo progetto per prepararlo all'installazione. Tra le altre cose, questo comando crea un account di servizio per consentire ai componenti Istio, come il proxy sidecar, di accedere in modo sicuro ai dati e alle risorse del tuo progetto: 
    curl --request POST \
  --header "Authorization: Bearer $(gcloud auth print-access-token)" \
  --data '' \
  https://meshconfig.googleapis.com/v1alpha1/projects/${PROJECT_ID}:initialize

    Il comando risponde con parentesi graffe vuote: {}

    Se in futuro installi una nuova versione di Anthos Service Mesh su questo cluster, non è necessario eseguire nuovamente il comando, ma l'esecuzione del comando non influisce sull'installazione.

  2. Accedi alle credenziali di autenticazione per interagire con il cluster: 
    gcloud container clusters get-credentials ${CLUSTER_NAME}
  3. Concedi le autorizzazioni di amministratore al cluster all'utente corrente. Per creare le regole necessarie per il controllo dell'accesso basato sui ruoli (RBAC) per Anthos Service Mesh, devi disporre delle seguenti autorizzazioni: 
    kubectl create clusterrolebinding cluster-admin-binding \
  --clusterrole=cluster-admin \
  --user="$(gcloud config get-value core/account)"

    Se visualizzi l'errore "cluster-admin-binding" already exists, puoi ignorarlo e continuare con l'associazione cluster-admin esistente.

Registrazione del cluster

Devi registrare il cluster con il parco risorse del progetto per ottenere l'accesso all'interfaccia utente unificata nella console Google Cloud. Un parco risorse fornisce un modo unificato per visualizzare e gestire i cluster e i relativi carichi di lavoro, inclusi i cluster esterni a Google Cloud.

Creare un account di servizio e un file di chiave Google Cloud

Per registrare un cluster è necessario un file JSON contenente le credenziali dell'account di servizio. Per seguire il principio del privilegio minimo, ti consigliamo di creare un account di servizio distinto per ogni cluster registrato.

Per creare un account di servizio e un file della chiave:

  1. Seleziona un nome per l'account di servizio e crea una variabile di ambiente per l'account:

    export SERVICE_ACCOUNT_NAME=SERVICE_ACCOUNT_NAME

  2. Crea l'account di servizio:

    gcloud iam service-accounts create ${SERVICE_ACCOUNT_NAME}

  3. Elenca tutti gli account di servizio di un progetto per confermare che sia stato creato:

    gcloud iam service-accounts list

  4. associare il ruolo IAM gkehub.connect all'account di servizio:

    gcloud projects add-iam-policy-binding ${PROJECT_ID} \
   --member="serviceAccount:${SERVICE_ACCOUNT_NAME}@${PROJECT_ID}.iam.gserviceaccount.com" \
   --role="roles/gkehub.connect"

  5. Crea una variabile di ambiente per il percorso file locale in cui vuoi salvare il file JSON. Ti consigliamo di assegnare al file il nome utilizzando il nome dell'account di servizio e l'ID progetto, ad esempio: /tmp/creds/${SERVICE_ACCOUNT_NAME}-${PROJECT_ID}.json

    export SERVICE_ACCOUNT_KEY_PATH=LOCAL_KEY_PATH

  6. Scarica il file JSON della chiave privata dell'account di servizio:

    gcloud iam service-accounts keys create ${SERVICE_ACCOUNT_KEY_PATH} \
   --iam-account=${SERVICE_ACCOUNT_NAME}@${PROJECT_ID}.iam.gserviceaccount.com

Registra il cluster

Nel comando seguente, sostituisci MEMBERSHIP_NAME con un nome che rappresenta in modo univoco il cluster che viene registrato sull'hub.

gcloud container hub memberships register MEMBERSHIP_NAME \
    --gke-cluster=${CLUSTER_LOCATION}/${CLUSTER_NAME} \
    --service-account-key-file=${SERVICE_ACCOUNT_KEY_PATH}

Il comando risponde con un output simile al seguente: 

kubeconfig entry generated for CLUSTER_NAME.
Waiting for membership to be created...done.
Created a new membership [projects/PROJECT_ID/locations/global/memberships/MEMBERSHIP_NAME] for the cluster [MEMBERSHIP_NAME]
Generating the Connect Agent manifest...
Deploying the Connect Agent on cluster [MEMBERSHIP_NAME] in namespace [gke-connect]...
Deployed the Connect Agent on cluster [MEMBERSHIP_NAME] in namespace [gke-connect].
Finished registering the cluster [MEMBERSHIP_NAME] with the Hub.

Questa chiave dell'account di servizio è archiviata come secret denominato creds-gcp nello spazio dei nomi gke-connect.

Per ulteriori informazioni sulla registrazione dei cluster, consulta Registrazione di un cluster nella documentazione di Connect.

Download del file di installazione

Prima di continuare, verifica che l'account di servizio del piano dati mesh ASM sia un membro del progetto:

gcloud projects get-iam-policy ${PROJECT_ID} | grep -B 1 'roles/meshdataplane.serviceAgent'

Se il comando precedente non restituisce alcun risultato, torna alla sezione Imposta credenziali e autorizzazioni ed esegui il comando curl.

    Linux

  1. Scarica il file di installazione di Anthos Service Mesh nella directory di lavoro attuale: 
    curl -LO https://storage.googleapis.com/gke-release/asm/istio-1.5.10-asm.2-linux.tar.gz
  2. Scarica il file della firma e utilizza openssl per verificare la firma: 
    curl -LO https://storage.googleapis.com/gke-release/asm/istio-1.5.10-asm.2-linux.tar.gz.1.sig
openssl dgst -verify - -signature istio-1.5.10-asm.2-linux.tar.gz.1.sig istio-1.5.10-asm.2-linux.tar.gz <<'EOF'
-----BEGIN PUBLIC KEY-----
MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEWZrGCUaJJr1H8a36sG4UUoXvlXvZ
wQfk16sxprI2gOJ2vFFggdq3ixF2h4qNBt0kI7ciDhgpwS8t+/960IsIgw==
-----END PUBLIC KEY-----
EOF

    L'output previsto è: Verified OK

  3. Estrai i contenuti del file in qualsiasi posizione nel file system. Ad esempio, per estrarre i contenuti nella directory di lavoro corrente: 
    tar xzf istio-1.5.10-asm.2-linux.tar.gz

    Il comando crea una directory di installazione nell'attuale directory di lavoro denominata istio-1.5.10-asm.2, che contiene:

    • Applicazioni di esempio in samples
    • I seguenti strumenti della directory bin:
      • istioctl: utilizzi istioctl per installare Anthos Service Mesh.
      • asmctl: utilizzi asmctl per convalidare la configurazione di sicurezza dopo l'installazione di Anthos Service Mesh. Attualmente asmctl non è supportato sui cluster Anthos su VMware.

    4. Mac OS

  4. Scarica il file di installazione di Anthos Service Mesh nella directory di lavoro attuale: 
    curl -LO https://storage.googleapis.com/gke-release/asm/istio-1.5.10-asm.2-osx.tar.gz
  5. Scarica il file della firma e utilizza openssl per verificare la firma: 
    curl -LO https://storage.googleapis.com/gke-release/asm/istio-1.5.10-asm.2-osx.tar.gz.1.sig
openssl dgst -sha256 -verify /dev/stdin -signature istio-1.5.10-asm.2-osx.tar.gz.1.sig istio-1.5.10-asm.2-osx.tar.gz <<'EOF'
-----BEGIN PUBLIC KEY-----
MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEWZrGCUaJJr1H8a36sG4UUoXvlXvZ
wQfk16sxprI2gOJ2vFFggdq3ixF2h4qNBt0kI7ciDhgpwS8t+/960IsIgw==
-----END PUBLIC KEY-----
EOF

    L'output previsto è: Verified OK

  6. Estrai i contenuti del file in qualsiasi posizione nel file system. Ad esempio, per estrarre i contenuti nella directory di lavoro corrente: 
    tar xzf istio-1.5.10-asm.2-osx.tar.gz

    Il comando crea una directory di installazione nell'attuale directory di lavoro denominata istio-1.5.10-asm.2, che contiene:

    • Applicazioni di esempio in samples
    • I seguenti strumenti della directory bin:
      • istioctl: utilizzi istioctl per installare Anthos Service Mesh.
      • asmctl: utilizzi asmctl per convalidare la configurazione di sicurezza dopo l'installazione di Anthos Service Mesh. Attualmente asmctl non è supportato sui cluster Anthos su VMware.

    7. Windows

  7. Scarica il file di installazione di Anthos Service Mesh nella directory di lavoro attuale: 
    curl -LO https://storage.googleapis.com/gke-release/asm/istio-1.5.10-asm.2-win.zip
  8. Scarica il file della firma e utilizza openssl per verificare la firma: 
    curl -LO https://storage.googleapis.com/gke-release/asm/istio-1.5.10-asm.2-win.zip.1.sig
openssl dgst -verify - -signature istio-1.5.10-asm.2-win.zip.1.sig istio-1.5.10-asm.2-win.zip <<'EOF'
-----BEGIN PUBLIC KEY-----
MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEWZrGCUaJJr1H8a36sG4UUoXvlXvZ
wQfk16sxprI2gOJ2vFFggdq3ixF2h4qNBt0kI7ciDhgpwS8t+/960IsIgw==
-----END PUBLIC KEY-----
EOF

    L'output previsto è: Verified OK

  9. Estrai i contenuti del file in qualsiasi posizione nel file system. Ad esempio, per estrarre i contenuti nella directory di lavoro corrente: 
    tar xzf istio-1.5.10-asm.2-win.zip

    Il comando crea una directory di installazione nell'attuale directory di lavoro denominata istio-1.5.10-asm.2, che contiene:

    • Applicazioni di esempio in samples
    • I seguenti strumenti della directory bin:
      • istioctl: utilizzi istioctl per installare Anthos Service Mesh.
      • asmctl: utilizzi asmctl per convalidare la configurazione di sicurezza dopo l'installazione di Anthos Service Mesh. Attualmente asmctl non è supportato sui cluster Anthos su VMware.

  10. Assicurati di essere nella directory principale dell'installazione di Anthos Service Mesh. 
    cd istio-1.5.10-asm.2
  11. Per praticità, aggiungi gli strumenti della directory /bin al tuo PERCORSO: 
    export PATH=$PWD/bin:$PATH

Preparazione dei file di configurazione delle risorse

Quando esegui istioctl apply command per installare Anthos Service Mesh, devi specificare -f istio-operator.yaml nella riga di comando. Questo file contiene informazioni sul progetto e sul cluster, necessari per abilitare le funzionalità di telemetria e sicurezza della rete mesh. Devi scaricare il file istio-operator.yaml e altri file di configurazione delle risorse e impostare le informazioni del progetto e del cluster.

Per preparare i file di configurazione delle risorse:

  1. Se non lo hai già fatto, installa kpt:

    gcloud components install kpt

  2. Facoltativamente, crea una nuova directory per i file di configurazione delle risorse del pacchetto Anthos Service Mesh. Se prevedi di configurare più di un cluster, puoi utilizzare il nome del cluster come nome della directory.

  3. Passa alla directory da cui vuoi scaricare il pacchetto Anthos Service Mesh.

  4. Scarica il pacchetto Anthos Service Mesh nella directory di lavoro corrente:

    kpt pkg get \
https://github.com/GoogleCloudPlatform/anthos-service-mesh-packages.git/asm@release-1.5-asm .

  5. Imposta il nome del cluster:

      kpt cfg set asm gcloud.container.cluster ${CLUSTER_NAME}

  6. Facoltativamente, personalizza i file di configurazione delle risorse utilizzando i setter kpt. Per impostazione predefinita, questi set di valori utilizzano i valori predefiniti per gcloud config. Se imposti i valori predefiniti di gcloud config o se vuoi modificare i valori, esegui i seguenti setter:

    • Imposta l'ID progetto:

      kpt cfg set asm gcloud.core.project ${PROJECT_ID}

    • Imposta la zona o la regione predefinita:

      kpt cfg set asm gcloud.compute.location ${CLUSTER_LOCATION}

  7. Facoltativamente, puoi controllare i file di configurazione delle risorse nel tuo sistema di controllo dell'origine, come Cloud Source Repositories, in modo da poter tenere traccia delle modifiche ai file.

Installazione di Anthos Service Mesh

Installare Anthos Service Mesh e impostare le opzioni necessarie per integrare Anthos Service Mesh con IAP.

mTLS CONSENTITO

istioctl manifest apply --set profile=asm \
  -f asm/cluster/istio-operator.yaml \
  --set values.gateways.istio-ingressgateway.type=NodePort

mTLS STRETTA

istioctl manifest apply --set profile=asm \
  -f asm/cluster/istio-operator.yaml \
  --set values.gateways.istio-ingressgateway.type=NodePort \
  --set values.global.mtls.enabled=true

Specifica NodePort per istio-ingressgateway, che configura {[mesh_name]} per aprire una porta specifica nel mesh di servizi. In questo modo puoi configurare un bilanciatore del carico, che instrada il traffico inviato al nome di dominio verso questa porta. Le altre opzioni consentono l'autorità di certificazione (Mesh CA) di Anthos Service Mesh.

Convalida dell'installazione

Ti consigliamo di utilizzare lo strumento di analisi asmctl per convalidare la configurazione di base del progetto, del cluster e dei carichi di lavoro. Se un test asmctl non va a buon fine, asmctl consiglia soluzioni, se possibile. Il comando asmctl validate esegue test di base che controllano:

  1. Che le API richieste da Anthos Service Mesh siano abilitate sul progetto.
  2. Che il traffico Istio-Ingressgateway sia configurato correttamente per chiamare Mesh CA.
  3. Lo stato generale di Istiod e Istio-Ingressgateway.

Se esegui il comando asmctl validate con il flag --with-testing-workloads facoltativo, oltre ai test di base, asmctl esegue test di sicurezza che verificano:

  1. La comunicazione TLS reciproca (mTLS) è configurata correttamente.
  2. Mesh CA può emettere certificati.

Per eseguire i test di sicurezza, asmctl esegue il deployment dei carichi di lavoro sul cluster in uno spazio dei nomi di test, esegue i test di comunicazione mTLS, genera i risultati ed elimina lo spazio dei nomi di test.

Per eseguire asmctl:

  1. Assicurati che siano impostate le credenziali predefinite dell'applicazione gcloud:

     gcloud auth application-default login

  2. Se non l'hai già fatto, ottieni credenziali di autenticazione per interagire con il cluster:

     gcloud container clusters get-credentials ${CLUSTER_NAME}

  3. Per eseguire i test di base e di sicurezza (supponendo che istio-1.5.10-asm.2/bin) sia presente in PATH:

    asmctl validate --with-testing-workloads

    In caso di esito positivo, il comando risponde con un output simile al seguente:

    [asmctl version 0.3.0]
Using Kubernetes context: example-project_us-central1-example-cluster
To change the context, use the --context flag
Validating enabled APIs
OK
Validating ingressgateway configuration
OK
Validating istio system
OK
Validating sample traffic
Launching example services...
Sent traffic to example service http code: 200
verified mTLS configuration
OK
Validating issued certs
OK

Deployment di un'applicazione di esempio

Prima di abilitare IAP, devi avere un'applicazione in esecuzione sul cluster GKE, in modo da poter verificare che tutte le richieste abbiano un'identità. Questa guida utilizza l'esempio Bookinfo per dimostrare come configurare il bilanciatore del carico HTTP(S) e abilitare IAP.

Avviare i servizi per applicazioni

  1. Cambia la directory nella directory principale dell'installazione di Anthos Service Mesh.

  2. Etichetta lo spazio dei nomi default per utilizzare l'iniezione automatica di sidecar:

    kubectl label namespace default istio-injection=enabled

  3. Esegui il deployment dell'applicazione:

    kubectl apply -f samples/bookinfo/platform/kube/bookinfo.yaml

  4. Verifica che tutti i servizi bookinfo siano in esecuzione:

    kubectl get services

    L'output previsto è simile a:

    NAME                       CLUSTER-IP   EXTERNAL-IP   PORT(S)              AGE
details                    10.0.0.31            9080/TCP             6m
kubernetes                 10.0.0.1             443/TCP              7d
productpage                10.0.0.120           9080/TCP             6m
ratings                    10.0.0.15            9080/TCP             6m
reviews                    10.0.0.170           9080/TCP             6m

  5. Verifica che tutti i pod siano in esecuzione:

    kubectl get pods

    L'output previsto è simile a:

    NAME                                        READY     STATUS    RESTARTS   AGE
details-v1-1520924117-48z17                 2/2       Running   0          6m
productpage-v1-560495357-jk1lz              2/2       Running   0          6m
ratings-v1-734492171-rnr5l                  2/2       Running   0          6m
reviews-v1-874083890-f0qf0                  2/2       Running   0          6m
reviews-v2-1343845940-b34q5                 2/2       Running   0          6m
reviews-v3-1813607990-8ch52                 2/2       Running   0          6m

  6. Verifica che l'applicazione Bookinfo sia in esecuzione:

    kubectl exec -it $(kubectl get pod -l app=ratings -o jsonpath='{.items[0].metadata.name}') -c ratings -- curl productpage:9080/productpage | grep -o "<title>.*</title>"

    Output previsto:

    <title>Simple Bookstore App</title>

  7. Definisci il gateway in entrata e il servizio virtuale per l'applicazione:

    kubectl apply -f samples/bookinfo/networking/bookinfo-gateway.yaml

  8. Verifica che il gateway sia stato creato:

    kubectl get gateway

    L'output previsto è simile a:

    NAME                AGE
bookinfo-gateway    32s

Richieste esterne

La risorsa Gateway di Bookinfo (definita in samples/bookinfo/networking/bookinfo-gateway.yaml) utilizza il metodo istio-ingressgateway preconfigurato. Ricorda che quando hai eseguito il deployment di Anthos Service Mesh, hai specificato NodePort per istio-ingressgateway, che apre una porta specifica nel mesh di servizi. Fino a quando non configuri il bilanciatore del carico, l'applicazione Bookinfo non è accessibile all'esterno del tuo cluster GKE (ad esempio da un browser). Anche se i nodi nel tuo cluster hanno indirizzi IP esterni, le richieste provenienti dall'esterno del tuo cluster sono bloccate dalle regole firewall di Google Cloud. Con IAP, il modo corretto per esporre questa applicazione alla rete Internet pubblica è utilizzare un bilanciatore del carico. Non esporre gli indirizzi dei nodi utilizzando regole firewall, in modo da ignorare IAP.

Per indirizzare le richieste a Bookinfo, configura un bilanciatore del carico HTTP(S) nel progetto Google Cloud. Poiché il bilanciatore del carico si trova nel tuo progetto, si trova all'interno del firewall e può accedere ai nodi nel tuo cluster. Dopo aver configurato il bilanciatore del carico con l'indirizzo IP statico e il nome di dominio, puoi inviare richieste al nome di dominio e il bilanciatore del carico inoltra le richieste ai nodi nel cluster.

Deployment del bilanciatore del carico

Puoi utilizzare una risorsa in entrata per creare un bilanciatore del carico HTTP(S) con certificati SSL configurati automaticamente. I certificati SSL gestiti da Google vengono forniti, rinnovati e gestiti per il tuo dominio.

  1. Creare una risorsa ManagedCertificate. Questa risorsa specifica il dominio per il certificato SSL. L'elenco spec.domains deve contenere un solo dominio. I domini con caratteri jolly non sono supportati.

    cat <<EOF | kubectl apply -f -
apiVersion: networking.gke.io/v1beta1
kind: ManagedCertificate
metadata:
  name: example-certificate
  namespace: istio-system
spec:
  domains:
    - ${DOMAIN_NAME}
EOF

  2. Crea il bilanciatore del carico definendo la risorsa Ingress.

    • Imposta l'annotazione networking.gke.io/managed-certificates sul nome del certificato che hai creato nel passaggio precedente, example-certificate.

    • Imposta l'annotazione kubernetes.io/ingress.global-static-ip-name sul nome dell'indirizzo IP statico prenotato, example-static-ip.

    • Imposta serviceName su istio-ingressgateway, che viene utilizzato nella risorsa Gateway per l'esempio di Bookinfo.

    cat <<EOF | kubectl create -f -
apiVersion: extensions/v1beta1
kind: Ingress
metadata:
  name: example-ingress
  namespace: istio-system
  annotations:
    kubernetes.io/ingress.global-static-ip-name: example-static-ip
    networking.gke.io/managed-certificates: example-certificate
spec:
  backend:
    serviceName: istio-ingressgateway
    servicePort: 80
EOF

  3. Nella console Google Cloud, vai alla pagina Kubernetes Engine > Servizi e Ingress.

    Vai alla pagina Servizi e Ingress

    Dovresti visualizzare il messaggio "Creazione del traffico in entrata" nella colonna Stato. Attendi che GKE esegua il provisioning completo della risorsa Ingress prima di continuare. Aggiorna la pagina a intervalli di pochi minuti per ottenere lo stato più aggiornato sulla risorsa Ingress. Dopo aver eseguito il provisioning della risorsa Ingress, potresti visualizzare lo stato "Ok" o l'errore "Tutti i servizi di backend sono in stato NON SALUTE". Una delle risorse di cui GKE esegue il provisioning è un controllo di integrità predefinito. Se viene visualizzato un messaggio di errore, significa che è stato eseguito il provisioning della risorsa Ingress e che è stato eseguito il controllo di integrità predefinito. Quando vedi lo stato "Ok" o l'errore, continua con la sezione successiva per configurare i controlli di integrità per il bilanciatore del carico.

Configurare i controlli di integrità per il bilanciatore del carico.

Per configurare i controlli di integrità, devi ottenere l'ID del controllo di integrità predefinito creato dalla risorsa Ingress, quindi aggiornare il controllo di integrità in modo da utilizzare il percorso e la porta del controllo di integrità di Istio-Ingress.

  1. Recupera le nuove credenziali utente da utilizzare per le credenziali predefinite dell'applicazione:

      gcloud auth application-default login

  2. Ottieni l'ID del controllo di integrità predefinito creato dalla risorsa Ingress:

    1. Imposta le seguenti variabili di ambiente:

      • Servizio di backend: collega vari gruppi di istanze su una determinata NodePort di servizio. 

        BACKEND_SERVICE=$(gcloud compute url-maps list | grep example-ingress | awk '{print $2}' | cut -d'/' -f 2)

      • Controllo di integrità: si tratta del controllo di integrità predefinito che viene creato automaticamente al deployment di Ingress. 

        HC=$(gcloud compute backend-services describe ${BACKEND_SERVICE} --global | grep healthChecks | cut -d'/' -f 10 | tail -n 1)

      • Porta di controllo di integrità: è la porta di controllo di integrità in entrata. 

        export HC_INGRESS_PORT=$(kubectl -n istio-system get service istio-ingressgateway -o jsonpath='{.spec.ports[?(@.name=="status-port")].nodePort}')

      • Percorso di controllo di integrità: è il percorso di controllo dell'integrità di istio-ingress. 

        export HC_INGRESS_PATH=$(kubectl -n istio-system get deployments istio-ingressgateway -o jsonpath='{.spec.template.spec.containers[?(@.name=="istio-proxy")].readinessProbe.httpGet.path}')

      • API Controllo di integrità: si tratta dell'API che chiami per configurare il controllo di integrità. 
        export HC_API=https://compute.googleapis.com/compute/v1/projects/${PROJECT_ID}/global/healthChecks/${HC}

    2. Ottieni il controllo di integrità predefinito in un file JSON chiamando l'API healthChecks:

      curl --request GET  --header "Authorization: Bearer $(gcloud auth application-default print-access-token)" ${HC_API} > health_check.json

  3. Aggiorna il controllo di integrità per utilizzare il percorso e la porta del controllo di integrità istio-ingress:

    1. Aggiorna il file health_check.json come indicato di seguito:

      • Imposta httpHealthCheck.port sul valore di ${HC_INGRESS_PORT}.
      • Imposta httpHealthCheck.requestPath sul valore di ${HC_INGRESS_PATH}.
      • Aggiungi il seguente attributo e impostalo su una stringa vuota: httpHealthCheck.portSpecification=""

      Il modo più semplice per farlo è utilizzare jq, che è preinstallato in Cloud Shell:

      jq ".httpHealthCheck.port=${HC_INGRESS_PORT} | .httpHealthCheck.requestPath=\"${HC_INGRESS_PATH}\" | .httpHealthCheck.portSpecification=\"\"" health_check.json > updated_health_check.json

      Se esegui cat sul file updated_health_check.json risultante, sarà simile al seguente:

      {
"id": "5062913090021441698",
"creationTimestamp": "2019-11-12T10:47:41.934-08:00",
"name": "${HC}",
"description": "Default kubernetes L7 Loadbalancing health check.",
"checkIntervalSec": 60,
"timeoutSec": 60,
"unhealthyThreshold": 10,
"healthyThreshold": 1,
"type": "HTTP",
"httpHealthCheck": {
  "port": 32394,
  "requestPath": "/healthz/ready",
  "proxyHeader": "NONE",
  "portSpecification": ""
},
"selfLink": "https://www.googleapis.com/compute/v1/projects/${PROJECT_ID}/global/healthChecks/${HC}",
"kind": "compute#healthCheck"
}

      Se hai modificato il file JSON manualmente invece di utilizzare il comando jq, salva il file come updated_health_check.json in modo che corrisponda al nome del file nel comando successivo.

    2. Aggiorna il controllo di integrità:

      curl --request PATCH --header "Authorization: Bearer $(gcloud auth application-default print-access-token)" --header "Content-Type: application/json" --data @updated_health_check.json ${HC_API}

    GKE impiega diversi minuti per aggiornare il controllo di integrità. Nella console Google Cloud, aggiorna ogni minuto la pagina Kubernetes Engine > Servizi e Ingress finché lo stato della risorsa Ingress non passa a "OK".

  4. Testa il bilanciatore del carico. Punta il browser a:

    http://YOUR_DOMAIN_NAME/productpage

    dove YOUR_DOMAIN_NAME è il nome di dominio che hai configurato con l'indirizzo IP statico esterno.

    Dovresti vedere la productpage dell'applicazione Bookinfo. Se aggiorni la pagina più volte, dovresti vedere diverse versioni delle recensioni, presentate in stile round robin: stelle rosse, stelle nere, nessuna stella.

    Devi anche testare l'accesso di https a Bookinfo.

Abilitazione di IAP

I seguenti passaggi descrivono come abilitare IAP.

  1. Controlla se hai già un brand utilizzando il comando list. Puoi avere un solo brand per progetto.

    gcloud iap oauth-brands list

    Di seguito è riportato un esempio di risposta gcloud, se il brand esiste:

    name: projects/[PROJECT_NUMBER]/brands/[BRAND_ID]
applicationTitle: [APPLICATION_TITLE]
supportEmail: [SUPPORT_EMAIL]
orgInternalOnly: true

  2. Se non esiste alcun brand, utilizza il comando create:

    gcloud iap oauth-brands create --application_title=APPLICATION_TITLE --support_email=SUPPORT_EMAIL

    I campi precedenti sono obbligatori quando chiami questa API:

    • supportEmail: l'email dell'assistenza visualizzata nella schermata per il consenso OAuth. Può trattarsi dell'indirizzo di un utente o di un alias di Google Gruppi. Anche se gli account di servizio hanno un indirizzo email, non sono indirizzi email validi e non possono essere utilizzati durante la creazione di un brand. Tuttavia, un account di servizio può essere il proprietario di un gruppo Google. Crea un nuovo gruppo Google o configura un gruppo esistente e imposta l'account di servizio desiderato come proprietario del gruppo.

    • applicationTitle: il nome dell'applicazione visualizzato nella schermata per il consenso OAuth.

    La risposta contiene i seguenti campi:

    name: projects/[PROJECT_NUMBER]/brands/[BRAND_ID]
applicationTitle: [APPLICATION_TITLE]
supportEmail: [SUPPORT_EMAIL]
orgInternalOnly: true

Creazione di un client OAuth IAP

  1. Utilizza il comando Crea per creare un client. Utilizza il brand name del passaggio precedente.

    gcloud iap oauth-clients create projects/PROJECT_NUMBER/brands/BRAND-ID --display_name=NAME

    La risposta contiene i seguenti campi:

    name: projects/[PROJECT_NUMBER]/brands/[BRAND_NAME]/identityAwareProxyClients/[CLIENT_ID]
secret: [CLIENT_SECRET]
displayName: [NAME]

Attivazione di IAP per il servizio

Utilizza il comando seguente per attivare IAP per il tuo servizio. Sostituisci CLIENT_ID e CLIENT_SECRET con il tuo ID client OAuth e il client secret del client creato in precedenza.

gcloud beta iap web enable \
    --oauth2-client-id=CLIENT_ID \
    --oauth2-client-secret=CLIENT_SECRET \
    --resource-type=backend-services \
    --service=${BACKEND_SERVICE}

Configura l'elenco di accesso IAP

Aggiungi un utente al criterio di accesso per IAP:

gcloud beta iap web add-iam-policy-binding \
    --member=user:EMAIL_ADDRESS \
    --role=roles/iap.httpsResourceAccessor \
    --resource-type=backend-services \
    --service=$BACKEND_SERVICE

dove EMAIL_ADDRESS è l'indirizzo email completo dell'utente, ad esempio alice@example.com.

Abilita il supporto RCToken sul mesh di servizi

Per impostazione predefinita, IAP genera un token web JSON (JWT) che ha come ambito il client OAuth. Per Anthos Service Mesh, puoi configurare IAP per generare un RequestContextToken (RCToken), che è un JWT ma con un pubblico configurabile. RCToken ti consente di configurare il pubblico di JWT con una stringa arbitraria, che può essere utilizzata nei criteri Anthos Service Mesh per un'autorizzazione granulare.

Per configurare RCToken:

  1. Crea una variabile di ambiente per il numero di progetto. Si tratta del numero che è stato generato e assegnato automaticamente al progetto quando lo hai creato. (non corrisponde all'ID progetto).

    export PROJECT_NUMBER=YOUR_PROJECT_NUMBER

  2. Crea una variabile di ambiente per il segmento di pubblico RCToken. Puoi scegliere qualsiasi stringa.

    export RCTOKEN_AUD="your-rctoken-aud"

  3. Recupera le impostazioni IAP esistenti

    gcloud beta iap settings get --format json \
--project=${PROJECT_NUMBER} --resource-type=compute \
--service=${BACKEND_SERVICE} > iapSettings.json

  4. Aggiorna IapSettings con il pubblico RCToken.

    cat iapSettings.json | jq --arg RCTOKEN_AUD_STR $RCTOKEN_AUD \
'. + {applicationSettings: {csmSettings: {rctokenAud: $RCTOKEN_AUD_STR}}}' \
> updatedIapSettings.json

    gcloud beta iap settings set updatedIapSettings.json --format json \
--project=${PROJECT_NUMBER} --resource-type=compute --service=${BACKEND_SERVICE}

  5. Abilita l'autenticazione RCToken sul gateway in entrata Istio.

    cat <<EOF | kubectl apply -f -
apiVersion: "authentication.istio.io/v1alpha1"
kind: "Policy"
metadata:
  name: "ingressgateway"
  namespace: istio-system
spec:
  targets:
  - name: "istio-ingressgateway"
  origins:
  - jwt:
      issuer: "https://cloud.google.com/iap"
      jwksUri: "https://www.gstatic.com/iap/verify/public_key-jwk"
      audiences:
      - "$RCTOKEN_AUD"
      jwt_headers:
      - "ingress-authorization"
      trigger_rules:
      - excluded_paths:
        - exact: /healthz/ready
  principalBinding: USE_ORIGIN
EOF

  6. Assicurati che le richieste al Bookinfo productpage abbiano ancora esito positivo:

    http://DOMAIN_NAME/productpage

Per testare il criterio:

  1. Crea un oggetto di richiesta IapSettings, ma imposta rctokenAud su una stringa diversa:

    echo $(cat <<EOF
{
   "name": "projects/${PROJECT_NUMBER}/iap_web/compute/services/${BACKEND_SERVICE}",
   "applicationSettings": {
     "csmSettings": {
       "rctokenAud": "some-other-arbitrary-string"
     }
   }
 }
EOF
) > request.txt

  2. Chiama l'API IapSettings per impostare il segmento di pubblico RCtoken.

    curl --request PATCH --header "Authorization: Bearer $(gcloud beta auth application-default print-access-token)" ${IAP_SETTINGS_API}

  3. Invia una richiesta al BookInfo productpage e questa non andrà a buon fine:

    http://DOMAIN_NAME/productpage

Eseguire la pulizia

Dopo aver completato questo tutorial, rimuovi le seguenti risorse per evitare che al tuo account vengano addebitati costi indesiderati:

  1. Elimina il certificato gestito:

    kubectl delete managedcertificates example-certificate

  2. Elimina il traffico Ingress, che alloca le risorse di bilanciamento del carico: 

    kubectl -n istio-system delete ingress example-ingress

  3. Elimina l'indirizzo IP statico: 

    gcloud compute addresses delete example-static-ip --global

    In questo caso, assicurati di eliminare l'indirizzo IP dal registrar di dominio.

  4. Elimina il cluster, che elimina le risorse che compongono il cluster, ad esempio istanze di calcolo, dischi e risorse di rete: 

    gcloud container clusters delete ${CLUSTER_NAME}