Configurare le VM utilizzando il deployment manuale di Envoy

Questo documento è rivolto agli amministratori di rete che vogliono configurare Cloud Service Mesh manualmente. La procedura manuale è un meccanismo precedente destinato solo agli utenti avanzati che configurano Cloud Service Mesh con le API di bilanciamento del carico.

Ti consigliamo vivamente di configurare Cloud Service Mesh utilizzando le API di routing dei servizi anziché le API di bilanciamento del carico precedenti. Se devi utilizzare le API di bilanciamento del carico, ti consigliamo di utilizzare il deployment automatico di Envoy anziché la procedura manuale descritta in questa pagina.

Prima di seguire le istruzioni riportate in questa guida, completa le attività preliminari descritte in Prepararsi alla configurazione delle API di routing dei servizi con Envoy e carichi di lavoro senza proxy.

Questa guida mostra come eseguire il deployment manuale di un piano dati costituito da proxy sidecar Envoy con macchine virtuali (VM) Compute Engine, configurarlo utilizzando Cloud Service Mesh e verificare la configurazione per assicurarti che funzioni correttamente. Questa procedura prevede:

  1. Creazione di un servizio di test.
  2. Esegui il deployment di un piano dati semplice su Compute Engine utilizzando i proxy Envoy.
  3. Configurazione di Cloud Service Mesh utilizzando le API Compute Engine, che consentono a Cloud Service Mesh di configurare i proxy sidecar Envoy.
  4. Accedi a una VM su cui è in esecuzione un proxy Envoy e invia una richiesta a un backend bilanciato in base al carico tramite il proxy Envoy.

Gli esempi di configurazione in questo documento sono a scopo dimostrativo. Per un ambiente di produzione, potresti dover implementare componenti aggiuntivi, in base al tuo ambiente e ai tuoi requisiti.

Panoramica della procedura di configurazione

Questa sezione descrive la procedura di configurazione manuale per i servizi in esecuzione sulle VM di Compute Engine. La procedura di configurazione delle VM client consiste nella configurazione di un proxy sidecar e nell'intercettazione del traffico su un VM host Compute Engine. Poi, configura il bilanciamento del carico utilizzando le API di bilanciamento del carico di Google Cloud.

Questa sezione fornisce informazioni su come ottenere e iniettare proxy Envoy da origini di terze parti non gestite da Google.

Quando un'applicazione invia traffico al servizio configurato in Cloud Service Mesh, il traffico viene intercettato e reindirizzato al proxy sidecar compatibile con l'API xDS, quindi bilanciato in base al carico sui backend in base alla configurazione nei componenti di bilanciamento del carico di Google Cloud. Per ulteriori informazioni sulla rete dell'host e sull'intercettazione del traffico, consulta Intercettazione del traffico del proxy sidecar in Cloud Service Mesh.

Per ogni host VM che richiede l'accesso ai servizi Cloud Service Mesh, esegui i seguenti passaggi:

  1. Assegna un account di servizio alla VM.

  2. Imposta l'ambito di accesso API della VM in modo da consentire l'accesso completo alle API Google Cloud.

    • Quando crei le VM, fai clic su Consenti l'accesso completo a tutte le API di Cloud in Identità e accesso API.

      Vai alla pagina Istanze VM.

    • Con gcloud CLI, specifica quanto segue:

      --scopes=https://www.googleapis.com/auth/cloud-platform.

  3. Consenti le connessioni in uscita a trafficdirector.googleapis.com (TCP, porta 443) dalla VM, in modo che il proxy sidecar possa connettersi al control plane di Cloud Service Mesh tramite gRPC. Le connessioni in uscita alla porta 443 sono abilitate per impostazione predefinita.

  4. Esegui il deployment di un proxy sidecar compatibile con l'API xDS (ad esempio Envoy), con una configurazione di bootstrap che rimandi a trafficdirector.googleapis.com:443 come server xDS. Per ottenere un file di configurazione di bootstrap di esempio, apri il file compresso traffic-director-xdsv3.tar.gz e modifica il file bootstrap_template.yaml in base alle tue esigenze.

  5. Reindirizza il traffico IP destinato ai servizi alla porta di ascolto dell'intercettazione del proxy sidecar.

