Creare un cluster GKE con Cloud Service Mesh e gcloud CLI

In questo tutorial esegui il provisioning di Cloud Service Mesh gestito utilizzando l'API Fleet di Google Kubernetes Engine (GKE) su un nuovo cluster pubblico GKE. Questo tutorial illustra:

  1. Configurazione del Google Cloud progetto.
  2. Creare un cluster GKE con il numero minimo di vCPU richiesto da Cloud Service Mesh.
  3. Registrazione del cluster GKE nel parco risorse del progetto.
  4. Esegui il provisioning di Cloud Service Mesh gestito sul cluster utilizzando l'API Fleet.
  5. Esegui il deployment di un gateway in entrata per esporre l'applicazione.
  6. Esegui il deployment di un'applicazione di esempio per poter visualizzare i dati di telemetria nelle dashboard di Cloud Service Mesh nella Google Cloud console.
  7. Esposizione e accesso all'applicazione di esempio.

API Fleet

Questa guida presuppone che tu abbia familiarità con i parchi risorse, ovvero raggruppamenti logici di cluster GKE e altre risorse che possono essere gestiti insieme. Un parco risorse è un concetto di GKE, non di Kubernetes. La registrazione di un cluster a un parco risorse ti consente di eseguire il provisioning di Cloud Service Mesh gestito su quel cluster utilizzando il comando gcloud container fleet mesh update. L'utilizzo dei parchi è abilitato dall'API Fleet (gkehub.googleapis.com), che viene attivata all'inizio di questo tutorial.

Costi

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

Per generare una stima dei costi in base all'utilizzo previsto, utilizza il Calcolatore prezzi. I nuovi Google Cloud utenti potrebbero avere diritto a una prova gratuita.

Al termine di questa guida introduttiva, puoi evitare la fatturazione continua eliminando il cluster. Per ulteriori informazioni, vedi Pulizia.

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. In the Google Cloud console, on the project selector page, select or create a Google Cloud project.

    Go to project selector

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

  4. Enable the GKE, Fleet (GKE Hub), and Cloud Service Mesh APIs.

    Enable the APIs

    5.

  5. In the Google Cloud console, on the project selector page, select or create a Google Cloud project.

    Go to project selector

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

  7. Enable the GKE, Fleet (GKE Hub), and Cloud Service Mesh APIs.

    Enable the APIs

    8.
  8. Prendi nota del ID progetto.

    9. Installa gli strumenti richiesti

    Puoi eseguire lo strumento su Cloud Shell o sulla tua macchina locale. Cloud Shell preinstalla tutti gli strumenti necessari.

    Cloud Shell

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

    • Cloud Shell include gcloud, kubectl, git e gli altri strumenti a riga di comando di cui hai bisogno.

    • La home directory $HOME di Cloud Shell ha uno spazio di archiviazione permanente di 5 GB.

    • Puoi scegliere tra diversi 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 accedi dalla riga di comando in Cloud Shell.

    In the Google Cloud console, activate Cloud Shell.

    Activate Cloud Shell

    At the bottom of the Google Cloud console, a Cloud Shell session starts and displays a command-line prompt. Cloud Shell is a shell environment with the Google Cloud CLI already installed and with values already set for your current project. It can take a few seconds for the session to initialize.

    Computer locale

    1. Assicurati di avere installato i seguenti strumenti:

    2. Esegui l'autenticazione con Google Cloud CLI:

      gcloud auth login --project PROJECT_ID

    3. Aggiorna i componenti:

      gcloud components update

    Creare un cluster GKE

    1. Esegui il comando seguente per creare il cluster con il numero minimo di vCPU richieste da Cloud Service Mesh. Nel comando, sostituisci i segnaposto con le seguenti informazioni:

      • CLUSTER_NAME: il nome del tuo cluster. Il nome può contenere solo caratteri alfanumerici minuscoli e -, deve iniziare con una lettera e terminare con un carattere alfanumerico e non deve superare i 40 caratteri.
      • PROJECT_ID: l'ID progetto in cui verrà creato il cluster.
      • CLUSTER_LOCATION: la zona del cluster, ad esempio us-central1-a.
      gcloud container clusters create CLUSTER_NAME \
    --project=PROJECT_ID \
    --zone=CLUSTER_LOCATION \
    --machine-type=e2-standard-4 \
    --num-nodes=2 \
    --workload-pool=PROJECT_ID.svc.id.goog

      La creazione del cluster richiede diversi minuti. Durante la creazione del cluster, il comando gcloud mostra quanto segue:

      Creating cluster CLUSTER_NAME in CLUSTER_LOCATION...working...

      L'output previsto in caso di creazione riuscita è simile al seguente:

      Creating cluster CLUSTER_NAME in CLUSTER_LOCATION...done.
