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

Se hai già installato gcloud CLI:

  1. Esegui l'autenticazione con l'interfaccia alla gcloud 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

Questa sezione spiega le nozioni di base per la creazione di un cluster GKE con le opzioni necessarie per Anthos Service Mesh. Per ulteriori informazioni, consulta la sezione Creazione di un cluster.

Per configurare un nuovo cluster:

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

    • Se creerai un cluster a zona singola, esegui il comando seguente per ottenere un elenco delle zone GCP disponibili:

      gcloud compute zones list

    • Se creerai un cluster a livello di regione, esegui questo comando per ottenere un elenco delle regioni disponibili:

      gcloud compute regions 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 o sulla regione del cluster:

      export CLUSTER_LOCATION=YOUR_ZONE_OR_REGION

    • 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}"

    • Imposta il canale di rilascio. Sostituisci YOUR_CHANNEL con uno dei seguenti elementi:regular, stable o rapid.

      export CHANNEL=YOUR_CHANNEL

      Per una descrizione di ciascun canale, vedi Canali disponibili.

  3. Imposta la zona o la regione predefinita per Google Cloud CLI.

    • Per un cluster a zona singola, imposta la zona predefinita:

      gcloud config set compute/zone ${CLUSTER_LOCATION}

    • Per un cluster a livello di area geografica, imposta la regione predefinita:

      gcloud config set compute/region ${CLUSTER_LOCATION}

    Suggerimento: per semplificare la configurazione dell'ambiente shell in futuro, puoi copiare e incollare le istruzioni export per ogni variabile di ambiente in un semplice script shell source quando avvii una nuova shell. Puoi anche aggiungere i comandi gcloud che impostano valori predefiniti allo script. In alternativa, puoi utilizzare gcloud init per creare e attivare una configurazione gcloud denominata.

  4. Crea il cluster con le opzioni richieste da Anthos Service Mesh. Il comando seguente crea un cluster contenente 4 nodi di tipo di macchina e2-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} \
    --machine-type=e2-standard-4 \
    --num-nodes=4 \
    --workload-pool=${WORKLOAD_POOL} \
    --enable-stackdriver-kubernetes \
    --subnetwork=default \
    --labels=mesh_id=${MESH_ID} \
    --release-channel=${CHANNEL}

    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 sulle pagine di Anthos Service Mesh nella console Google Cloud.

    • release-channel ${CHANNEL}: registra il cluster nel canale di rilascio specificato.

Preparazione dell'installazione di Anthos Service Mesh

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.4.10-asm.18-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.4.10-asm.18-linux.tar.gz.1.sig
openssl dgst -verify - -signature istio-1.4.10-asm.18-linux.tar.gz.1.sig istio-1.4.10-asm.18-linux.tar.gz <<'EOF'
-----BEGIN PUBLIC KEY-----
MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEWZrGCUaJJr1H8a36sG4UUoXvlXvZ
wQfk16sxprI2gOJ2vFFggdq3ixF2h4qNBt0kI7ciDhgpwS8t+/960IsIgw==
-----END PUBLIC KEY-----
EOF

    L'output previsto è: Verified OK

    3. Mac OS

  3. 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.4.10-asm.18-osx.tar.gz
  4. Scarica il file della firma e utilizza openssl per verificare la firma: 
    curl -LO https://storage.googleapis.com/gke-release/asm/istio-1.4.10-asm.18-osx.tar.gz.1.sig
openssl dgst -sha256 -verify /dev/stdin -signature istio-1.4.10-asm.18-osx.tar.gz.1.sig istio-1.4.10-asm.18-osx.tar.gz <<'EOF'
-----BEGIN PUBLIC KEY-----
MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEWZrGCUaJJr1H8a36sG4UUoXvlXvZ
wQfk16sxprI2gOJ2vFFggdq3ixF2h4qNBt0kI7ciDhgpwS8t+/960IsIgw==
-----END PUBLIC KEY-----
EOF

    L'output previsto è: Verified OK

    5. Windows

  5. 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.4.10-asm.18-win.zip
  6. Scarica il file della firma e utilizza openssl per verificare la firma: 
    curl -LO https://storage.googleapis.com/gke-release/asm/istio-1.4.10-asm.18-win.zip.1.sig