Crea il servizio di test Hello World

Questa sezione mostra come creare un semplice servizio di test che restituisce il nome host della VM che ha soddisfatto la richiesta del client. Il servizio di test è semplice: si tratta di un server web di cui è stato eseguito il deployment in un gruppo di istanze gestite Compute Engine.

Crea il modello di istanza

Il modello di istanza che crei configura un server web apache2 di esempio utilizzando il parametro startup-script.

Console

  1. Nella console Google Cloud, vai alla pagina Modelli di istanza.

    Vai a Modelli di istanza

  2. Fai clic su Crea modello istanza.
  3. Nei campi, inserisci le seguenti informazioni:
    • Nome: td-demo-hello-world-template
    • Disco di avvio: Debian GNU/Linux 10 (buster)
    • Account di servizio: account di servizio predefinito di Compute Engine
    • Ambiti di accesso: consenti l'accesso completo a tutte le API Cloud
  4. Fai clic su Gestione, sicurezza, dischi, networking, single tenancy.
  5. Nella scheda Networking, aggiungi il tag td-http-server nel campo Tag di rete.

  6. Nella scheda Gestione, copia il seguente script nel campo Script di avvio.

    #! /bin/bash
sudo apt-get update -y
sudo apt-get install apache2 -y
sudo service apache2 restart
echo '<!doctype html><html><body><h1>'`/bin/hostname`'</h1></body></html>' | sudo tee /var/www/html/index.html

  7. Fai clic su Crea.

gcloud

Crea il modello di istanza:

gcloud compute instance-templates create td-demo-hello-world-template \
  --machine-type=n1-standard-1 \
  --boot-disk-size=20GB \
  --image-family=debian-10 \
  --image-project=debian-cloud \
  --scopes=https://www.googleapis.com/auth/cloud-platform \
  --tags=td-http-server \
  --metadata=startup-script="#! /bin/bash
sudo apt-get update -y
sudo apt-get install apache2 -y
sudo service apache2 restart
sudo mkdir -p /var/www/html/
echo '<!doctype html><html><body><h1>'`/bin/hostname`'</h1></body></html>' | sudo tee /var/www/html/index.html"

Crea il gruppo di istanze gestite

In questa sezione, specifichi che il gruppo di istanze gestite ha sempre due istanze del servizio di test. Questa immagine è solo a scopo dimostrativo. Cloud Service Mesh supporta i gruppi di istanze gestite con scalabilità automatica.

Console

  1. Nella console Google Cloud, vai alla pagina Gruppi di istanze.

    Vai a Gruppi di istanze

  2. Fai clic su Crea gruppo di istanze.
  3. Seleziona Nuovo gruppo di istanze gestite (stateless). Per ulteriori informazioni, consulta Gruppi di istanze gestite stateless o stateful.
  4. Inserisci td-demo-hello-world-mig come nome del gruppo di istanze gestite e seleziona la zona us-central1-a.
  5. In Modello di istanza, seleziona td-demo-hello-world-template, ovvero il modello di istanza che hai creato.
  6. In Modalità di scalabilità automatica, seleziona Non scalare automaticamente.
  7. In Numero di istanze, specifica almeno due come numero di istanze da creare nel gruppo.
  8. Fai clic su Crea.

gcloud

Utilizza gcloud CLI per creare un gruppo di istanze gestite con il modello di istanza creato in precedenza.

gcloud compute instance-groups managed create td-demo-hello-world-mig \
  --zone us-central1-a \
  --size=2 \
  --template=td-demo-hello-world-template

Crea il modello di istanza e il gruppo di istanze gestite in cui è dipiegato Envoy

Segui le istruzioni riportate in questa sezione per creare manualmente un modello di istanza e un gruppo di istanze gestite per Cloud Service Mesh. I gruppi di istanze gestite creano nuove VM di backend utilizzando la scalabilità automatica.

Questo esempio illustra come:

  • Crea un modello VM con una configurazione completa di Envoy e un servizio di esempio che serve il proprio nome host utilizzando il protocollo HTTP.
  • Configura un gruppo di istanze gestite utilizzando questo modello.

