Cloud Service Mesh Regional

Pratinjau — Regional Cloud Service Mesh

Fitur ini tunduk pada "Persyaratan Penawaran Pra-GA" di bagian Persyaratan Layanan Umum dari Persyaratan Khusus Layanan. Fitur pra-GA tersedia "sebagaimana adanya" dan mungkin memiliki dukungan terbatas. Untuk mengetahui informasi selengkapnya, lihat deskripsi tahap peluncuran.

Dengan isolasi regional, klien yang terhubung ke region tertentu dari bidang kontrol Cloud Service Mesh hanya dapat mengakses resource dalam region tersebut. Demikian pula, resource API dalam region tertentu hanya dapat merujuk ke resource lain di region tersebut.

Cloud Service Mesh regional memiliki Batasan berikut:

• Istio API tidak didukung. Anda tidak dapat menggunakan Kubernetes dengan Istio API menggunakan Traffic Director regional. Hanya API Google Cloud yang didukung dalam pratinjau ini.
• Pertimbangan dan batasan yang ada dari API perutean layanan global berlaku.
• Versi Envoy minimum untuk mendukung skema penamaan xdSTP adalah v1.31.1.
• Gateway for Mesh API tidak didukung.
• Versi gRPC minimum adalah v1.65.

• Hanya wilayah berikut yang didukung:

  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
  

Harga

Setiap region tempat Cloud Service Mesh regional didukung akan memiliki SKU regional saat fitur ini Tersedia Secara Umum. Untuk saat ini, harga sama dengan global.

Menyiapkan klien xDS untuk Cloud Service Mesh

xDS Envoy Compute VM

Manual

Langkah-langkah manual ini didasarkan pada Menyiapkan VM menggunakan deployment Envoy manual. Perbedaan utamanya adalah ENVOY_CONTROL_PLANE_REGION ditetapkan dan disuntikkan ke bootstrap.

1. Buat template instance:

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

xDS gRPC VM Compute

Mirip dengan Cloud Service Mesh global, klien gRPC perlu mengonfigurasi bootstrap untuk memberi tahu cara terhubung ke Cloud Service Mesh Regional.

Anda dapat menggunakan generator bootstrap gRPC untuk membuat bootstrap ini. Untuk menyetelnya agar menggunakan Cloud Service Mesh regional, tentukan flag baru: --xds-server-region.

Dalam contoh ini, menyetel xds-server-region ke us-central1 secara otomatis menentukan endpoint Cloud Service Mesh regional: trafficdirector.us-central1.rep.googleapis.com:443.

Injeksi Envoy Manual K8s

Langkah-langkah manual ini didasarkan pada Menyiapkan Pod Google Kubernetes Engine menggunakan injeksi Envoy manual. Namun, Anda hanya perlu mengubah bagian tentang penyuntikan pod manual.