openssl dgst -verify - -signature istio-1.4.10-asm.18-win.zip.1.sig istio-1.4.10-asm.18-win.zip <<'EOF'
-----BEGIN PUBLIC KEY-----
MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEWZrGCUaJJr1H8a36sG4UUoXvlXvZ
wQfk16sxprI2gOJ2vFFggdq3ixF2h4qNBt0kI7ciDhgpwS8t+/960IsIgw==
-----END PUBLIC KEY-----
EOF

    L'output previsto è: Verified OK

  7. 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.4.10-asm.18-linux.tar.gz

    Il comando crea una directory di installazione nell'attuale directory di lavoro denominata istio-1.4.10-asm.18, 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.

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

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 \
  --set values.gateways.istio-ingressgateway.type=NodePort \
  --set values.global.trustDomain=${WORKLOAD_POOL} \
  --set values.global.sds.token.aud=${WORKLOAD_POOL} \
  --set values.nodeagent.env.GKE_CLUSTER_URL=https://container.googleapis.com/v1/projects/${PROJECT_ID}/locations/${CLUSTER_LOCATION}/clusters/${CLUSTER_NAME} \
  --set values.global.meshID=${MESH_ID} \
  --set values.global.proxy.env.GCP_METADATA="${PROJECT_ID}|${PROJECT_NUMBER}|${CLUSTER_NAME}|${CLUSTER_LOCATION}"

mTLS STRETTA

istioctl manifest apply --set profile=asm \
  --set values.gateways.istio-ingressgateway.type=NodePort \
  --set values.global.trustDomain=${WORKLOAD_POOL} \
  --set values.global.sds.token.aud=${WORKLOAD_POOL} \
  --set values.nodeagent.env.GKE_CLUSTER_URL=https://container.googleapis.com/v1/projects/${PROJECT_ID}/locations/${CLUSTER_LOCATION}/clusters/${CLUSTER_NAME} \
  --set values.global.meshID=${MESH_ID} \
  --set values.global.proxy.env.GCP_METADATA="${PROJECT_ID}|${PROJECT_NUMBER}|${CLUSTER_NAME}|${CLUSTER_LOCATION}" \
  --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.

Controlla i componenti del piano di controllo

Verifica che i pod del piano di controllo in istio-system siano aumentati:

kubectl get pod -n istio-system

Dovresti vedere un output simile al seguente:

NAME                                      READY   STATUS      RESTARTS   AGE
istio-galley-5c65896ff7-m2pls             2/2     Running     0          18m
istio-ingressgateway-587cd459f-q6hqt      2/2     Running     0          18m
istio-nodeagent-74w69                     1/1     Running     0          18m
istio-nodeagent-7524w                     1/1     Running     0          18m
istio-nodeagent-7652w                     1/1     Running     0          18m
istio-nodeagent-7948w                     1/1     Running     0          18m
istio-pilot-9db77b99f-7wfb6               2/2     Running     0          18m
istio-sidecar-injector-69c4d9f875-dt8rn   1/1     Running     0          18m
promsd-55f464d964-lqs7w                   2/2     Running     0          18m

Dovresti vedere un'istanza di istio-nodeagent per ogni nodo nel tuo cluster. Mesh CA, che sostituisce il componente Istio Citadel OSS, crea gli agenti nodo per emettere certificati mTLS per i carichi di lavoro in esecuzione nel mesh di servizi.

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

Attivazione dei criteri di sicurezza dei pod

Se abiliti i criteri di sicurezza dei pod, ti assicuri che gli spazi dei nomi compromessi (diversi da istio-system) non influiscano sulla sicurezza degli altri spazi dei nomi che condividono gli stessi nodi. Esempi di file di risorse PodSecurityPolicy che funzionano con Mesh CA sono forniti con Anthos Service Mesh. Puoi modificare questi file in base alle esigenze. Nel seguente, applichi prima i criteri di sicurezza dei pod, quindi abiliti i criteri di sicurezza dei pod per il cluster GKE.

  1. Applica il criterio di sicurezza dei pod predefinito per tutti gli account di servizio nel cluster:

    kubectl apply -f "samples/security/psp/all-pods-psp.yaml"

  2. Applica il criterio di sicurezza dei pod per proteggere il Secret Discovery Service (SDS):

    kubectl apply -f "samples/security/psp/citadel-agent-psp.yaml"

    Questo assegna all'agente Citadel (chiamato anche agente nodo) il privilegio di creare il percorso UDS /var/run/sds sulla VM host.

  3. Esegui questo comando per abilitare il criterio di sicurezza dei pod:

    gcloud beta container clusters update ${CLUSTER_NAME} \
    --enable-pod-security-policy

    L'attivazione dei criteri di sicurezza dei pod potrebbe richiedere diversi minuti. Durante questo processo, i carichi di lavoro esistenti non potranno connettersi al master Kubernetes. Attendi finché il master Kubernetes non si avvia di nuovo. Puoi controllare lo stato del cluster nella console Google Cloud nella pagina Cluster Kubernetes.

    Per ulteriori informazioni, consulta la pagina relativa all'utilizzo dei criteri di sicurezza dei pod.

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}