Crea il modello di istanza

Innanzitutto, crea il modello di istanza VM Compute Engine. Questo modello configura automaticamente il proxy sidecar Envoy e il web service apache2 di esempio tramite il parametro startup-script.

Console

  1. Nella console Google Cloud, vai alla pagina Modelli di istanza.

    Vai a Modelli di istanza

  2. Fai clic su Crea modello istanza.

  3. Compila i campi come segue:

    • Nome: td-vm-template
    • Disco di avvio: Debian GNU/Linux 10 (buster)
    • Account di servizio:account di servizio predefinito Compute Engine
    • Ambiti di accesso:consenti l'accesso completo a tutte le API Cloud

  4. In Firewall, seleziona le caselle accanto a Consenti traffico HTTP e Consenti traffico HTTPS.

  5. Fai clic su Gestione, sicurezza, dischi, networking, single tenancy.

  6. Nella scheda Gestione, copia il seguente script nel Script di avvio.

    #! /usr/bin/env bash

# Set variables
export ENVOY_USER="envoy"
export ENVOY_USER_UID="1337"
export ENVOY_USER_GID="1337"
export ENVOY_USER_HOME="/opt/envoy"
export ENVOY_CONFIG="${ENVOY_USER_HOME}/config.yaml"
export ENVOY_PORT="15001"
export ENVOY_ADMIN_PORT="15000"
export ENVOY_TRACING_ENABLED="false"
export ENVOY_XDS_SERVER_CERT="/etc/ssl/certs/ca-certificates.crt"
export ENVOY_ACCESS_LOG="/dev/stdout"
export ENVOY_NODE_ID="$(cat /proc/sys/kernel/random/uuid)~$(hostname -i)"
export BOOTSTRAP_TEMPLATE="${ENVOY_USER_HOME}/bootstrap_template.yaml"
export GCE_METADATA_SERVER="169.254.169.254/32"
export INTERCEPTED_CIDRS="*"
export GCP_PROJECT_NUMBER=PROJECT_NUMBER
export VPC_NETWORK_NAME=NETWORK_NAME
export GCE_ZONE=$(curl -sS -H "Metadata-Flavor: Google" http://metadata.google.internal/computeMetadata/v1/instance/zone | cut -d"/" -f4)

# Create system user account for Envoy binary
sudo groupadd ${ENVOY_USER} \
 --gid=${ENVOY_USER_GID} \
 --system
sudo adduser ${ENVOY_USER} \
 --uid=${ENVOY_USER_UID} \
 --gid=${ENVOY_USER_GID} \
 --home=${ENVOY_USER_HOME} \
 --disabled-login \
 --system

# Download and extract the Cloud Service Mesh tar.gz file
cd ${ENVOY_USER_HOME}
sudo curl -sL https://storage.googleapis.com/traffic-director/traffic-director-xdsv3.tar.gz -o traffic-director-xdsv3.tar.gz
sudo tar -xvzf traffic-director-xdsv3.tar.gz traffic-director-xdsv3/bootstrap_template.yaml \
 -C bootstrap_template.yaml \
 --strip-components 1
sudo tar -xvzf traffic-director-xdsv3.tar.gz traffic-director-xdsv3/iptables.sh \
 -C iptables.sh \
 --strip-components 1
sudo rm traffic-director-xdsv3.tar.gz

# Generate Envoy bootstrap configuration
cat "${BOOTSTRAP_TEMPLATE}" \
 | sed -e "s|ENVOY_NODE_ID|${ENVOY_NODE_ID}|g" \
 | sed -e "s|ENVOY_ZONE|${GCE_ZONE}|g" \
 | sed -e "s|VPC_NETWORK_NAME|${VPC_NETWORK_NAME}|g" \
 | sed -e "s|CONFIG_PROJECT_NUMBER|${GCP_PROJECT_NUMBER}|g" \
 | sed -e "s|ENVOY_PORT|${ENVOY_PORT}|g" \
 | sed -e "s|ENVOY_ADMIN_PORT|${ENVOY_ADMIN_PORT}|g" \
 | sed -e "s|XDS_SERVER_CERT|${ENVOY_XDS_SERVER_CERT}|g" \
 | sed -e "s|TRACING_ENABLED|${ENVOY_TRACING_ENABLED}|g" \
 | sed -e "s|ACCESSLOG_PATH|${ENVOY_ACCESS_LOG}|g" \
 | sed -e "s|BACKEND_INBOUND_PORTS|${BACKEND_INBOUND_PORTS}|g" \
 | sudo tee "${ENVOY_CONFIG}"

# Install Envoy binary
curl -sL "https://deb.dl.getenvoy.io/public/gpg.8115BA8E629CC074.key" | sudo gpg --dearmor -o /usr/share/keyrings/getenvoy-keyring.gpg
echo a077cb587a1b622e03aa4bf2f3689de14658a9497a9af2c427bba5f4cc3c4723 /usr/share/keyrings/getenvoy-keyring.gpg | sha256sum --check
echo "deb [arch=amd64 signed-by=/usr/share/keyrings/getenvoy-keyring.gpg] https://deb.dl.getenvoy.io/public/deb/debian $(lsb_release -cs) main" | sudo tee /etc/apt/sources.list.d/getenvoy.list
sudo apt update
sudo apt -y install getenvoy-envoy

# Run Envoy as systemd service
sudo systemd-run --uid=${ENVOY_USER_UID} --gid=${ENVOY_USER_GID} \
 --working-directory=${ENVOY_USER_HOME} --unit=envoy.service \
 bash -c "/usr/bin/envoy --config-path ${ENVOY_CONFIG} | tee"

# Configure iptables for traffic interception and redirection
sudo ${ENVOY_USER_HOME}/iptables.sh \
 -p "${ENVOY_PORT}" \
 -u "${ENVOY_USER_UID}" \
 -g "${ENVOY_USER_GID}" \
 -m "REDIRECT" \
 -i "${INTERCEPTED_CIDRS}" \
 -x "${GCE_METADATA_SERVER}"

  7. Fai clic su Crea per creare il modello.

gcloud

Crea il modello di istanza.

gcloud compute instance-templates create td-vm-template \
  --scopes=https://www.googleapis.com/auth/cloud-platform \
  --tags=http-td-tag,http-server,https-server \
  --image-family=debian-10 \
  --image-project=debian-cloud \
  --metadata=startup-script='#! /usr/bin/env bash

# Set variables
export ENVOY_USER="envoy"
export ENVOY_USER_UID="1337"
export ENVOY_USER_GID="1337"
export ENVOY_USER_HOME="/opt/envoy"
export ENVOY_CONFIG="${ENVOY_USER_HOME}/config.yaml"
export ENVOY_PORT="15001"
export ENVOY_ADMIN_PORT="15000"
export ENVOY_TRACING_ENABLED="false"
export ENVOY_XDS_SERVER_CERT="/etc/ssl/certs/ca-certificates.crt"
export ENVOY_ACCESS_LOG="/dev/stdout"
export ENVOY_NODE_ID="$(cat /proc/sys/kernel/random/uuid)~$(hostname -i)"
export BOOTSTRAP_TEMPLATE="${ENVOY_USER_HOME}/bootstrap_template.yaml"
export GCE_METADATA_SERVER="169.254.169.254/32"
export INTERCEPTED_CIDRS="*"
export GCP_PROJECT_NUMBER=PROJECT_NUMBER
export VPC_NETWORK_NAME=NETWORK_NAME
export GCE_ZONE=$(curl -sS -H "Metadata-Flavor: Google" http://metadata.google.internal/computeMetadata/v1/instance/zone | cut -d"/" -f4)

# Create system user account for Envoy binary
sudo groupadd ${ENVOY_USER} \
  --gid=${ENVOY_USER_GID} \
  --system
sudo adduser ${ENVOY_USER} \
  --uid=${ENVOY_USER_UID} \
  --gid=${ENVOY_USER_GID} \
  --home=${ENVOY_USER_HOME} \
  --disabled-login \
  --system
# Download and extract the Cloud Service Mesh tar.gz file
cd ${ENVOY_USER_HOME}
sudo curl -sL https://storage.googleapis.com/traffic-director/traffic-director-xdsv3.tar.gz -o traffic-director-xdsv3.tar.gz
sudo tar -xvzf traffic-director-xdsv3.tar.gz traffic-director-xdsv3/bootstrap_template.yaml \
  -C bootstrap_template.yaml \
  --strip-components 1
sudo tar -xvzf traffic-director-xdsv3.tar.gz traffic-director-xdsv3/iptables.sh \
  -C iptables.sh \
  --strip-components 1
sudo rm traffic-director-xdsv3.tar.gz

# Generate Envoy bootstrap configuration
cat "${BOOTSTRAP_TEMPLATE}" \
  | sed -e "s|ENVOY_NODE_ID|${ENVOY_NODE_ID}|g" \
  | sed -e "s|ENVOY_ZONE|${GCE_ZONE}|g" \
  | sed -e "s|VPC_NETWORK_NAME|${VPC_NETWORK_NAME}|g" \
  | sed -e "s|CONFIG_PROJECT_NUMBER|${GCP_PROJECT_NUMBER}|g" \
  | sed -e "s|ENVOY_PORT|${ENVOY_PORT}|g" \
  | sed -e "s|ENVOY_ADMIN_PORT|${ENVOY_ADMIN_PORT}|g" \
  | sed -e "s|XDS_SERVER_CERT|${ENVOY_XDS_SERVER_CERT}|g" \
  | sed -e "s|TRACING_ENABLED|${ENVOY_TRACING_ENABLED}|g" \
  | sed -e "s|ACCESSLOG_PATH|${ENVOY_ACCESS_LOG}|g" \
  | sed -e "s|BACKEND_INBOUND_PORTS|${BACKEND_INBOUND_PORTS}|g" \
  | sudo tee "${ENVOY_CONFIG}"

# Install Envoy binary
curl -sL "https://deb.dl.getenvoy.io/public/gpg.8115BA8E629CC074.key" | sudo gpg --dearmor -o /usr/share/keyrings/getenvoy-keyring.gpg
echo a077cb587a1b622e03aa4bf2f3689de14658a9497a9af2c427bba5f4cc3c4723 /usr/share/keyrings/getenvoy-keyring.gpg | sha256sum --check
echo "deb [arch=amd64 signed-by=/usr/share/keyrings/getenvoy-keyring.gpg] https://deb.dl.getenvoy.io/public/deb/debian $(lsb_release -cs) main" | sudo tee /etc/apt/sources.list.d/getenvoy.list
sudo apt update
sudo apt -y install getenvoy-envoy

# Run Envoy as systemd service
sudo systemd-run --uid=${ENVOY_USER_UID} --gid=${ENVOY_USER_GID} \
  --working-directory=${ENVOY_USER_HOME} --unit=envoy.service \
  bash -c "/usr/bin/envoy --config-path ${ENVOY_CONFIG} | tee"

# Configure iptables for traffic interception and redirection
sudo ${ENVOY_USER_HOME}/iptables.sh \
  -p "${ENVOY_PORT}" \
  -u "${ENVOY_USER_UID}" \
  -g "${ENVOY_USER_GID}" \
  -m "REDIRECT" \
  -i "${INTERCEPTED_CIDRS}" \
  -x "${GCE_METADATA_SERVER}"
'

Crea il gruppo di istanze gestite

Se non hai un gruppo di istanze gestite con i servizi in esecuzione, creane uno, utilizzando un modello VM come quello mostrato nella sezione precedente. Questo esempio utilizza il modello di istanza creato nella sezione precedente per dimostrare la funzionalità. Non è necessario utilizzare il modello di istanza.

Console

  1. Nella console Google Cloud, vai alla pagina Gruppi di istanze.

    Vai a Gruppi di istanze

  2. Fai clic su Crea un gruppo di istanze. Per impostazione predefinita, viene visualizzata la pagina per la creazione di un gruppo di istanze gestite.
  3. Scegli Nuovo gruppo di istanze gestite (stateless). Per ulteriori informazioni, consulta Gruppi di istanze gestite stateless o stateful.
  4. Inserisci td-vm-mig-us-central1 come nome del gruppo di istanze gestite e seleziona la zona us-central1-a.
  5. In Modello di istanza, seleziona il modello di istanza che hai creato.
  6. Specifica 2 come numero di istanze da creare nel gruppo.
  7. Fai clic su Crea.

gcloud

Utilizza gcloud CLI per creare un gruppo di istanze gestite con il modello di istanza creato in precedenza.

gcloud compute instance-groups managed create td-vm-mig-us-central1 \
    --zone us-central1-a --size=2 --template=td-vm-template

Configura Cloud Service Mesh con i componenti di bilanciamento del carico di Google Cloud

Le istruzioni riportate in questa sezione illustrano come configurare Cloud Service Mesh in modo che i proxy Envoy bilancino il carico del traffico in uscita su due istanze di backend. Configura i seguenti componenti:

Crea il controllo di integrità

Segui le istruzioni riportate di seguito per creare un controllo di integrità. Per ulteriori informazioni, consulta Creare controlli di integrità.

Console

  1. Nella console Google Cloud, vai alla pagina Controlli di integrità.

    Vai a Controlli di integrità

  2. Fai clic su Crea controllo di integrità.
  3. Come nome, inserisci td-vm-health-check.
  4. Per il protocollo, seleziona HTTP.
  5. Fai clic su Crea.

gcloud

  1. Crea il controllo di integrità:

    gcloud compute health-checks create http td-vm-health-check

  2. Crea la regola firewall:

    gcloud compute firewall-rules create fw-allow-health-checks \
  --action ALLOW \
  --direction INGRESS \
  --source-ranges 35.191.0.0/16,130.211.0.0/22 \
  --target-tags http-td-tag,http-server,https-server \
  --rules tcp

Crea il servizio di backend

Se utilizzi Google Cloud CLI, devi designare il servizio di backend come servizio di backend globale con uno schema di bilanciamento del carico di INTERNAL_SELF_MANAGED. Aggiungi il controllo di stato e un gruppo di istanze gestite o non gestite al servizio di backend. Tieni presente che questo esempio utilizza il gruppo di istanze gestite con il modello VM Compute Engine che esegue il servizio HTTP di esempio creato in Creare il gruppo di istanze gestite.

Console

  1. Nella console Google Cloud, vai alla pagina Cloud Service Mesh.

    Vai a Cloud Service Mesh

  2. Nella scheda Servizi, fai clic su Crea servizio.
  3. Fai clic su Continua.
  4. Come nome del servizio, inserisci td-vm-service.
  5. Seleziona la rete VPC corretta.
  6. Assicurati che il Tipo di backend sia Gruppi di istanze.
  7. Seleziona il gruppo di istanze gestite che hai creato.
  8. Inserisci i Numeri di porta corretti.
  9. Scegli Utilizzo o Tariffa come Modalità di bilanciamento. Il valore predefinito è Rate.
  10. Fai clic su Fine.
  11. Seleziona il controllo di integrità che hai creato.
  12. Fai clic su Salva e continua.
  13. Fai clic su Crea.

gcloud

  1. Crea il servizio di backend:

    gcloud compute backend-services create td-vm-service \
  --global \
  --load-balancing-scheme=INTERNAL_SELF_MANAGED \
  --health-checks td-vm-health-check

  2. Aggiungi i backend al servizio di backend:

    gcloud compute backend-services add-backend td-vm-service \
   --instance-group td-demo-hello-world-mig \
   --instance-group-zone us-central1-a \
   --global

Crea la mappa di regole di routing

La mappa delle regole di routing definisce il modo in cui Cloud Service Mesh instrada il traffico nel tuo mesh.

Segui queste istruzioni per creare la regola di instradamento, la regola di forwarding, il proxy di destinazione e l'indirizzo IP interno per la configurazione di Cloud Service Mesh.

Il traffico inviato all'indirizzo IP interno viene intercettato dal proxy Envoy e inviato al servizio appropriato in base alle regole host e percorso.

La regola di forwarding viene creata come regola di forwarding globale con load-balancing-scheme impostato su INTERNAL_SELF_MANAGED.

Puoi impostare l'indirizzo della regola di forwarding su 0.0.0.0. In questo caso, il traffico viene instradato in base al nome host HTTP e alle informazioni sul percorso configurate nella mappa URL, a prescindere dall'effettivo indirizzo IP di destinazione della richiesta. In questo caso, i nomi host dei tuoi servizi, come configurati nelle regole host, devono essere univoci all'interno della configurazione del tuo mesh di servizi. In altre parole, non puoi avere due servizi diversi, con insiemi di backend diversi, che utilizzano entrambi lo stesso nome host.

In alternativa, puoi attivare il routing in base alla destinazione VIP effettiva del servizio. Se configuri l'IP virtuale del tuo servizio come parametro address della regola di forwarding, solo le richieste destinate a questo indirizzo vengono instradate in base ai parametri HTTP specificati nella mappa URL.

Questo esempio utilizza 10.0.0.1 come parametro indirizzo, il che significa che il routing per il servizio viene eseguito in base all'IP VIP di destinazione effettivo del servizio.

Console

Nella console Google Cloud, il proxy di destinazione viene combinato con la regola di forwarding. Quando crei la regola di forwarding, Google Cloud crea automaticamente un proxy HTTP di destinazione e lo collega alla mappa URL.

  1. Nella console Google Cloud, vai alla pagina Cloud Service Mesh.

    Vai a Cloud Service Mesh

  2. Nella scheda Mappe di regole di routing, fai clic su Crea mappa di regole di routing.
  3. Inserisci un nome.
  4. Fai clic su Aggiungi regola di inoltro.
  5. Inserisci td-vm-forwarding-rule come nome della regola di forwarding.
  6. Seleziona la tua rete.

  7. Seleziona il tuo IP interno. Il traffico inviato a questo indirizzo IP viene intercettato dal proxy Envoy e inviato al servizio appropriato in base alle regole host e percorso.

    La regola di forwarding viene creata come regola di forwarding globale con load-balancing-scheme impostato su INTERNAL_SELF_MANAGED.

  8. Nel campo IP personalizzato, digita 10.0.0.1. Quando la VM invia un messaggio a questo indirizzo IP, il proxy Envoy lo intercetta e lo invia all'endpoint del servizio di backend appropriato in base alle regole di gestione del traffico definite nella mappa URL.

    Ogni regola di forwarding in una rete VPC deve avere un indirizzo IP e una porta univoci per ogni rete VPC. Se crei più di una regola di forwarding con lo stesso indirizzo IP e la stessa porta in una determinata rete VPC, è valida solo la prima regola di forwarding. mentre gli altri vengono ignorati. Se 10.0.0.1 non è disponibile nella tua rete, scegli un indirizzo IP diverso.

  9. Assicurati che Porta sia impostata su 80.

  10. Fai clic su Salva.

  11. Nella sezione Regole di routing, seleziona Regola host e percorso semplice.

  12. Nella sezione Regole host e percorso, seleziona td-vm-service come servizio.

  13. Fai clic su Aggiungi regola host e percorso.

  14. In Host, inserisci hello-world.

  15. In Servizio, seleziona td-vm-service.

  16. Fai clic su Salva.

gcloud

  1. Crea una mappa URL che utilizza il servizio di backend:

    gcloud compute url-maps create td-vm-url-map \
   --default-service td-vm-service

  2. Crea un'espressione di corrispondenza del percorso della mappa URL e una regola host per instradare il traffico per il tuo servizio in base al nome host e a un percorso. Questo esempio utilizza service-test come nome del servizio e un matcher dei percorsi predefinito che corrisponde a tutte le richieste di percorso per questo host (/*).

    gcloud compute url-maps add-path-matcher td-vm-url-map \
   --default-service td-vm-service --path-matcher-name td-vm-path-matcher

    gcloud compute url-maps add-host-rule td-vm-url-map --hosts service-test \
   --path-matcher-name td-vm-path-matcher \
   --hosts hello-world

  3. Crea il proxy HTTP di destinazione:

    gcloud compute target-http-proxies create td-vm-proxy \
   --url-map td-vm-url-map

  4. Crea la regola di forwarding. La regola di forwarding deve essere globale e deve essere creata con il valore di load-balancing-scheme impostato su INTERNAL_SELF_MANAGED.

    gcloud compute forwarding-rules create td-vm-forwarding-rule \
   --global \
   --load-balancing-scheme=INTERNAL_SELF_MANAGED \
   --address=10.0.0.1 \
   --target-http-proxy=td-vm-proxy \
   --ports 80 \
   --network default

A questo punto, Cloud Service Mesh è configurato per bilanciare il traffico per i servizi specificati nella mappa URL tra i backend nel gruppo di istanze gestito.

Verificare la configurazione

In questa parte finale della guida alla configurazione di Cloud Service Mesh per le VM Compute Engine, verifichi che il traffico inviato dalla VM client destinato al VIP della regola di forwarding venga intercettato e reindirizzato al proxy Envoy, che poi instrada la richiesta alle VM che ospitano il servizio Hello World.

Innanzitutto, verifica che i backend siano operativi seguendo questi passaggi:

Console

  1. Nella console Google Cloud, vai alla pagina Cloud Service Mesh.

    Vai a Cloud Service Mesh

    La sezione Riepilogo indica se i servizi sono integri.

  2. Fai clic sul nome di un servizio. La pagina Dettagli del servizio contiene informazioni sullo stato dei backend.
  3. Se i backend non sono integri, puoi reimpostarli facendo clic sul nome e poi su Reimposta nella pagina Dettagli istanza VM.

gcloud

Utilizza il comando compute backend-services get-health per verificare che i backend siano integri:

gcloud compute backend-services get-health td-vm-service \
    --global \
    --format=get(name, healthStatus)

Dopo aver verificato gli stati di integrità dei tuoi backend, accedi alla VM client che è stata configurata per intercettare il traffico e reindirizzarlo a Envoy. Invia una curl richiesta al VIP associato alla mappa delle regole di routing. Envoy ispeziona la richiesta curl, determina a quale servizio deve essere risolta e la invia a un backend associato a quel servizio.

Console

  1. Nella console Google Cloud, vai alla pagina Gruppi di istanze.

    Vai a Gruppi di istanze

  2. Seleziona il gruppo di istanze td-vm-mig-us-central1.
  3. In Connetti, fai clic su SSH.

  4. Dopo aver eseguito l'accesso alla VM client, utilizza lo strumento curl per inviare una richiesta al servizio Hello World tramite Envoy:

    curl -H "Host: hello-world" http://10.0.0.1/

Se esegui questo comando ripetutamente, visualizzerai diverse risposte HTML contenenti i nomi host dei backend nel Hello World gruppo di istanze gestite. Questo perché Envoy utilizza il bilanciamento del carico round robin, l'algoritmo di bilanciamento del carico predefinito, per inviare il traffico ai backend del servizio Hello World.

Al termine della configurazione, ogni VM Compute Engine con un proxy sidecar può accedere ai servizi configurati in Cloud Service Mesh utilizzando il protocollo HTTP.

Se hai seguito gli esempi specifici in questa guida utilizzando il modello VM Compute Engine con il server HTTP di dimostrazione e il nome host del servizioservice-test, segui questi passaggi per verificare la configurazione:

  1. Accedi a uno degli host VM su cui è installato un proxy sidecar.
  2. Esegui il comando curl -H 'Host: service-test' 10.0.0.1. Questa richiesta restituisce il nome host del backend del gruppo di istanze gestite che ha eseguito la richiesta.

Nel passaggio 2, tieni presente che puoi utilizzare qualsiasi indirizzo IP. Ad esempio, il comando curl -I -H 'Host: service-test' 1.2.3.4 funzionerebbe nel passaggio 2.

Questo perché il parametro address della regola di forwarding è impostato su 0.0.0.0, che indica a Cloud Service Mesh di eseguire la corrispondenza in base all'host definito nella mappa URL. Nella configurazione di esempio, il nome host è service-test.

Passaggi successivi