1. Ubah bidang kontrol dari global menjadi regional:

   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. Terapkan perubahan:

      kubectl apply -f trafficdirector_client_new_api_sample_xdsv3.yaml
        ```
      

Panduan penyiapan

Bagian ini mencakup lima konfigurasi dan model deployment independen. Berikut adalah semua panduan penyiapan API perutean layanan global yang ada dalam versi regional.

• Mengonfigurasi layanan gRPC tanpa proxy dengan GRPCRoute regional dan Cloud Service Mesh regional
• Mengonfigurasi konfigurasi proxy sidecar Envoy dengan layanan HTTP menggunakan HTTPRoute regional dan Cloud Service Mesh regional
• Mengonfigurasi layanan TCP dengan TCPRoute regional
• Perutean TLS gateway
• Mengonfigurasi referensi lintas project untuk Cloud Service Mesh regional dan Rute regional

Mengonfigurasi layanan gRPC tanpa proxy dengan GRPCRoute regional dan Cloud Service Mesh regional

Bagian ini menjelaskan cara mengonfigurasi mesh layanan gRPC tanpa proxy dengan Cloud Service Mesh regional dan resource GRPCRoute regional.

Untuk mempermudah, simpan nomor project Google Cloud yang Anda gunakan untuk melakukan konfigurasi, sehingga semua contoh dalam panduan ini dapat disalin dan ditempel di command line:

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

Ganti PROJECT_NUMBER dengan nomor project Anda.

Secara opsional, Anda dapat mengganti hal berikut:

• us-central1 dengan region lain yang ingin Anda gunakan.
• us-central1-a dengan zona lain yang ingin Anda gunakan.
• default dengan VPC_NAME yang berbeda.

Konfigurasi mesh

Saat aplikasi gRPC tanpa proxy terhubung ke xds://hostname, library klien gRPC membuat koneksi ke Cloud Service Mesh untuk mendapatkan konfigurasi perutean yang diperlukan untuk merutekan permintaan untuk nama host.

1. Buat spesifikasi Mesh dan simpan di file mesh.yaml:

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

2. Buat Mesh menggunakan spesifikasi mesh.yaml:

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

   Setelah mesh regional dibuat, Cloud Service Mesh siap menyajikan konfigurasi. Namun, karena belum ada layanan yang ditentukan, konfigurasi kosong.

Konfigurasi layanan gRPC

Untuk tujuan demonstrasi, Anda akan membuat Layanan Backend regional dengan VM yang diskalakan otomatis (menggunakan Grup instance terkelola - MIG) yang akan melayani hello world menggunakan protokol gRPC di port 50051.

1. Buat template instance VM Compute Engine dengan layanan gRPC helloworld yang diekspos di port 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. Buat MIG berdasarkan template:

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

3. Konfigurasi port bernama untuk layanan gRPC. Ini adalah port tempat layanan gRPC dikonfigurasi untuk memproses permintaan.

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

   Dalam contoh ini, port-nya adalah 50051.

4. Buat health check gRPC.

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

   Layanan harus menerapkan protokol pemeriksaan kesehatan gRPC agar pemeriksaan kesehatan gRPC berfungsi dengan baik. Untuk mengetahui informasi selengkapnya, lihat Membuat health check.

5. Buat aturan firewall untuk mengizinkan koneksi health check yang masuk ke instance di jaringan Anda:

   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. Buat Backend Service regional dengan skema load balancing INTERNAL_SELF_MANAGED, lalu tambahkan health check dan grup instance terkelola yang dibuat sebelumnya ke Backend Service. Port dalam port-name yang ditentukan digunakan untuk terhubung ke VM dalam grup instance terkelola.

   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. Tambahkan grup instance terkelola ke BackendService:

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

Menyiapkan perutean dengan GRPCRoute regional

Pada tahap ini, mesh regional dan layanan server gRPC dikonfigurasi. Sekarang Anda dapat menyiapkan perutean yang diperlukan.

1. Buat spesifikasi GRPCRoute regional dan simpan di 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. Buat GRPCRoute regional menggunakan spesifikasi grpc_route.yaml:

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

   Cloud Service Mesh kini dikonfigurasi untuk melakukan load balancing traffic bagi layanan yang ditentukan dalam Rute gRPC di seluruh backend dalam grup instance terkelola.

Buat layanan klien gRPC

Untuk memverifikasi konfigurasi, buat instance aplikasi klien dengan bidang data gRPC tanpa proxy. Aplikasi ini harus menentukan (dalam file bootstrap-nya) nama mesh.

Setelah dikonfigurasi, aplikasi ini dapat mengirim permintaan ke instance atau endpoint yang terkait dengan helloworld-gce menggunakan URI layanan xds:///helloworld-gce.

Dalam contoh berikut, gunakan alat grpcurl untuk menguji layanan gRPC.

1. Buat VM klien:

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

Menyiapkan variabel lingkungan dan file bootstrap

Aplikasi klien memerlukan file konfigurasi bootstrap. Skrip startup di bagian sebelumnya menetapkan variabel lingkungan GRPC_XDS_BOOTSTRAP dan menggunakan skrip helper untuk membuat file bootstrap. Nilai untuk TRAFFICDIRECTOR_GCP_PROJECT_NUMBER dan zona dalam file bootstrap yang dihasilkan diperoleh dari server metadata yang mengetahui detail ini tentang instance VM Compute Engine Anda.

Anda dapat memberikan nilai ini ke skrip pembantu secara manual menggunakan opsi -gcp-project-number. Anda harus memberikan nama mesh yang cocok dengan resource mesh menggunakan opsi -config-mesh-experimental.

1. Untuk memverifikasi konfigurasi, login ke klien:

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

2. Download dan instal alat 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. Jalankan alat grpcurl dengan xds:///helloworld-gce sebagai URI layanan dan helloworld.Greeter/SayHello sebagai nama dan metode layanan yang akan dipanggil.

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

   Parameter ke metode SayHello diteruskan menggunakan opsi -d.

   Anda akan melihat output yang serupa dengan ini, di mana INSTANCE_NAME adalah nama instance VM:

   Greeting: Hello world, from INSTANCE_HOSTNAME
   

Hal ini memverifikasi bahwa klien gRPC tanpa proxy berhasil terhubung ke Cloud Service Mesh dan mempelajari backend untuk layanan helloworld-gce menggunakan pemecah nama xDS. Klien mengirim permintaan ke salah satu backend layanan tanpa perlu mengetahui alamat IP atau melakukan resolusi DNS.

Mengonfigurasi konfigurasi proxy sidecar Envoy dengan layanan HTTP dengan HTTPRoute regional dan Mesh regional

Bagian ini menjelaskan cara mengonfigurasi mesh layanan berbasis proxy Envoy dengan resource HTTPRoute regional dan mesh regional.

Untuk mempermudah, simpan nomor project Google Cloud yang Anda gunakan untuk melakukan konfigurasi, sehingga semua contoh dalam panduan ini dapat disalin dan ditempel di command line:

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

Ganti kode berikut:

• PROJECT_ID dengan ID project Anda.
• PROJECT_NUMBER dengan nomor project Anda.

Secara opsional, Anda dapat mengganti hal berikut:

• us-central1 dengan region lain yang ingin Anda gunakan.
• us-central1-a dengan zona lain yang ingin Anda gunakan.

Konfigurasi mesh

Proxy Envoy sidecar menerima konfigurasi perutean layanan dari Cloud Service Mesh. Sidecar menampilkan nama resource mesh regional untuk mengidentifikasi mesh layanan tertentu yang dikonfigurasi. Konfigurasi perutean yang diterima dari Cloud Service Mesh digunakan untuk mengarahkan traffic yang melewati proxy sidecar ke berbagai Layanan Backend regional, bergantung pada parameter permintaan, seperti nama host atau header, yang dikonfigurasi di resource Rute.

Perhatikan bahwa nama mesh adalah kunci yang digunakan proxy sidecar untuk meminta konfigurasi yang terkait dengan mesh ini.

1. Buat spesifikasi mesh regional dan simpan di file mesh.yaml:

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

   Port penyadapan secara default adalah 15001 jika tidak ditentukan.

2. Buat mesh regional menggunakan spesifikasi mesh.yaml:

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

   Setelah mesh regional dibuat, Cloud Service Mesh siap menyajikan konfigurasi. Namun, karena belum ada layanan yang ditentukan, konfigurasi akan kosong.

Konfigurasi server HTTP

Untuk tujuan demonstrasi, Anda akan membuat Layanan Backend regional dengan VM berskala otomatis (menggunakan Grup instance terkelola - MIG) yang akan menyalurkan "hello world" menggunakan protokol gRPC di port 80.

1. Buat template instance VM Compute Engine dengan layanan helloworldHTTP yang diekspos di port 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. Buat MIG berdasarkan template:

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

3. Buat health check:

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

4. Buat aturan firewall untuk mengizinkan koneksi health check yang masuk ke instance di jaringan Anda:

   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. Buat Backend Service regional dengan skema load balancing 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. Tambahkan pemeriksaan kesehatan dan grup instance terkelola atau tidak terkelola ke layanan backend:

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

   Contoh ini menggunakan grup instance terkelola dengan template VM Compute Engine yang menjalankan layanan HTTP contoh yang kita buat sebelumnya.

Menyiapkan pemilihan rute dengan HTTPRoute regional

Resource mesh dan server HTTP dikonfigurasi. Sekarang Anda dapat menghubungkannya menggunakan resource HTTPRoute yang mengaitkan nama host dengan Layanan Backend.

1. Buat spesifikasi HTTPRoute dan simpan sebagai 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. Buat HTTPRoute menggunakan spesifikasi http_route.yaml:

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

   Cloud Service Mesh kini dikonfigurasi untuk menyeimbangkan beban traffic untuk layanan yang ditentukan dalam HTTPRoute di seluruh backend dalam grup instance terkelola.

Membuat klien HTTP dengan sidecar Envoy

Di bagian ini, Anda akan membuat instance VM klien dengan proxy sidecar Envoy untuk meminta konfigurasi Cloud Service Mesh yang dibuat sebelumnya. Perhatikan bahwa parameter mesh dalam perintah Google Cloud CLI mereferensikan resource mesh yang dibuat sebelumnya.

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. Login ke VM yang dibuat:

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

2. Verifikasi konektivitas HTTP ke layanan pengujian yang dibuat:

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

   Perintah ini akan menampilkan respons dari salah satu VM di Managed Instance Group dengan nama hostnya yang dicetak ke konsol.

Mengonfigurasi layanan TCP dengan TCPRoute regional

Alur konfigurasi ini sangat mirip dengan Menyiapkan proxy Envoy dengan layanan HTTP dengan pengecualian bahwa Layanan Backend menyediakan layanan TCP dan perutean berdasarkan parameter TCP/IP digunakan, bukan berdasarkan protokol HTTP.

Untuk mempermudah, simpan nomor project Google Cloud yang Anda gunakan untuk melakukan konfigurasi, sehingga semua contoh dalam panduan ini dapat disalin dan ditempel di command line:

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

Ganti kode berikut:

• PROJECT_ID dengan ID project Anda.
• PROJECT_NUMBER dengan nomor project Anda.

Secara opsional, Anda dapat mengganti hal berikut:

• us-central1 dengan region lain yang ingin Anda gunakan.
• us-central1-a dengan zona lain yang ingin Anda gunakan.

Konfigurasi mesh

1. Buat spesifikasi mesh regional dan simpan di file mesh.yaml:

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

2. Buat mesh regional menggunakan spesifikasi mesh.yaml:

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

Konfigurasi server TCP

Untuk tujuan demonstrasi, Anda akan membuat Layanan Backend regional dengan VM yang diskalakan otomatis (menggunakan Grup instance terkelola - MIG) yang akan melayani "hello world" menggunakan protokol gRPC di port 10000.

1. Buat template instance VM Compute Engine dengan layanan pengujian di port 10000 menggunakan utilitas 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. Buat MIG berdasarkan template:

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

3. Tetapkan port bernama pada grup instance terkelola yang dibuat ke port 10000:

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

4. Membuat health check regional:

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

5. Buat aturan firewall untuk mengizinkan koneksi health check yang masuk ke instance di jaringan Anda:

   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. Buat Layanan Backend regional dengan skema load balancing INTERNAL_SELF_MANAGED, lalu tambahkan health check dan grup instance terkelola atau tidak terkelola ke layanan 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. Tambahkan MIG ke BackendService:

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

Menyiapkan perutean dengan TCPRoute regional

1. Buat spesifikasi TCPRoute dan simpan di 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. Buat TCPRoute menggunakan spesifikasi tcp_route.yaml:

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

Membuat klien TCP dengan sidecar Envoy

1. Buat VM dengan Envoy yang terhubung ke 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. Login ke VM yang dibuat:

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

3. Verifikasi konektivitas ke layanan pengujian yang dibuat:

   curl 10.0.0.1:10000 --http0.9 -v
   

   Anda akan melihat teks Hello from TCP service yang ditampilkan kepada Anda serta dapat melihat teks apa pun yang Anda ketik yang ditampilkan kembali kepada Anda oleh layanan netcat yang berjalan di VM jarak jauh.

Konfigurasi mesh regional di project host

Tetapkan project sebagai project host. Akun layanan apa pun dengan izin untuk membuat/memperbarui/menghapus mesh dalam project ini dapat mengontrol konfigurasi perutean yang dilampirkan ke mesh regional dalam project ini.

1. Tentukan variabel yang akan digunakan di seluruh contoh:

   export REGION="us-central1"
   

   Jika ingin, Anda dapat mengganti us-central1 dengan region lain yang ingin Anda gunakan.

2. Buat spesifikasi mesh dan simpan di file mesh.yaml:

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

3. Tentukan resource mesh dalam project ini dengan konfigurasi yang diperlukan:

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

   Catat URI lengkap resource mesh ini. Pemilik layanan akan memerlukannya di masa mendatang untuk melampirkan rute mereka ke Mesh ini.

4. Berikan izin IAM networkservices.meshes.use ke mesh ini dan ke akun layanan lintas project yang harus dapat melampirkan informasi layanannya ke mesh ini:

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

   Sekarang semua pemilik layanan yang telah diberi izin networkservices.meshes.use dapat menambahkan aturan perutean mereka ke mesh ini.

Konfigurasi rute di project layanan

Setiap pemilik layanan perlu membuat Backend Service regional dan resource Rute regional di project mereka, mirip dengan Menyiapkan proxy Envoy dengan layanan HTTP. Satu-satunya perbedaan adalah bahwa setiap HTTPRoute/GRPCRoute/TCPRoute akan memiliki URI resource mesh project host di kolom meshes.

1. Buat sharedvpc-http-route:

   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}
   

Mengonfigurasi layanan klien di project layanan

Saat mengonfigurasi klien Cloud Service Mesh (proxy Envoy atau tanpa proxy) yang berada di project layanan, Anda perlu menentukan nomor project tempat resource mesh berada dan nama mesh dalam konfigurasi bootstrap-nya:

TRAFFICDIRECTOR_GCP_PROJECT_NUMBER=HOST_PROJECT_NUMBER
TRAFFICDIRECTOR_MESH_NAME=MESH_NAME

Perutean TLS gateway

Bagian ini menunjukkan cara menyiapkan gateway ingress berbasis proxy Envoy dengan resource TLSRoute dan Gateway regional.

Load Balancer Jaringan passthrough eksternal regional mengarahkan traffic ke proxy Envoy yang bertindak sebagai gateway traffic masuk. Proxy Envoy menggunakan perutean TLS passthrough dan mengarahkan traffic ke server HTTPS yang berjalan di instance VM backend.

Tentukan beberapa variabel yang akan digunakan di seluruh contoh.

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

Ganti kode berikut: default

• PROJECT_ID dengan ID project Anda.
• PROJECT_NUMBER dengan nomor project Anda.

Secara opsional, Anda dapat mengganti hal berikut:

• us-central1 dengan region lain yang ingin Anda gunakan.
• us-central1-b dengan zona lain yang ingin Anda gunakan.
• default dengan nama jaringan lain yang ingin Anda gunakan.

Referensi silang resource mesh regional dan rute regional di lingkungan VPC Bersama multi-project

Ada skenario saat konfigurasi mesh layanan terdiri dari layanan yang dimiliki oleh project yang berbeda. Misalnya, dalam deployment VPC Bersama atau VPC yang di-peering, setiap pemilik project dapat menentukan serangkaian layanan mereka sendiri dengan tujuan agar layanan ini tersedia untuk semua project lainnya.

Konfigurasi ini bersifat "lintas project" karena beberapa resource yang ditentukan dalam project yang berbeda digabungkan untuk membentuk satu konfigurasi yang dapat ditayangkan ke klien proxy atau tanpa proxy.

Catatan: Referensi antar-resource regional harus ada di region yang sama.

Mengonfigurasi aturan firewall

1. Konfigurasi aturan firewall untuk mengizinkan traffic dari sumber mana pun. Edit perintah untuk port dan rentang alamat IP sumber Anda.

   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
   

Mengonfigurasi izin IAM

1. Buat identitas akun layanan untuk proxy gateway:

   gcloud iam service-accounts create gateway-proxy
   

2. Tetapkan peran IAM yang diperlukan ke identitas akun layanan:

   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"
   

Konfigurasi Gateway regional:

1. Di file bernama gateway8443.yaml, buat spesifikasi Gateway untuk traffic HTTP:

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

2. Buat resource Gateway regional menggunakan spesifikasi gateway8443.yaml:

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

Membuat grup instance terkelola dengan proxy Envoy

Di bagian ini, Anda akan membuat template instance untuk VM yang menjalankan proxy layanan Envoy yang di-deploy secara otomatis. Envoi memiliki cakupan yang ditetapkan ke gateway-proxy. Jangan teruskan port penayangan sebagai parameter flag --service-proxy.

1. Buat grup instance terkelola dengan 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. Buat grup instance terkelola regional dari template instance:

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

3. Tetapkan nama port penayangan untuk grup instance terkelola:

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

Menyiapkan load balancer jaringan passthrough eksternal regional

1. Buat alamat IP eksternal regional statis:

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

2. Dapatkan alamat IP yang dicadangkan untuk load balancer eksternal:

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

3. Buat health check untuk proxy gateway:

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

4. Buat layanan backend untuk proxy 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. Tambahkan grup instance terkelola sebagai backend:

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

6. Buat aturan penerusan untuk merutekan traffic ke 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}
   

Mengonfigurasi grup instance terkelola yang menjalankan layanan HTTPS

1. Buat template instance dengan layanan HTTPS yang diekspos di port 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. Buat grup instance terkelola berdasarkan template instance:

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

3. Tetapkan nama port penayangan untuk grup instance terkelola:

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

4. Membuat health check:

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

5. Buat aturan firewall untuk mengizinkan koneksi health check yang masuk ke instance di jaringan Anda:

   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. Buat layanan backend regional dengan skema load balancing INTERNAL_SELF_MANAGED dan tambahkan health check:

   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. Tambahkan grup instance terkelola sebagai backend ke layanan backend:

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

Menyiapkan perutean dengan resource TLSRoute

1. Dalam file bernama tls_route.yaml, buat spesifikasi 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
   

   Dalam petunjuk sebelumnya, TLSRoute mencocokkan example.com sebagai SNI dan h2 sebagai ALPN. Jika kecocokan diubah sebagai berikut, TLSRoute cocok dengan SNI atau ALPN:

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

2. Gunakan spesifikasi tls_route.yaml untuk membuat resource TLSRoute:

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

Memvalidasi deployment

1. Jalankan perintah curl berikut untuk memverifikasi konektivitas HTTP ke layanan pengujian yang Anda buat:

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

2. Perintah ini akan menampilkan respons dari salah satu VM dalam grup instance terkelola. Outputnya mirip dengan hal berikut ini:

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

Memverifikasi dengan verifikasi negatif

1. Pada perintah berikut, SNI tidak cocok dengan example.com, sehingga Gateway menolak koneksi:

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

2. Dalam perintah berikut, ALPN tidak cocok dengan h2 (protokol HTTP2), sehingga Gateway menolak koneksi:

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

   Semua perintah sebelumnya menampilkan error berikut:

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

3. Dalam perintah berikut, klien membuat koneksi teks biasa (tidak terenkripsi), sehingga Gateway menolak koneksi dengan error 404 Not Found:

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