Created [https://container.googleapis.com/v1/projects/PROJECT_ID/zones/CLUSTER_LOCATION/clusters/CLUSTER_NAME].
To inspect the contents of your cluster, go to: https://console.cloud.google.com/kubernetes/workload_/gcloud/CLUSTER_LOCATION/CLUSTER_NAME?project=PROJECT_ID
kubeconfig entry generated for CLUSTER_NAME.
NAME: CLUSTER_NAME
LOCATION: CLUSTER_LOCATION
MASTER_VERSION: 1.20.10-gke.1600
MASTER_IP: 198.51.100.1
MACHINE_TYPE: e2-standard-4
NODE_VERSION: 1.20.10-gke.1600
NUM_NODES: 2
STATUS: RUNNING

    2. Recupera le credenziali di autenticazione per interagire con il cluster.

      gcloud container clusters get-credentials CLUSTER_NAME \
    --project=PROJECT_ID \
    --zone=CLUSTER_LOCATION

      Risultato previsto:

      Fetching cluster endpoint and auth data.
kubeconfig entry generated for CLUSTER_NAME.

    3. Imposta il contesto corrente per kubectl sul cluster.

      kubectl config set-context CLUSTER_NAME

      Risultato previsto:

      Context "CLUSTER_NAME" created.

    Esegui il provisioning di Cloud Service Mesh

    Se non hai chiuso questa pagina da quando hai creato il cluster, i segnaposto hanno i valori che hai inserito per il comando gcloud container clusters create.

    1. Abilita Cloud Service Mesh nel parco risorse del tuo progetto.

      gcloud container fleet mesh enable --project PROJECT_ID

      L'output è simile al seguente:

      Waiting for Feature Service Mesh to be created...done.

    2. Registra il cluster nel parco risorse del progetto:

      gcloud container fleet memberships register CLUSTER_NAME-membership \
  --gke-cluster=CLUSTER_LOCATION/CLUSTER_NAME \
  --enable-workload-identity \
  --project PROJECT_ID

      L'output è simile al seguente:

       Waiting for membership to be created...done.
 Finished registering to the Fleet.

    3. Esegui il provisioning di Cloud Service Mesh gestito sul cluster utilizzando l'API Fleet:

      gcloud container fleet mesh update \
  --management automatic \
  --memberships CLUSTER_NAME-membership \
  --project PROJECT_ID

      L'output è simile al seguente:

      Waiting for Feature Service Mesh to be updated...done.

    4. Verifica che Cloud Service Mesh gestito sia stato attivato per il cluster e sia pronto per l'uso:

      gcloud container fleet mesh describe --project PROJECT_ID

      Il provisioning di Cloud Service Mesh e la relativa disponibilità per l'utilizzo sul cluster possono richiedere circa 10 minuti. Se vedi controlPlaneManagement.state: DISABLED o controlPlaneManagement.state: PROVISIONING, dovrai eseguire di nuovo il comando precedente ogni pochi minuti finché non vedi controlPlaneManagement.state: ACTIVE.

      L'output è simile al seguente:

      createTime: '2022-07-06T01:05:39.110120474Z'
membershipSpecs:
  projects/123456789123/locations/global/memberships/your-cluster-membership:
    mesh:
      management: MANAGEMENT_AUTOMATIC
membershipStates:
  projects/123456789123/locations/global/memberships/your-cluster-membership:
    servicemesh:
      controlPlaneManagement:
        details:
        - code: REVISION_READY
          details: 'Ready: asm-managed'
        state: ACTIVE
      dataPlaneManagement:
        details:
        - code: OK
          details: Service is running.
        state: ACTIVE
    state:
      code: OK
      description: 'Revision(s) ready for use: asm-managed.'
      updateTime: '2022-07-06T01:19:24.243993678Z'
name: projects/your-project-id/locations/global/features/servicemesh
resourceState:
  state: ACTIVE
spec: {}
state:
  state: {}
updateTime: '2022-07-06T01:19:27.475885687Z'

    Scarica il codice campione

    Clona il repository Git contenente il codice di esempio utilizzato in questo tutorial:

       git clone https://github.com/GoogleCloudPlatform/anthos-service-mesh-packages.git

    Le sezioni successive di questo tutorial utilizzano una variabile DIR_PATH. Imposta questa variabile sul percorso del repository anthos-service-mesh-packages che hai clonato (ad esempio ./anthos-service-mesh-packages).

    Esegui il deployment di un gateway di ingresso

    Cloud Service Mesh ti offre la possibilità di eseguire il deployment e gestire i gateway all'interno del tuo mesh di servizi. Un gateway descrive un bilanciatore del carico che opera all'esterno della rete mesh e riceve connessioni HTTP/TCP in entrata o in uscita. I gateway sono proxy Envoy che ti offrono un controllo granulare sul traffico in entrata e in uscita dal mesh.

    1. Crea un nome di spazio per il gateway di ingresso se non ne hai già uno. I gateway sono carichi di lavoro utente e, come best practice, non devono essere eseguiti nel spazio dei nomi del piano di controllo. Sostituisci GATEWAY_NAMESPACE con il nome dello spazio dei nomi.

      kubectl create namespace GATEWAY_NAMESPACE

      Risultato previsto:

      namespace/GATEWAY_NAMESPACE created

    2. Attiva l'iniezione automatica sul gateway. I passaggi richiesti dipendono dal fatto che tu voglia utilizzare le etichette di inserimento predefinite (ad es. istio-injection=enabled) o l'etichetta di revisione nello spazio dei nomi del gateway. Il tag di revisione e l'etichetta di revisione predefiniti vengono utilizzati dall'webhook dell'iniettore sidecar per associare i proxy iniettati a una determinata revisione del piano di controllo.

      Etichette di inserimento predefinite

      Applica le etichette di inserimento predefinite allo spazio dei nomi.

      kubectl label namespace GATEWAY_NAMESPACE istio-injection=enabled istio.io/rev-

      Etichetta revisione

      1. Utilizza il seguente comando per individuare l'etichetta di revisione su istiod:

        kubectl get deploy -n istio-system -l app=istiod -o \
  "jsonpath={.items[*].metadata.labels['istio\.io/rev']}{'\n'}"

        Il comando restituisce l'etichetta di revisione corrispondente alla versione di Cloud Service Mesh, ad esempio: asm-11910-9

      2. Applica l'etichetta di revisione allo spazio dei nomi. Nel seguente comando, REVISION è il valore dell'etichetta della revisione istiod che hai annotato nel passaggio precedente.

        kubectl label namespace GATEWAY_NAMESPACE \
  istio.io/rev=REVISION --overwrite

        Risultato previsto:

        namespace/GATEWAY_NAMESPACE labeled

      Puoi ignorare il messaggio "istio.io/rev" not found nell'output. Ciò significa che in precedenza lo spazio dei nomi non aveva l'etichetta istio.io/rev, che dovresti aspettarti nelle nuove installazioni di Cloud Service Mesh o nei nuovi deployment. Poiché l'iniezione automatica non va a buon fine se uno spazio dei nomi ha sia l'etichetta istio.io/rev sia l'etichetta istio-injection, tutti i comandi kubectl label nella documentazione di Cloud Service Mesh specificano esplicitamente entrambe le etichette.

      Se lo spazio dei nomi del gateway non è etichettato, i pod istio-ingressgateway non andranno a buon fine con un errore ImagePullBackOff quando il gateway tenta di estrarre l'immagine auto. Questa immagine deve essere sostituita dall'webhook.

    3. Scarica il file di configurazione .yaml del gateway di ingresso di esempio dal repository anthos-service-mesh-packages.

    4. Applica la configurazione .yaml del gateway in entrata di esempio così com'è o modificala come necessario.

      kubectl apply -n GATEWAY_NAMESPACE \
  -f CONFIG_PATH/istio-ingressgateway

      Risultato previsto:

      deployment.apps/istio-ingressgateway created
poddisruptionbudget.policy/istio-ingressgateway created
horizontalpodautoscaler.autoscaling/istio-ingressgateway created
role.rbac.authorization.k8s.io/istio-ingressgateway created
rolebinding.rbac.authorization.k8s.io/istio-ingressgateway created
service/istio-ingressgateway created
serviceaccount/istio-ingressgateway created

    Scopri di più sulle best practice per i gateway.

    Esegui il deployment dell'esempio Online Boutique

    L'applicazione di esempio Online Boutique nel repo anthos-service-mesh-packages viene modificata dall'insieme originale di manifest nel repo microservices-demo. Seguendo le best practice, ogni servizio viene implementato in un ambito distinto con un account di servizio univoco.

    1. Crea gli spazi dei nomi per l'applicazione:

      kubectl apply -f \
  DIR_PATH/samples/online-boutique/kubernetes-manifests/namespaces

      Risultato previsto:

      namespace/ad created
namespace/cart created
namespace/checkout created
namespace/currency created
namespace/email created
namespace/frontend created
namespace/loadgenerator created
namespace/payment created
namespace/product-catalog created
namespace/recommendation created
namespace/shipping created

    2. Attiva l'iniezione automatica del sidecar (auto-iniezione). Il comando richiesto dipende dal fatto che tu voglia utilizzare le etichette di inserimento predefinite (ad esempio istio-injection=enabled) o la stessa etichetta di revisione utilizzata per annotare lo spazio dei nomi del gateway di ingresso.

      Etichette di inserimento predefinite

      Applica le etichette di inserimento predefinite allo spazio dei nomi. Nel seguente comando, GATEWAY_NAMESPACE è lo stesso valore che hai utilizzato per annotare lo spazio dei nomi del gateway di ingresso.

      for ns in ad cart checkout currency email frontend loadgenerator payment product-catalog recommendation shipping; do
  kubectl label namespace $ns istio-injection=enabled istio.io/rev-
done;

      Risultato previsto:

      namespace/ad labeled
namespace/cart labeled
namespace/checkout labeled
namespace/currency labeled
namespace/email labeled
namespace/frontend labeled
namespace/loadgenerator labeled
namespace/payment labeled
namespace/product-catalog labeled
namespace/recommendation labeled
namespace/shipping labeled

      Etichetta revisione

      Applica l'etichetta della revisione agli spazi dei nomi dell'applicazione. Nel seguente comando, REVISION è lo stesso valore che hai utilizzato per annotare lo spazio dei nomi del gateway di ingresso.

      for ns in ad cart checkout currency email frontend loadgenerator payment product-catalog recommendation shipping; do
  kubectl label namespace $ns istio.io/rev=REVISION --overwrite
done;

      Risultato previsto:

      namespace/ad labeled
namespace/cart labeled
namespace/checkout labeled
namespace/currency labeled
namespace/email labeled
namespace/frontend labeled
namespace/loadgenerator labeled
namespace/payment labeled
namespace/product-catalog labeled
namespace/recommendation labeled
namespace/shipping labeled

    3. Esegui il deployment dell'applicazione di esempio nel cluster.

      1. Crea gli account di servizio e i deployment:

        kubectl apply -f \
 DIR_PATH/samples/online-boutique/kubernetes-manifests/deployments

        Risultato previsto:

        serviceaccount/ad created
deployment.apps/adservice created
serviceaccount/cart created
deployment.apps/cartservice created
serviceaccount/checkout created
deployment.apps/checkoutservice created
serviceaccount/currency created
deployment.apps/currencyservice created
serviceaccount/email created
deployment.apps/emailservice created
serviceaccount/frontend created
deployment.apps/frontend created
serviceaccount/loadgenerator created
deployment.apps/loadgenerator created
serviceaccount/payment created
deployment.apps/paymentservice created
serviceaccount/product-catalog created
deployment.apps/productcatalogservice created
serviceaccount/recommendation created
deployment.apps/recommendationservice created
serviceaccount/shipping created
deployment.apps/shippingservice created

      2. Crea i servizi:

        kubectl apply -f \
 DIR_PATH/samples/online-boutique/kubernetes-manifests/services

        Risultato previsto:

        service/adservice created
service/cartservice created
service/checkoutservice created
service/currencyservice created
service/emailservice created
service/frontend created
service/frontend-external created
service/paymentservice created
service/productcatalogservice created
service/recommendationservice created
service/shippingservice created

      3. Crea le voci del servizio:

        kubectl apply -f \
 DIR_PATH/samples/online-boutique/istio-manifests/allow-egress-googleapis.yaml

        Risultato previsto:

        serviceentry.networking.istio.io/allow-egress-googleapis created
serviceentry.networking.istio.io/allow-egress-google-metadata created

    Esposizione e accesso all'applicazione

    Esistono diversi modi per esporre l'applicazione. In questa guida, utilizzeremo il gateway di ingresso di cui abbiamo eseguito il deployment sopra per farlo. Per altri modi per esporre l'applicazione Online Boutique, consulta la sezione Esposizione e accesso all'applicazione della guida sul deployment dell'applicazione di esempio Online Boutique.

    1. Esegui il deployment di un Gateway e un VirtualService per il servizio frontend

      kubectl apply -f \
    DIR_PATH/samples/online-boutique/istio-manifests/frontend-gateway.yaml

      Risultato previsto:

      gateway.networking.istio.io/frontend-gateway created
virtualservice.networking.istio.io/frontend-ingress created

    2. Ottieni l'indirizzo IP esterno del gateway di ingresso, sostituisci i segnaposto con le seguenti informazioni:

      • GATEWAY_SERVICE_NAME: il nome del servizio gateway di ingresso. Se hai implementato il gateway di esempio senza modifiche, il valore sarà istio-ingressgateway.
      • GATEWAY_NAMESPACE: lo spazio dei nomi in cui hai disegnato il gateway di ingresso:
      kubectl get service GATEWAY_SERVICE_NAME \
    -n GATEWAY_NAMESPACE

      L'output è simile al seguente:

      NAME                   TYPE           CLUSTER-IP      EXTERNAL-IP   PORT(S)                                      AGE
istio-ingressgateway   LoadBalancer   10.19.247.233   35.239.7.64   80:31380/TCP,443:31390/TCP,31400:31400/TCP   27m

      In questo esempio, l'indirizzo IP del gateway di ingresso è 35.239.7.64.

    3. Visita l'applicazione sul browser per confermare l'installazione:

      http://EXTERNAL_IP/

    Visualizzare le dashboard di Service Mesh

    Dopo aver eseguito il deployment dei workload nel cluster con i proxy sidecar iniettati, puoi esplorare le pagine di Cloud Service Mesh nella Google Cloud console per visualizzare tutte le funzionalità di osservabilità offerte da Cloud Service Mesh. Tieni presente che occorrono circa uno o due minuti prima che i dati di telemetria vengano visualizzati nella Google Cloud console dopo il deployment dei carichi di lavoro.

    L'accesso a Cloud Service Mesh nella Google Cloud console è controllato da Identity and Access Management (IAM). Per accedere alle pagine di Cloud Service Mesh, un Proprietario progetto deve concedere agli utenti il ruolo Editor o Visualizzatore del progetto oppure i ruoli più restrittivi descritti in Controllo dell'accesso ad Anthos Service Mesh nella Google Cloud console.

    1. Nella Google Cloud console, vai a Cloud Service Mesh.

      Vai a Cloud Service Mesh

    2. Seleziona il Google Cloud progetto dall'elenco a discesa nella barra dei menu.

    3. Se hai più di un mesh di servizi, selezionalo dall'elenco a discesa Service Mesh.

    Per scoprire di più, consulta Esplorazione di Cloud Service Mesh nella Google Cloud console.

    Esegui la pulizia

    Prima di eseguire la pulizia, se vuoi saperne di più sul TLS reciproco, consulta Cloud Service Mesh tramite esempi: mTLS.

    • Se vuoi conservare il cluster e rimuovere l'esempio Online Boutique:

      1. Elimina gli spazi dei nomi dell'applicazione:

        kubectl delete -f DIR_PATH/samples/online-boutique/kubernetes-manifests/namespaces

        Risultato previsto:

        namespace "ad" deleted
namespace "cart" deleted
namespace "checkout" deleted
namespace "currency" deleted
namespace "email" deleted
namespace "frontend" deleted
namespace "loadgenerator" deleted
namespace "payment" deleted
namespace "product-catalog" deleted
namespace "recommendation" deleted
namespace "shipping" deleted

      2. Elimina le voci del servizio:

        kubectl delete -f DIR_PATH/samples/online-boutique/istio-manifests/allow-egress-googleapis.yaml

        Risultato previsto:

        serviceentry.networking.istio.io "allow-egress-googleapis" deleted
serviceentry.networking.istio.io "allow-egress-google-metadata" deleted

    • Se vuoi evitare addebiti aggiuntivi, elimina il cluster:

      1. Esegui questo comando:

        gcloud container clusters delete CLUSTER_NAME \
    --project=PROJECT_ID \
    --zone=CLUSTER_LOCATION

      2. Al prompt Do you want to continue (Y/n)? (Vuoi continuare (S/n)?), inserisci y.

        Dopo alcuni minuti, viene visualizzato il seguente output:

        Deleting cluster CLUSTER_NAME...done.
Deleted [https://container.googleapis.com/v1/projects/PROJECT_ID/zones/CLUSTER_LOCATION/clusters/CLUSTER_NAME].

    Passaggi successivi