Cloud Service Mesh regionale

Anteprima — Regional Cloud Service Mesh

Questa funzionalità è soggetta ai "Termini delle Offerte pre-GA" nella sezione Termini di servizio generali dei Termini di servizio specifici. Le funzionalità pre-GA sono disponibili "così come sono" e potrebbero avere un supporto limitato. Per ulteriori informazioni, consulta le descrizioni delle fasi di lancio.

Con l'isolamento regionale, i client che si connettono a una regione specifica del control plane Cloud Service Mesh possono accedere solo alle risorse all'interno di quella regione. Allo stesso modo, le risorse API all'interno di una regione specifica possono fare riferimento solo ad altre risorse in quella regione.

Cloud Service Mesh regionale presenta le seguenti limitazioni:

• L'API Istio non è supportata. Non puoi utilizzare Kubernetes con l'API Istio utilizzando Traffic Director regionale. In questa anteprima sono supportate solo le API Google Cloud .
• Si applicano le considerazioni e limitazioni esistenti delle API di routing dei servizi globali.
• La versione minima di Envoy per supportare gli schemi di denominazione xdSTP è la v1.31.1.
• L'API Gateway for Mesh non è supportata.
• La versione minima di gRPC è la v1.65.

• Sono supportate solo le seguenti regioni:

  africa-south1
  asia-east1
  asia-east2
  asia-northeast1
  asia-northeast2
  asia-northeast3
  asia-south1
  asia-south2
  asia-southeast1
  asia-southeast2
  australia-southeast1
  australia-southeast2
  europe-central2
  europe-north1
  europe-north2
  europe-southwest1
  europe-west10
  europe-west12
  europe-west1
  europe-west2
  europe-west3
  europe-west4
  europe-west6
  europe-west8
  europe-west9
  me-central1
  me-central2
  me-west1
  northamerica-northeast1
  northamerica-northeast2
  northamerica-south1
  southamerica-east1
  southamerica-west1
  us-central1
  us-east1
  us-east4
  us-east5
  us-south1
  us-west1
  us-west2
  us-west3
  us-west4
  

Prezzi

Ogni regione in cui è supportato Cloud Service Mesh regionale avrà uno SKU regionale quando questa funzionalità sarà disponibile a livello generale. Per ora, i prezzi sono gli stessi di quelli globali.

Prepara il client xDS per Cloud Service Mesh

Compute VM Envoy xDS

Manuale

I passaggi manuali si basano su Configura le VM utilizzando il deployment manuale di Envoy. La differenza principale è che ENVOY_CONTROL_PLANE_REGION viene impostato e inserito nel bootstrap.

1. Crea il modello di istanza:

   gcloud compute instance-templates create td-vm-templategcloud 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-11 \
     --image-project=debian-cloud \
     --metadata=startup-script='#! /usr/bin/env bash
   
   # Set variables
   export ENVOY_CONTROL_PLANE_REGION="us-central1"
   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=mesh:sidecar-mesh
   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" \
     | sed -e "s|trafficdirector.googleapis.com|trafficdirector.${ENVOY_CONTROL_PLANE_REGION}.rep.googleapis.com|g" \
     | sudo tee "${ENVOY_CONFIG}"
   
   # Install Envoy binary
   wget -O envoy_key https://apt.envoyproxy.io/signing.key
   cat envoy_key | sudo gpg --dearmor > $(pwd)/envoy-keyring.gpg
   echo "deb [arch=$(dpkg --print-architecture) signed-by=$(pwd)/envoy-keyring.gpg] https://apt.envoyproxy.io bullseye main" | sudo tee /etc/apt/sources.list.d/envoy.list
   sudo apt-get update
   sudo apt-get install 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}"
   

Compute VM gRPC xDS

Analogamente a Cloud Service Mesh globale, i client gRPC devono configurare un bootstrap per indicare come connettersi a Cloud Service Mesh regionale.

Puoi utilizzare il generatore di bootstrap gRPC per generare questo bootstrap. Per impostarlo in modo che utilizzi Cloud Service Mesh regionale, specifica un nuovo flag: --xds-server-region.

In questo esempio, l'impostazione di xds-server-region su us-central1 determina automaticamente l'endpoint Cloud Service Mesh regionale: trafficdirector.us-central1.rep.googleapis.com:443.

Inserimento manuale di Envoy in K8s

I passaggi manuali si basano su Configurazione dei pod di Google Kubernetes Engine utilizzando l'inserimento Envoy manuale. Tuttavia, devi modificare solo la sezione relativa all'inserimento manuale di pod.

1. Modifica il control plane da globale a regionale:

   wget -q -O - https://storage.googleapis.com/traffic-director/demo/trafficdirector_client_new_api_sample_xdsv3.yaml
   
   sed -i "s/PROJECT_NUMBER/PROJECT_NUMBER/g" trafficdirector_client_new_api_sample_xdsv3.yaml
   
   sed -i "s/MESH_NAME/MESH_NAME/g" trafficdirector_client_new_api_sample_xdsv3.yaml
   
   sed -i "s|trafficdirector.googleapis.com|trafficdirector.${REGION}.rep.googleapis.com|g" trafficdirector_client_new_api_sample_xdsv3.yaml
   
   sed -i "s|gcr.io/google-containers/busybox|busybox:stable|g" trafficdirector_client_new_api_sample_xdsv3.yaml
   

   1. Applica le modifiche:

      kubectl apply -f trafficdirector_client_new_api_sample_xdsv3.yaml
        ```
      

Guide per la configurazione

La sezione tratta cinque modelli di configurazione e deployment indipendenti. Queste sono tutte versioni regionalizzate delle guide alla configurazione dell'API di routing dei servizi globale esistente.

• Configurazione dei servizi gRPC senza proxy con GRPCRoute regionale e Cloud Service Mesh regionale
• Configurazione della configurazione del proxy sidecar Envoy con servizi HTTP con HTTPRoute regionale e Cloud Service Mesh regionale
• Configurazione dei servizi TCP con TCPRoute regionale
• Routing TLS del gateway
• Configurazione di riferimenti tra progetti per Cloud Service Mesh regionale e Route regionale

Configura i servizi gRPC senza proxy con GRPCRoute regionale e Cloud Service Mesh regionale

Questa sezione spiega come configurare un mesh di servizi gRPC senza proxy con Cloud Service Mesh regionale e risorse GRPCRoute regionali.

Per comodità, memorizza il numero di progetto Google Cloud in cui esegui la configurazione, in modo che tutti gli esempi di questa guida possano essere copiati e incollati nella riga di comando:

export PROJECT="PROJECT_NUMBER"
export REGION="us-central1"
export ZONE="us-central1-a"

Sostituisci PROJECT_NUMBER con il numero del progetto.

In via facoltativa, puoi sostituire quanto segue:

• us-central1 con un'altra regione che vuoi utilizzare.
• us-central1-a con un'altra zona che vuoi utilizzare.
• default con un VPC_NAME diverso.

Configurazione mesh

Quando un'applicazione gRPC senza proxy si connette a un xds://hostname, la libreria client gRPC stabilisce una connessione a Cloud Service Mesh per ottenere la configurazione di routing necessaria per instradare le richieste per il nome host.

1. Crea una specifica Mesh e archiviala nel file mesh.yaml:

   cat <<EOF > mesh.yaml
   name: grpc-mesh
   EOF
   

2. Crea una mesh utilizzando la specifica mesh.yaml:

   gcloud network-services meshes import grpc-mesh \
       --source=mesh.yaml \
       --location=${REGION}
   

   Una volta creata la mesh regionale, Cloud Service Mesh è pronto a gestire la configurazione. Tuttavia, poiché non sono ancora stati definiti servizi, la configurazione è vuota.

Configurazione del servizio gRPC

A scopo dimostrativo, creerai un servizio di backend regionale con VM scalate automaticamente (utilizzando gruppi di istanze gestite, MIG) che serviranno hello world utilizzando il protocollo gRPC sulla porta 50051.

1. Crea il modello di istanza VM di Compute Engine con un servizio gRPC helloworld esposto sulla porta 50051:

   gcloud compute instance-templates create grpc-td-vm-template \
     --scopes=https://www.googleapis.com/auth/cloud-platform \
     --tags=allow-health-checks \
     --image-family=debian-11 \
     --image-project=debian-cloud \
     --metadata-from-file=startup-script=<(echo '#! /bin/bash
   set -e
   cd /root
   sudo apt-get update -y
   sudo apt-get install -y openjdk-11-jdk-headless
   curl -L https://github.com/grpc/grpc-java/archive/v1.38.0.tar.gz | tar -xz
   cd grpc-java-1.38.0/examples/example-hostname
   ../gradlew --no-daemon installDist
   # Server listens on 50051
   sudo systemd-run ./build/install/hostname-server/bin/hostname-server')
   

2. Crea un MIG basato sul modello:

   gcloud compute instance-groups managed create grpc-td-mig-us-central1 \
     --zone=${ZONE} \
     --size=2 \
     --template=grpc-td-vm-template
   

3. Configura una porta denominata per il servizio gRPC. Questa è la porta su cui il servizio gRPC è configurato per rimanere in ascolto delle richieste.

   gcloud compute instance-groups set-named-ports grpc-td-mig-us-central1 \
     --named-ports=grpc-helloworld-port:50051 \
     --zone=${ZONE}
   

   In questo esempio, la porta è 50051.

4. Crea controlli di integrità gRPC.

   gcloud compute health-checks create grpc grpc-helloworld-health-check \
     --use-serving-port --region=${REGION}
   

   Affinché i controlli di integrità gRPC funzionino correttamente, i servizi devono implementare il protocollo di controllo di integrità gRPC. Per saperne di più, consulta la sezione Creazione di controlli di integrità.

5. Crea una regola firewall per consentire le connessioni di controllo di integrità in entrata alle istanze nella tua rete:

   gcloud compute firewall-rules create grpc-vm-allow-health-checks \
     --network default --action allow --direction INGRESS \
     --source-ranges 35.191.0.0/16,209.85.152.0/22,209.85.204.0/22 \
     --target-tags allow-health-checks \
     --rules tcp:50051
   

6. Crea un servizio di backend regionale con uno schema di bilanciamento del carico di INTERNAL_SELF_MANAGED e aggiungi il controllo di integrità e un gruppo di istanze gestite creato in precedenza al servizio di backend. La porta nel nome della porta specificato viene utilizzata per connettersi alle VM nel gruppo di istanze gestite.

   gcloud compute backend-services create grpc-helloworld-service \
       --load-balancing-scheme=INTERNAL_SELF_MANAGED \
       --protocol=GRPC \
       --port-name=grpc-helloworld-port \
     --health-checks="https://www.googleapis.com/compute/v1/projects/${PROJECT}/regions/${REGION}/healthChecks/grpc-helloworld-health-check" \
       --region=${REGION}
   

7. Aggiungi il gruppo di istanze gestite a BackendService:

   gcloud compute backend-services add-backend grpc-helloworld-service \
     --instance-group=grpc-td-mig-us-central1 \
     --instance-group-zone=${ZONE} \
     --region=${REGION}
   

Configura il routing con GRPCRoute regionale

A questo punto, la mesh regionale e il servizio server gRPC sono configurati. Ora puoi configurare il routing richiesto.

1. Crea la specifica GRPCRoute regionale e archiviala nel file grpc_route.yaml:

   cat <<EOF > grpc_route.yaml
   name: helloworld-grpc-route
   hostnames:
   - helloworld-gce
   meshes:
   - projects/${PROJECT_NUMBER}/locations/${REGION}/meshes/grpc-mesh
   rules:
   - action:
       destinations:
       - serviceName: projects/${PROJECT_NUMBER}/locations/${REGION}/backendServices/grpc-helloworld-service
   EOF
   

2. Crea GRPCRoute regionale utilizzando la specifica grpc_route.yaml:

   gcloud network-services grpc-routes import helloworld-grpc-route \
       --source=grpc_route.yaml \
       --location=${REGION}
   

   Cloud Service Mesh è ora configurato per bilanciare il carico del traffico per i servizi specificati nella route gRPC tra i backend nel gruppo di istanze gestite.

Crea il servizio client gRPC

Per verificare la configurazione, crea un'istanza di un'applicazione client con un piano dati gRPC senza proxy. Questa applicazione deve specificare (nel file bootstrap) il nome della mesh.

Una volta configurata, questa applicazione può inviare una richiesta alle istanze o agli endpoint associati a helloworld-gce utilizzando l'URI del servizio xds:///helloworld-gce.

Negli esempi seguenti, utilizza lo strumento grpcurl per testare il servizio gRPC.

1. Crea una VM client:

   gcloud compute instances create grpc-client \
     --zone=${ZONE}\
     --scopes=https://www.googleapis.com/auth/cloud-platform \
     --image-family=debian-11 \
     --image-project=debian-cloud \
     --metadata-from-file=startup-script=<(echo '#! /bin/bash
   set -ex
   export PROJECT=PROJECT_NUMBER
   export REGION=us-central1
   export GRPC_XDS_BOOTSTRAP=/run/td-grpc-bootstrap.json
   echo export GRPC_XDS_BOOTSTRAP=$GRPC_XDS_BOOTSTRAP | sudo tee /etc/profile.d/grpc-xds-bootstrap.sh
   curl -L https://storage.googleapis.com/traffic-director/td-grpc-bootstrap-0.18.0.tar.gz | tar -xz
   ./td-grpc-bootstrap-0.18.0/td-grpc-bootstrap --config-mesh=grpc-mesh --xds-server-uri=trafficdirector.${REGION}.rep.googleapis.com:443 --gcp-project-number=${PROJECT} | sudo tee $GRPC_XDS_BOOTSTRAP
   sudo sed -i "s|\"authorities\": {|\"authorities\": {\n    \"traffic-director.${REGION}.xds.googleapis.com\": {\"xds_servers\":[{\"server_uri\": \"trafficdirector.${REGION}.rep.googleapis.com:443\", \"channel_creds\": [ { \"type\": \"google_default\" } ], \"server_features\": [ \"xds_v3\", \"ignore_resource_deletion\" ]}], \"client_listener_resource_name_template\": \"xdstp://traffic-director.${REGION}.xds.googleapis.com/envoy.config.listener.v3.Listener/${PROJECT}/mesh:grpc-mesh/%s\"},|g" $GRPC_XDS_BOOTSTRAP
   sudo sed -i "s|\"client_default_listener_resource_name_template\": \"xdstp://traffic-director-global.xds.googleapis.com|\"client_default_listener_resource_name_template\": \"xdstp://traffic-director.${REGION}.xds.googleapis.com|g" $GRPC_XDS_BOOTSTRAP')
   

Configura la variabile di ambiente e il file di bootstrap

L'applicazione client ha bisogno di un file di configurazione di bootstrap. Lo script di avvio nella sezione precedente imposta la variabile di ambiente GRPC_XDS_BOOTSTRAP e utilizza uno script di supporto per generare il file di bootstrap. I valori di TRAFFICDIRECTOR_GCP_PROJECT_NUMBER e della zona nel file di bootstrap generato vengono ottenuti dal server dei metadati che conosce questi dettagli sulle tue istanze VM di Compute Engine.

Puoi fornire questi valori allo script helper manualmente utilizzando l'opzione -gcp-project-number. Devi fornire un nome mesh che corrisponda alla risorsa mesh utilizzando l'opzione -config-mesh-experimental.

1. Per verificare la configurazione, accedi al client:

   gcloud compute ssh grpc-client --zone=${ZONE}
   

2. Scarica e installa lo strumento grpcurl:

   curl -L https://github.com/fullstorydev/grpcurl/releases/download/v1.9.3/grpcurl_1.9.3_linux_x86_64.tar.gz | tar -xz
   

3. Esegui lo strumento grpcurl con xds:///helloworld-gce come URI del servizio e helloworld.Greeter/SayHello come nome del servizio e metodo da richiamare.

   ./grpcurl --plaintext \
     -d '{"name": "world"}' \
     xds:///helloworld-gce helloworld.Greeter/SayHello
   

   I parametri del metodo SayHello vengono passati utilizzando l'opzione -d.

   Dovresti visualizzare un output simile a questo, dove INSTANCE_NAME è il nome dell'istanza VM:

   Greeting: Hello world, from INSTANCE_HOSTNAME
   

In questo modo viene verificato che il client gRPC senza proxy si sia connesso correttamente a Cloud Service Mesh e abbia appreso i backend per il servizio helloworld-gce utilizzando il resolver di nomi xDS. Il client ha inviato una richiesta a uno dei backend del servizio senza dover conoscere l'indirizzo IP o eseguire la risoluzione DNS.

Configurazione della configurazione del proxy sidecar Envoy con servizi HTTP con HTTPRoute regionale e mesh regionale

Questa sezione spiega come configurare un mesh di servizi basato su proxy Envoy con risorse mesh regionali e HTTPRoute regionali.

Per comodità, memorizza il numero di progetto Google Cloud in cui esegui la configurazione, in modo che tutti gli esempi di questa guida possano essere copiati e incollati nella riga di comando:

export PROJECT_ID="PROJECT_ID"
export PROJECT="PROJECT_NUMBER"
export REGION="us-central1"
export ZONE="us-central1-a"

Sostituisci quanto segue

• PROJECT_ID con l'ID progetto.
• PROJECT_NUMBER con il numero del tuo progetto.

In via facoltativa, puoi sostituire quanto segue:

• us-central1 con un'altra regione che vuoi utilizzare.
• us-central1-a con un'altra zona che vuoi utilizzare.

Configurazione mesh

Il proxy sidecar Envoy riceve la configurazione di routing del servizio da Cloud Service Mesh. Il sidecar presenta il nome della risorsa mesh regionale per identificare ilmesh di servizih specifico configurato. La configurazione di routing ricevuta da Cloud Service Mesh viene utilizzata per indirizzare il traffico che passa attraverso il proxy sidecar a vari servizi di backend regionali a seconda dei parametri della richiesta, come l'hostname o le intestazioni, configurati nelle risorse Route.

Tieni presente che il nome del mesh è la chiave utilizzata dal proxy sidecar per richiedere la configurazione associata a questo mesh.

1. Crea la specifica della mesh regionale e archiviala nel file mesh.yaml:

   cat <<EOF > mesh.yaml
   name: sidecar-mesh
   EOF
   

   Se non specificata, la porta di intercettazione è 15001.

2. Crea la mesh regionale utilizzando la specifica mesh.yaml:

   gcloud network-services meshes import sidecar-mesh \
       --source=mesh.yaml \
       --location=${REGION}
   

   Una volta creata la mesh regionale, Cloud Service Mesh è pronto a gestire la configurazione. Tuttavia, poiché non sono ancora stati definiti servizi, la configurazione sarà vuota.

Configurazione del server HTTP

A scopo dimostrativo, creerai un servizio di backend regionale con VM con scalabilità automatica (utilizzando gruppi di istanze gestite, MIG) che servirà "Hello world" utilizzando il protocollo gRPC sulla porta 80.

1. Crea il modello di istanza VM di Compute Engine con un servizio HTTP helloworld esposto sulla porta 80:

   gcloud compute instance-templates create td-httpd-vm-template \
     --scopes=https://www.googleapis.com/auth/cloud-platform \
     --tags=http-td-server \
     --image-family=debian-11 \
     --image-project=debian-cloud \
     --metadata=startup-script="#! /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"
   

2. Crea un MIG basato sul modello:

   gcloud compute instance-groups managed create http-td-mig-us-central1 \
     --zone=${ZONE} \
     --size=2 \
     --template=td-httpd-vm-template
   

3. Crea i controlli di integrità:

   gcloud compute health-checks create http http-helloworld-health-check --region=${REGION}
   

4. Crea una regola firewall per consentire le connessioni di controllo di integrità in entrata alle istanze nella tua rete:

   gcloud compute firewall-rules create http-vm-allow-health-checks \
     --network default --action allow --direction INGRESS \
     --source-ranges 35.191.0.0/16,209.85.152.0/22,209.85.204.0/22 \
     --target-tags http-td-server \
     --rules tcp:80
   

5. Crea un servizio di backend regionale con uno schema di bilanciamento del carico di INTERNAL_SELF_MANAGED:

   gcloud compute backend-services create http-helloworld-service \
       --load-balancing-scheme=INTERNAL_SELF_MANAGED \
       --protocol=HTTP \
   --health-checks="https://www.googleapis.com/compute/v1/projects/${PROJECT}/regions/${REGION}/healthChecks/http-helloworld-health-check" \
       --region=${REGION}
   

6. Aggiungi il controllo di integrità e un gruppo di istanze gestito o non gestito al servizio di backend:

   gcloud compute backend-services add-backend http-helloworld-service \
     --instance-group=http-td-mig-us-central1 \
     --instance-group-zone=${ZONE} \
     --region=${REGION}
   

   Questo esempio utilizza il gruppo di istanze gestite con il modello di VM Compute Engine che esegue il servizio HTTP di esempio creato in precedenza.

Configurazione del routing con HTTPRoute regionale

La risorsa mesh e il server HTTP sono configurati. Ora puoi collegarli utilizzando una risorsa HTTPRoute che associa un nome host a un servizio di backend.

1. Crea la specifica HTTPRoute e archiviala come http_route.yaml:

   cat <<EOF > http_route.yaml
   name: helloworld-http-route
   hostnames:
   - helloworld-gce
   meshes:
   - projects/${PROJECT_NUMBER}/locations/${REGION}/meshes/sidecar-mesh
   rules:
   - action:
       destinations:
       - serviceName: projects/${PROJECT_NUMBER}/locations/${REGION}/backendServices/http-helloworld-service
   EOF
   

2. Crea HTTPRoute utilizzando la specifica http_route.yaml:

   gcloud network-services http-routes import helloworld-http-route \
       --source=http_route.yaml \
       --location=${REGION}
   

   Cloud Service Mesh è ora configurato per bilanciare il carico del traffico per i servizi specificati in HTTPRoute nei backend del gruppo di istanze gestite.

Crea un client HTTP con un proxy sidecar Envoy

In questa sezione istanzi una VM client con il proxy sidecar Envoy per richiedere la configurazione di Cloud Service Mesh creata in precedenza. Tieni presente che il parametro mesh nel comando Google Cloud CLI fa riferimento alla risorsa mesh creata in precedenza.

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-11 \
  --image-project=debian-cloud \
  --metadata=startup-script='#! /usr/bin/env bash

# Set variables
export ENVOY_CONTROL_PLANE_REGION="us-central1"
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=mesh:sidecar-mesh
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" \
  | sed -e "s|trafficdirector.googleapis.com|trafficdirector.${ENVOY_CONTROL_PLANE_REGION}.rep.googleapis.com|g" \
  | sudo tee "${ENVOY_CONFIG}"

# Install Envoy binary
wget -O envoy_key https://apt.envoyproxy.io/signing.key
cat envoy_key | sudo gpg --dearmor > $(pwd)/envoy-keyring.gpg
echo "deb [arch=$(dpkg --print-architecture) signed-by=$(pwd)/envoy-keyring.gpg] https://apt.envoyproxy.io bullseye main" | sudo tee /etc/apt/sources.list.d/envoy.list
sudo apt-get update
sudo apt-get install 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}"
'

gcloud compute instances create td-vm-client \
  --zone=${ZONE} \
  --source-instance-template td-vm-template

1. Accedi alla VM creata:

   gcloud compute ssh td-vm-client --zone=${ZONE}
   

2. Verifica la connettività HTTP ai servizi di test creati:

   curl -H "Host: helloworld-gce" http://10.0.0.1/
   

   Il comando restituisce una risposta da una delle VM nel gruppo di istanze gestite con il relativo nome host stampato nella console.

Configurazione dei servizi TCP con TCPRoute regionale

Questo flusso di configurazione è molto simile a Configura i proxy Envoy con i servizi HTTP con l'eccezione che il servizio di backend fornisce un servizio TCP e il routing basato sui parametri TCP/IP viene utilizzato anziché sul protocollo HTTP.

Per comodità, memorizza il numero di progetto Google Cloud in cui esegui la configurazione, in modo che tutti gli esempi di questa guida possano essere copiati e incollati nella riga di comando:

export PROJECT_ID="PROJECT_ID"
export PROJECT="PROJECT_NUMBER"
export REGION="us-central1"
export ZONE="us-central1-a"

Sostituisci quanto segue

• PROJECT_ID con l'ID progetto.
• PROJECT_NUMBER con il numero del tuo progetto.

In via facoltativa, puoi sostituire quanto segue:

• us-central1 con un'altra regione che vuoi utilizzare.
• us-central1-a con un'altra zona che vuoi utilizzare.

Configurazione mesh

1. Crea la specifica della mesh regionale e archiviala nel file mesh.yaml:

   cat <<EOF > mesh.yaml
   name: sidecar-mesh
   EOF
   

2. Crea la mesh regionale utilizzando la specifica mesh.yaml:

   gcloud network-services meshes import sidecar-mesh \
       --source=mesh.yaml \
       --location=${REGION}
   

Configurazione del server TCP

A scopo dimostrativo, creerai un servizio di backend regionale con VM scalate automaticamente (utilizzando gruppi di istanze gestite, MIG) che servirà "hello world" utilizzando il protocollo gRPC sulla porta 10000.

1. Crea il modello di istanza VM di Compute Engine con un servizio di test sulla porta 10000 utilizzando l'utilità netcat:

   gcloud compute instance-templates create tcp-td-vm-template \
     --scopes=https://www.googleapis.com/auth/cloud-platform \
     --tags=allow-health-checks \
     --image-family=debian-11 \
     --image-project=debian-cloud \
     --metadata=startup-script="#! /bin/bash
   sudo apt-get update -y
   sudo apt-get install netcat -y
   while true;
     do echo 'Hello from TCP service' | nc -l -s 0.0.0.0 -p 10000;
   done &"
   

2. Crea un MIG basato sul modello:

   gcloud compute instance-groups managed create tcp-td-mig-us-central1 \
     --zone=${ZONE} \
     --size=1 \
     --template=tcp-td-vm-template
   

3. Imposta le porte denominate sul gruppo di istanze gestite creato su port 10000:

   gcloud compute instance-groups set-named-ports tcp-td-mig-us-central1 \
     --zone=${ZONE} --named-ports=tcp:10000
   

4. Crea un controllo di integrità a livello di regione:

   gcloud compute health-checks create tcp tcp-helloworld-health-check --port 10000 --region=${REGION}
   

5. Crea una regola firewall per consentire le connessioni di controllo di integrità in entrata alle istanze nella tua rete:

   gcloud compute firewall-rules create tcp-vm-allow-health-checks \
     --network default --action allow --direction INGRESS \
     --source-ranges 35.191.0.0/16,209.85.152.0/22,209.85.204.0/22 \
     --target-tags allow-health-checks \
     --rules tcp:10000
   

6. Crea un servizio di backend regionale con uno schema di bilanciamento del carico di INTERNAL_SELF_MANAGED e aggiungi il controllo di integrità e un gruppo di istanze gestite o non gestite al servizio di backend.

   gcloud compute backend-services create tcp-helloworld-service \
       --region=${REGION} \
       --load-balancing-scheme=INTERNAL_SELF_MANAGED \
       --protocol=TCP \
       --port-name=tcp \
       --health-checks="https://www.googleapis.com/compute/v1/projects/${PROJECT}/regions/${REGION}/healthChecks/tcp-helloworld-health-check"
   

7. Aggiungi il MIG a BackendService:

   gcloud compute backend-services add-backend tcp-helloworld-service \
     --instance-group tcp-td-mig-us-central1 \
     --instance-group-zone=${ZONE} \
     --region=${REGION}
   

Configura il routing con TCPRoute regionale

1. Crea la specifica TCPRoute e archiviala nel file tcp_route.yaml:

   cat <<EOF > tcp_route.yaml
   name: helloworld-tcp-route
   meshes:
   - projects/$PROJECT_NUMBER/locations/$REGION/meshes/sidecar-mesh
   rules:
   - action:
       destinations:
       - serviceName: projects/$PROJECT_NUMBER/locations/$REGION/backendServices/tcp-helloworld-service
     matches:
     - address: '10.0.0.1/32'
       port: '10000'
   EOF
   

2. Crea TCPRoute utilizzando la specifica tcp_route.yaml:

   gcloud network-services tcp-routes import helloworld-tcp-route \
       --source=tcp_route.yaml \
       --location=${REGION}
   

Crea un client TCP con un proxy sidecar Envoy

1. Crea una VM con Envoy connesso a Cloud Service Mesh:

   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-11 \
     --image-project=debian-cloud \
     --metadata=startup-script='#! /usr/bin/env bash
   
   # Set variables
   export ENVOY_CONTROL_PLANE_REGION="us-central1"
   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=mesh:sidecar-mesh
   
   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" \
     | sed -e "s|trafficdirector.googleapis.com|trafficdirector.${ENVOY_CONTROL_PLANE_REGION}.rep.googleapis.com|g" \
     | sudo tee "${ENVOY_CONFIG}"
   
   # Install Envoy binary
   wget -O envoy_key https://apt.envoyproxy.io/signing.key
   cat envoy_key | sudo gpg --dearmor > $(pwd)/envoy-keyring.gpg
   echo "deb [arch=$(dpkg --print-architecture) signed-by=$(pwd)/envoy-keyring.gpg] https://apt.envoyproxy.io bullseye main" | sudo tee /etc/apt/sources.list.d/envoy.list
   sudo apt-get update
   sudo apt-get install 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}"
   '
   
   gcloud compute instances create td-vm-client \
     --zone=${ZONE} \
     --source-instance-template td-vm-template
   

2. Accedi alla VM creata:

   gcloud compute ssh td-vm-client --zone=${ZONE}
   

3. Verifica la connettività ai servizi di test creati:

   curl 10.0.0.1:10000 --http0.9 -v
   

   Dovresti vedere il testo Hello from TCP service restituito, nonché qualsiasi testo digitato restituito dal servizio netcat in esecuzione sulla VM remota.

Configurazione del mesh regionale nel progetto host

Designa un progetto come progetto host. Qualsiasi account di servizio con l'autorizzazione a creare/aggiornare/eliminare mesh in questo progetto può controllare le configurazioni di routing associate alle mesh regionali in questo progetto.

1. Definisci una variabile che verrà utilizzata in tutto l'esempio:

   export REGION="us-central1"
   

   Se vuoi, puoi sostituire us-central1 con un'altra regione che vuoi utilizzare.

2. Crea la specifica della mesh e archiviala nel file mesh.yaml:

   cat <<EOF > mesh.yaml
   name: shared-mesh
   EOF
   

3. Definisci una risorsa mesh in questo progetto con la configurazione richiesta:

   gcloud network-services meshes import shared-mesh \
       --source=mesh.yaml \
       --location=${REGION}
   

   Prendi nota dell'URI completo di questa risorsa mesh. I proprietari dei servizi ne avranno bisogno in futuro per collegare le proprie route a questo mesh.

4. Concedi l'autorizzazione IAM networkservices.meshes.use a questo mesh e ai service account tra progetti che devono essere in grado di collegare le informazioni sui servizi a questo mesh:

   gcloud projects add-iam-policy-binding HOST_PROJECT_NUMBER --member='HTTP_ROUTE_SERVICE_OWNER_ACCOUNT' --role='roles/compute.networkAdmin'
   

   Ora tutti i proprietari dei servizi a cui è stata concessa l'autorizzazione networkservices.meshes.use possono aggiungere le proprie regole di routing a questo mesh.

Configurazione delle route nei service project

Ogni proprietario del servizio deve creare servizi di backend regionali e risorse di route regionali nel proprio progetto in modo simile a Configura i proxy Envoy con i servizi HTTP. L'unica differenza è che ogni HTTPRoute/GRPCRoute/TCPRoute avrebbe l'URI della risorsa mesh del progetto host nel campo meshes.

1. Crea una route HTTP sharedvpc:

   echo "name: sharedvpc-http-route
   hostnames:
   - helloworld-gce
   meshes:
   - /projects/HOST_PROJECT_NUMBER/locations/${REGION}/meshes/shared-mesh
   rules:
   - action:
       destinations:
       - serviceName: \"SERVICE_URL\"" | \
   gcloud network-services http-routes import sharedvpc-http-route \
       --source=- \
       --location=${REGION}
   

Configurazione dei servizi client nei service project

Durante la configurazione di un client Cloud Service Mesh (proxy Envoy o senza proxy) che si trova in un progetto di servizio, è necessario specificare il numero di progetto in cui si trova la risorsa mesh e il nome della mesh nella configurazione di bootstrap:

TRAFFICDIRECTOR_GCP_PROJECT_NUMBER=HOST_PROJECT_NUMBER
TRAFFICDIRECTOR_MESH_NAME=MESH_NAME

Routing TLS del gateway

Questa sezione mostra come configurare un gateway in entrata basato su proxy Envoy con risorse Gateway regionali e TLSRoute regionali.

Un bilanciatore del carico di rete passthrough esterno regionale indirizza il traffico ai proxy Envoy che fungono da gateway in entrata. I proxy Envoy utilizzano l'instradamento TLS passthrough e indirizzano il traffico ai server HTTPS in esecuzione sulle istanze VM di backend.

Definisci alcune variabili che verranno utilizzate nell'esempio.

export PROJECT_ID="PROJECT_ID"
export PROJECT_NUMBER="PROJECT_NUMBER"
export REGION="us-central1"
export ZONE="us-central1-b"
export NETWORK_NAME = "default"

Sostituisci quanto segue: default

• PROJECT_ID con l'ID progetto.
• PROJECT_NUMBER con il numero del tuo progetto.

In via facoltativa, puoi sostituire quanto segue:

• us-central1 con un'altra regione che vuoi utilizzare.
• us-central1-b con un'altra zona che vuoi utilizzare.
• default con un nome di rete diverso che vuoi utilizzare.

Riferimento incrociato alle risorse di mesh regionale e route regionale in un ambiente VPC condiviso multiprogetto

Esistono scenari in cui la configurazione mesh di servizi è costituita da servizi di proprietà di progetti diversi. Ad esempio, nelle implementazioni di VPC condiviso o VPC con peering è possibile che ogni proprietario del progetto definisca il proprio insieme di servizi con lo scopo di renderli disponibili a tutti gli altri progetti.

Questa configurazione è "cross-project" perché più risorse definite in progetti diversi vengono combinate per formare una singola configurazione che può essere fornita a un proxy o a un client senza proxy.

Nota: i riferimenti tra le risorsa di regione devono esistere nella stessa regione.

Configura le regole firewall

1. Configura le regole del firewall per consentire il traffico da qualsiasi origine. Modifica i comandi per le porte e gli intervalli di indirizzi IP di origine.

   gcloud compute firewall-rules create allow-gateway-health-checks \
   --network=${NETWORK_NAME} \
   --direction=INGRESS \
   --action=ALLOW \
   --rules=tcp \
   --source-ranges="35.191.0.0/16,209.85.152.0/22,209.85.204.0/22" \
   --target-tags=gateway-proxy
   

Configurare le autorizzazioni IAM

1. Crea un'identità del account di servizio per i proxy gateway:

   gcloud iam service-accounts create gateway-proxy
   

2. Assegna i ruoli IAM richiesti all'identità del account di servizio:

   gcloud projects add-iam-policy-binding ${PROJECT_ID} \
     --member="serviceAccount:gateway-proxy@${PROJECT_ID}.iam.gserviceaccount.com" \
     --role="roles/trafficdirector.client"
   

   gcloud projects add-iam-policy-binding ${PROJECT_ID} \
     --member="serviceAccount:gateway-proxy@${PROJECT_ID}.iam.gserviceaccount.com" \
     --role="roles/logging.logWriter"
   

Configura il gateway regionale:

1. In un file denominato gateway8443.yaml, crea la specifica del gateway per il traffico HTTP:

   cat <<EOF > gateway8443.yaml
   name: gateway8443
   scope: gateway-proxy-8443
   ports:
   - 8443
   type: OPEN_MESH
   EOF
   

2. Crea la risorsa Gateway regionale utilizzando la specifica gateway8443.yaml:

   gcloud network-services gateways import gateway8443 \
       --source=gateway8443.yaml \
       --location=${REGION}
   

Creazione di un gruppo di istanze gestite con proxy Envoy

In questa sezione crei un modello di istanza per una VM che esegue un proxy di servizio Envoy di cui è stato eseguito il deployment automatico. L'ambito degli inviati è impostato su gateway-proxy. Non trasmettere la porta di pubblicazione come parametro del flag --service-proxy.

1. Crea un gruppo di istanze gestite con proxy Envoy:

   gcloud beta compute instance-templates create gateway-proxy \
     --scopes=https://www.googleapis.com/auth/cloud-platform \
     --tags=gateway-proxy,http-td-tag,http-server,https-server \
     --image-family=debian-11 \
     --image-project=debian-cloud \
     --network-interface=network=${NETWORK_NAME} \
     --service-account="gateway-proxy@${PROJECT_ID}.iam.gserviceaccount.com" \
     --metadata=startup-script='#! /usr/bin/env bash
   
   # Set variables
   export ENVOY_CONTROL_PLANE_REGION="us-central1"
   export GCP_PROJECT_NUMBER=PROJECT_NUMBER
   export VPC_NETWORK_NAME=scope:gateway-proxy-8443
   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 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" \
     | sed -e "s|trafficdirector.googleapis.com|trafficdirector.${ENVOY_CONTROL_PLANE_REGION}.rep.googleapis.com|g" \
     | sudo tee "${ENVOY_CONFIG}"
   
   # Install Envoy binary
   wget -O envoy_key https://apt.envoyproxy.io/signing.key
   cat envoy_key | sudo gpg --dearmor > $(pwd)/envoy-keyring.gpg
   echo "deb [arch=$(dpkg --print-architecture) signed-by=$(pwd)/envoy-keyring.gpg] https://apt.envoyproxy.io bullseye main" | sudo tee /etc/apt/sources.list.d/envoy.list
   sudo apt-get update
   sudo apt-get install 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}"
   '
   

2. Crea un gruppo di istanze gestite a livello di regione dal modello di istanza:

   gcloud compute instance-groups managed create gateway-proxy \
     --region=${REGION} \
     --size=1 \
     --template=gateway-proxy
   

3. Imposta il nome della porta di pubblicazione per il gruppo di istanze gestite:

   gcloud compute instance-groups managed set-named-ports gateway-proxy \
     --named-ports=https:8443 \
     --region=${REGION}
   

Configura il bilanciatore del carico di rete passthrough esterno regionale

1. Crea un indirizzo IP esterno regionale statico:

   gcloud compute addresses create xnlb-${REGION} \
     --region=${REGION}
   

2. Ottieni l'indirizzo IP riservato al bilanciatore del carico esterno:

   gcloud compute addresses describe xnlb-${REGION} \
     --region=${REGION} --format='value(address)'
   

3. Crea un controllo di integrità per i proxy gateway:

   gcloud compute health-checks create tcp xnlb-${REGION} \
     --region=${REGION} \
     --use-serving-port
   

4. Crea un servizio di backend per i proxy del gateway:

   gcloud compute backend-services create xnlb-${REGION} \
     --health-checks=xnlb-${REGION} \
     --health-checks-region=${REGION} \
     --load-balancing-scheme=EXTERNAL \
     --protocol=TCP \
     --region=${REGION} \
     --port-name=https
   

5. Aggiungi il gruppo di istanze gestite come backend:

   gcloud compute backend-services add-backend xnlb-${REGION} \
     --instance-group=gateway-proxy \
     --instance-group-region=${REGION} \
     --region=${REGION}
   

6. Crea una regola di forwarding per instradare il traffico ai proxy gateway:

   gcloud compute forwarding-rules create xnlb-${REGION} \
     --region=${REGION} \
     --load-balancing-scheme=EXTERNAL \
     --address=${IP_ADDRESS} \
     --ip-protocol=TCP \
     --ports=8443 \
     --backend-service=xnlb-${REGION} \
     --backend-service-region=${REGION}
   

Configura un gruppo di istanze gestite che esegue un servizio HTTPS

1. Crea un modello di istanza con un servizio HTTPS esposto sulla porta 8443:

   gcloud compute instance-templates create td-https-vm-template \
     --scopes=https://www.googleapis.com/auth/cloud-platform \
     --tags=https-td-server \
     --image-family=debian-11 \
     --image-project=debian-cloud \
     --metadata=startup-script='#! /bin/bash
   
   sudo rm -rf /var/lib/apt/lists/*
   sudo apt-get -y clean
   sudo apt-get -y update
   sudo apt-get -y install apt-transport-https ca-certificates curl gnupg2 software-properties-common
   sudo curl -fsSL https://download.docker.com/linux/debian/gpg | sudo apt-key add -
   sudo add-apt-repository -y "deb [arch=amd64] https://download.docker.com/linux/debian $(lsb_release -cs) stable"
   sudo apt-get -y update
   sudo apt-get -y install docker-ce
   sudo which docker
   echo "{ \"registry-mirrors\": [\"https://mirror.gcr.io\"] }" | sudo tee -a /etc/docker/daemon.json
   sudo service docker restart
   sudo docker run -e HTTPS_PORT=9999 -p 8443:9999 --rm -dt mendhak/http-https-echo:22'
   

2. Crea un gruppo di istanze gestite basato sul modello di istanza:

   gcloud compute instance-groups managed create https-td-mig-us-${REGION} \
     --zone=${ZONE} \
     --size=2 \
     --template=td-https-vm-template
   

3. Imposta il nome della porta di pubblicazione per il gruppo di istanze gestite:

   gcloud compute instance-groups managed set-named-ports https-td-mig-us-${REGION} \
     --named-ports=https:8443 \
     --zone=${ZONE}
   

4. Crea un controllo di integrità:

   gcloud compute health-checks create https https-helloworld-health-check \
     --port=8443 --region=${REGION}
   

5. Crea una regola firewall per consentire le connessioni di controllo di integrità in entrata alle istanze nella tua rete:

   gcloud compute firewall-rules create https-vm-allow-health-checks \
     --network ${NETWORK_NAME} --action allow --direction INGRESS \
     --source-ranges 35.191.0.0/16,130.211.0.0/22 \
     --target-tags https-td-server \
     --rules tcp:8443
   

6. Crea un servizio di backend regionale con uno schema di bilanciamento del carico di INTERNAL_SELF_MANAGED e aggiungi il controllo di integrità:

   gcloud compute backend-services create https-helloworld-service \
     --region=${REGION} \
     --load-balancing-scheme=INTERNAL_SELF_MANAGED \
     --port-name=https \
     --health-checks="https://www.googleapis.com/compute/v1/projects/${PROJECT}/regions/${REGION}/healthChecks/https-helloworld-health-check"
   

7. Aggiungi il gruppo di istanze gestite come backend al servizio di backend:

   gcloud compute backend-services add-backend https-helloworld-service \
     --instance-group=https-td-mig-us-${REGION} \
     --instance-group-zone=${ZONE} \
     --region=${REGION}
   

Configura il routing con una risorsa TLSRoute

1. In un file denominato tls_route.yaml, crea la specifica TLSRoute:

   cat <<EOF > tls_route.yaml
   name: helloworld-tls-route
   gateways:
   - projects/${PROJECT_NUMBER}/locations/${REGION}/gateways/gateway8443
   rules:
   - matches:
     - sniHost:
       - example.com
       alpn:
       - h2
     action:
       destinations:
       - serviceName: projects/${PROJECT_NUMBER}/locations/${REGION}/backendServices/https-helloworld-service
   EOF
   

   Nell'istruzione precedente, TLSRoute corrisponde a example.com come SNI e h2 come ALPN. Se le corrispondenze vengono modificate come segue, TLSRoute corrisponde a SNI o ALPN:

   - matches:
     - sniHost:
       - example.com
     - alpn:
       - h2
   

2. Utilizza la specifica tls_route.yaml per creare la risorsa TLSRoute:

   gcloud network-services tls-routes import helloworld-tls-route \
       --source=tls_route.yaml \
       --location=${REGION}
   

Convalida il deployment

1. Esegui il seguente comando curl per verificare la connettività HTTP ai servizi di test che hai creato:

   curl https://example.com:8443 --resolve example.com:8443:${IP_ADDRESS} -k
   

2. Il comando restituisce una risposta da una delle VM nel gruppo di istanze gestite. L'output è simile al seguente:

   {
     "path": "/",
     "headers": {
       "host": "example.com:8443",
       "user-agent": "curl/8.16.0",
       "accept": "*/*"
     },
     "method": "GET",
     "body": "",
     "fresh": false,
     "hostname": "example.com",
     "ip": "::ffff:10.128.0.59",
     "ips": [],
     "protocol": "https",
     "query": {},
     "subdomains": [],
     "xhr": false,
     "os": {
       "hostname": "19cd7812e792"
     },
     "connection": {
       "servername": "example.com"
     }
   

Verifica con esito negativo

1. Nel comando seguente, l'SNI non corrisponde a example.com, quindi il gateway rifiuta la connessione:

   curl https://invalid-server.com:8443 --resolve invalid-server.com:8443:${IP_ADDRESS} -k
   

2. Nel comando seguente, ALPN non corrisponde a h2 (protocollo HTTP2), quindi il gateway rifiuta la connessione:

   curl https://example.com:8443 --resolve example.com:8443:${IP_ADDRESS} -k --http1.1
   

   Tutti i comandi precedenti restituiscono il seguente errore:

   curl: (35) OpenSSL SSL_connect: Connection reset by peer in connection.
   

3. Nel comando seguente, il client sta creando una connessione di testo normale (non criptata), pertanto il gateway rifiuta la connessione con un errore 404 Non trovato:

   curl example.com:8443 --resolve example.com:8443:${IP_ADDRESS} -k