Regionales Cloud Service Mesh

Vorschau – Regional Cloud Service Mesh

Diese Funktion unterliegt den Bedingungen für Pre‑GA-Angebote im Abschnitt „Allgemeine Dienstbedingungen“ der dienstspezifischen Nutzungsbedingungen. Pre-GA-Funktionen stehen in der vorliegenden Form zur Verfügung und bieten möglicherweise nur eingeschränkten Support. Weitere Informationen finden Sie in den Beschreibungen der Produkteinführungsphasen.

Durch die regionale Isolation können Clients, die eine Verbindung zu einer bestimmten Region der Cloud Service Mesh-Steuerungsebene herstellen, nur auf Ressourcen in dieser Region zugreifen. Ebenso können API-Ressourcen in einer bestimmten Region nur auf andere Ressourcen in dieser Region verweisen.

Für regionale Cloud Service Mesh gelten die folgenden Einschränkungen:

• Die Istio API wird nicht unterstützt. Sie können Kubernetes nicht mit der Istio API verwenden, wenn Sie regionalen Traffic Director nutzen. In dieser Vorabversion werden nur Google Cloud APIs unterstützt.
• Die bestehenden Überlegungen und Einschränkungen der globalen Service Routing APIs gelten.
• Die Mindestversion von Envoy zur Unterstützung von xdSTP-Namensschemata ist v1.31.1.
• Gateway for Mesh API wird nicht unterstützt.
• Die Mindestversion von gRPC ist v1.65.

• Nur die folgenden Regionen werden unterstützt:

  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
  

Preise

Für jede Region, in der regionales Cloud Service Mesh unterstützt wird, ist eine regionale SKU verfügbar, wenn diese Funktion allgemein verfügbar ist. Derzeit sind die Preise die gleichen wie global.

xDS-Client für Cloud Service Mesh vorbereiten

Compute-VM Envoy xDS

Manuell

Die manuellen Schritte bauen auf VMs mit manueller Envoy-Bereitstellung einrichten auf. Der Hauptunterschied besteht darin, dass ENVOY_CONTROL_PLANE_REGION festgelegt und in den Bootstrap eingefügt wird.

1. Erstellen Sie die Instanzvorlage:

   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

Ähnlich wie bei globalem Cloud Service Mesh müssen gRPC-Clients einen Bootstrap konfigurieren, um zu erfahren, wie sie eine Verbindung zu regionalem Cloud Service Mesh herstellen.

Sie können den gRPC-Bootstrap-Generator verwenden, um diesen Bootstrap zu generieren. Wenn Sie die regionale Cloud Service Mesh verwenden möchten, geben Sie ein neues Flag an: --xds-server-region.

Wenn Sie in diesem Beispiel xds-server-region auf us-central1 festlegen, wird der regionale Cloud Service Mesh-Endpunkt automatisch ermittelt: trafficdirector.us-central1.rep.googleapis.com:443.

Manuelle Envoy-Injection in K8s

Die manuellen Schritte bauen auf Google Kubernetes Engine-Pods mit manueller Envoy-Injektion einrichten auf. Sie müssen jedoch nur den Abschnitt zum manuellen Einfügen von Pods ändern.

1. Steuerungsebene von global zu regional ändern:

   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. Übernehmen Sie die Änderung:

      kubectl apply -f trafficdirector_client_new_api_sample_xdsv3.yaml
        ```
      

Leitfäden für die Einrichtung

In diesem Abschnitt werden fünf unabhängige Konfigurations- und Bereitstellungsmodelle behandelt. Dies sind alles regionalisierte Versionen der vorhandenen globalen Einrichtungsanleitungen für die Service Routing API.

• Proxylose gRPC-Dienste mit regionalen GRPCRoute- und regionalen Cloud Service Mesh-Ressourcen konfigurieren
• Konfiguration des Envoy-Sidecar-Proxys mit HTTP-Diensten mit regionaler HTTPRoute und regionalem Cloud Service Mesh konfigurieren
• TCP-Dienste mit regionaler TCPRoute konfigurieren
• Gateway-TLS-Routing
• Projektübergreifende Referenzen für regionales Cloud Service Mesh und regionale Route konfigurieren

Proxylose gRPC-Dienste mit regionalen GRPCRoute- und regionalen Cloud Service Mesh-Ressourcen konfigurieren

In diesem Abschnitt wird beschrieben, wie Sie ein proxyloses gRPC-Service Mesh mit regionalen Cloud Service Mesh- und regionalen GRPCRoute-Ressourcen konfigurieren.

Speichern Sie die Google Cloud Projektnummer, in der Sie die Konfiguration vornehmen, damit alle Beispiele in diesem Leitfaden in die Befehlszeile kopiert und eingefügt werden können:

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

Ersetzen Sie PROJECT_NUMBER durch die Projekt-ID.

Optional können Sie Folgendes ersetzen:

• us-central1 durch eine andere Region, die Sie verwenden möchten.
• us-central1-a durch eine andere Zone, die Sie verwenden möchten.
• default durch einen anderen VPC_NAME.

Mesh-Konfiguration

Wenn eine proxylose gRPC-Anwendung eine Verbindung zu einem xds://hostname herstellt, stellt die gRPC-Clientbibliothek eine Verbindung zu Cloud Service Mesh her, um die Routingkonfiguration abzurufen, die zum Weiterleiten von Anfragen für den Hostnamen erforderlich ist.

1. Erstellen Sie eine Mesh-Spezifikation und speichern Sie sie in der Datei „mesh.yaml“:

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

2. Erstellen Sie ein Mesh mit der Spezifikation mesh.yaml:

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

   Nachdem das regionale Mesh erstellt wurde, kann Cloud Service Mesh die Konfiguration bereitstellen. Da aber noch keine Dienste definiert sind, ist die Konfiguration leer.

gRPC-Dienstkonfiguration

Zu Demonstrationszwecken erstellen Sie einen regionalen Backend-Dienst mit automatisch skalierten VMs (mithilfe von verwalteten Instanzgruppen – MIG), der hello world über das gRPC-Protokoll an Port 50051 bereitstellt.

1. Erstellen Sie die Compute Engine-VM-Instanzvorlage mit dem gRPC-Dienst helloworld, der an Port 50051 verfügbar ist:

   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. Erstellen Sie eine MIG anhand der Vorlage:

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

3. Konfigurieren Sie einen benannten Port für den gRPC-Dienst. Dies ist der Port, den der gRPC-Dienst auf Anfragen überwacht.

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

   In diesem Beispiel lautet der Port 50051.

4. gRPC-Systemdiagnosen erstellen

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

   Die Dienste müssen das gRPC-Systemdiagnoseprotokoll implementieren, damit gRPC-Systemdiagnosen funktionieren. Weitere Informationen finden Sie unter Systemdiagnosen erstellen.

5. Erstellen Sie eine Firewallregel, um eingehende Systemdiagnoseverbindungen zu Instanzen in Ihrem Netzwerk zuzulassen.

   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. Erstellen Sie einen regionalen Backend-Dienst mit einem Load-Balancing-Schema von INTERNAL_SELF_MANAGED und fügen Sie dem Backend-Dienst die Systemdiagnose und eine zuvor erstellte verwaltete Instanzgruppe hinzu. Der Port im angegebenen Portnamen wird verwendet, um eine Verbindung zu den VMs in der verwalteten Instanzgruppe herzustellen.

   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. Fügen Sie die verwaltete Instanzgruppe dem BackendService hinzu:

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

Routing mit regionaler GRPCRoute einrichten

An diesem Punkt sind das regionale Mesh und der gRPC-Serverdienst konfiguriert. Jetzt können Sie das erforderliche Routing einrichten.

1. Erstellen Sie eine regionale GRPCRoute-Spezifikation und speichern Sie sie in der Datei „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. Erstellen Sie eine regionale GRPCRoute mit der Spezifikation grpc_route.yaml:

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

   Cloud Service Mesh ist jetzt so konfiguriert, dass der Traffic für die in der gRPC-Route angegebenen Dienste über Back-Ends in der verwalteten Instanzgruppe verteilt wird.

gRPC-Clientdienst erstellen

Um die Konfiguration zu prüfen, instanziieren Sie eine Clientanwendung mit einer proxylosen gRPC-Datenebene. In der Bootstrap-Datei muss die Anwendung den Namen des Mesh angeben.

Nach der Konfiguration kann diese Anwendung eine Anfrage an die mit helloworld-gce verknüpften Instanzen oder Endpunkte senden und dazu den Dienst-URI xds:///helloworld-gce verwenden.

In den folgenden Beispielen verwenden Sie das grpcurl-Tool, um den gRPC-Dienst zu testen.

1. Erstellen Sie eine Client-VM:

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

Umgebungsvariable und Bootstrap-Datei einrichten

Die Clientanwendung benötigt eine Bootstrap-Konfigurationsdatei. Das Startskript im vorherigen Abschnitt legt die Umgebungsvariable GRPC_XDS_BOOTSTRAP fest und verwendet ein Hilfsskript, um die Bootstrap-Datei zu erstellen. Die Werte für TRAFFICDIRECTOR_GCP_PROJECT_NUMBER und Zone in der erstellten Bootstrap-Datei werden vom Metadatenserver abgerufen, der diese Details zu Ihren Compute Engine-VM-Instanzen kennt.

Sie können diese Werte mithilfe der Option -gcp-project-number manuell im Hilfsskript angeben. Sie müssen mit der Option -config-mesh-experimental einen Mesh-Namen angeben, der mit der Mesh-Ressource übereinstimmt.

1. So prüfen Sie die Konfiguration:

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

2. Laden Sie das grpcurl-Tool herunter und installieren Sie es:

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

3. Führen Sie das grpcurl-Tool mit xds:///helloworld-gce als Dienst-URI und helloworld.Greeter/SayHello als Dienstnamen und aufzurufende Methode aus.

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

   Die Parameter für die Methode „SayHello“ werden mit der Option „-d“ übergeben.

   Die Ausgabe sollte in etwa so aussehen, wobei INSTANCE_NAME der Name der VM-Instanz ist:

   Greeting: Hello world, from INSTANCE_HOSTNAME
   

Dadurch wird bestätigt, dass der proxylose gRPC-Client mit Cloud Service Mesh erfolgreich verbunden wurde und Informationen zu den Back-Ends für den Dienst „helloworld-gce“ über den xDS-Name-Resolver erhalten hat. Der Client hat eine Anfrage an eines der Back-Ends des Dienstes gesendet, ohne dass Sie die IP-Adresse kennen oder die DNS-Auflösung ausführen müssen.

Konfiguration des Envoy-Sidecar-Proxys mit HTTP-Diensten mit regionaler HTTPRoute und regionalem Mesh konfigurieren

In diesem Abschnitt wird beschrieben, wie Sie ein Envoy-Proxy-basiertes Service Mesh mit regionalen Mesh- und HTTPRoute-Ressourcen konfigurieren.

Speichern Sie die Google Cloud Projektnummer, in der Sie die Konfiguration vornehmen, damit alle Beispiele in diesem Leitfaden in die Befehlszeile kopiert und eingefügt werden können:

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

Ersetzen Sie Folgendes:

• PROJECT_ID durch Ihre Projekt-ID,
• PROJECT_NUMBER durch Ihre Projektnummer,

Optional können Sie Folgendes ersetzen:

• us-central1 durch eine andere Region, die Sie verwenden möchten.
• us-central1-a durch eine andere Zone, die Sie verwenden möchten.

Mesh-Konfiguration

Der Sidecar-Envoy-Proxy empfängt die Dienstroutingkonfiguration von Cloud Service Mesh. Der Sidecar-Container präsentiert den Namen der regionalen Mesh-Ressource, um das konfigurierte Service Mesh zu identifizieren. Die von Cloud Service Mesh empfangene Routingkonfiguration wird verwendet, um den Traffic, der über den Sidecar-Proxy läuft, je nach den in den Routenressourcen konfigurierten Anfrageparametern wie Hostname oder Headern an verschiedene regionale Backend-Dienste weiterzuleiten.

Der Mesh-Name ist der Schlüssel, den der Sidecar-Proxy zum Anfordern der mit diesem Mesh verknüpften Konfiguration verwendet.

1. Erstellen Sie eine regionale Mesh-Spezifikation und speichern Sie sie in der Datei „mesh.yaml“:

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

   Wenn kein Port angegeben ist, wird standardmäßig der Port 15001 verwendet.

2. Erstellen Sie ein regionales Mesh mit der Spezifikation mesh.yaml:

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

   Nachdem das regionale Mesh erstellt wurde, kann Cloud Service Mesh die Konfiguration bereitstellen. Da aber noch keine Dienste definiert sind, ist die Konfiguration leer.

HTTP-Serverkonfiguration

Zu Demonstrationszwecken erstellen Sie einen regionalen Backend-Dienst mit automatisch skalierten VMs (mit verwalteten Instanzgruppen – MIG), der „Hallo Welt“ über das gRPC-Protokoll an Port 80 bereitstellt.

1. Erstellen Sie die Compute Engine-VM-Instanzvorlage mit dem HTTP-Dienst helloworld, der an Port 80 verfügbar ist:

   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. Erstellen Sie eine MIG anhand der Vorlage:

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

3. Systemdiagnosen erstellen:

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

4. Erstellen Sie eine Firewallregel, um eingehende Systemdiagnoseverbindungen zu Instanzen in Ihrem Netzwerk zuzulassen.

   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. Erstellen Sie einen regionalen Backend-Dienst mit dem Load-Balancing-Schema 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. Fügen Sie dem Back-End-Dienst die Systemdiagnose und eine verwaltete oder nicht verwaltete Instanzgruppe hinzu:

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

   In diesem Beispiel wird die verwaltete Instanzgruppe mit der Compute Engine-VM-Vorlage verwendet, die den zuvor erstellten Beispiel-HTTP-Dienst ausführt.

Routing mit regionaler HTTPRoute einrichten

Die Mesh-Ressource und der HTTP-Server sind konfiguriert. Sie können sie jetzt über eine HTTPRoute-Ressource verbinden, die einen Hostnamen mit einem Backend-Dienst verknüpft.

1. Erstellen Sie die HTTPRoute-Spezifikation und speichern Sie sie als „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. Erstellen Sie die HTTPRoute mit der Spezifikation http_route.yaml:

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

   Cloud Service Mesh ist jetzt so konfiguriert, dass der Traffic für die in der HTTPRoute angegebenen Dienste über Back-Ends in der verwalteten Instanzgruppe verteilt wird.

HTTP-Client mit Envoy-Sidecar erstellen

In diesem Abschnitt instanziieren Sie eine Client-VM mit einem Envoy-Sidecar-Proxy, um die zuvor erstellte Cloud Service Mesh-Konfiguration anzufordern. Der Parameter mesh im Google Cloud CLI-Befehl verweist auf die zuvor erstellte Mesh-Ressource.

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. Melden Sie sich bei der erstellten VM an:

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

2. Prüfen Sie die HTTP-Konnektivität zu den erstellten Testdiensten:

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

   Der Befehl gibt eine Antwort von einer der VMs in der verwalteten Instanzgruppe zurück, wobei der Hostname an die Console ausgegeben wird.

TCP-Dienste mit regionaler TCPRoute konfigurieren

Dieser Konfigurationsablauf ähnelt sehr dem Einrichten von Envoy-Proxys mit HTTP-Diensten. Die Ausnahme ist, dass der Backend-Dienst einen TCP-Dienst bereitstellt und das Routing auf TCP/IP-Parametern statt auf dem HTTP-Protokoll basiert.

Speichern Sie die Google Cloud Projektnummer, in der Sie die Konfiguration vornehmen, damit alle Beispiele in diesem Leitfaden in die Befehlszeile kopiert und eingefügt werden können:

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

Ersetzen Sie Folgendes:

• PROJECT_ID durch Ihre Projekt-ID,
• PROJECT_NUMBER durch Ihre Projektnummer,

Optional können Sie Folgendes ersetzen:

• us-central1 durch eine andere Region, die Sie verwenden möchten.
• us-central1-a durch eine andere Zone, die Sie verwenden möchten.

Mesh-Konfiguration

1. Erstellen Sie eine regionale Mesh-Spezifikation und speichern Sie sie in der Datei „mesh.yaml“:

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

2. Erstellen Sie ein regionales Mesh mit der Spezifikation mesh.yaml:

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

TCP-Serverkonfiguration

Zu Demonstrationszwecken erstellen Sie einen regionalen Backend-Dienst mit automatisch skalierten VMs (mit verwalteten Instanzgruppen – MIG), der „Hallo Welt“ über das gRPC-Protokoll an Port 10000 bereitstellt.

1. Erstellen Sie die Compute Engine-VM-Instanzvorlage mit einem Testdienst an Port 10000 mit dem Netcat-Dienstprogramm:

   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. Erstellen Sie eine MIG anhand der Vorlage:

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

3. Legen Sie für die benannten Ports in der erstellten verwalteten Instanzgruppe port 10000 fest:

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

4. Erstellen Sie eine regionale Systemdiagnose.

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

5. Erstellen Sie eine Firewallregel, um eingehende Systemdiagnoseverbindungen zu Instanzen in Ihrem Netzwerk zuzulassen.

   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. Erstellen Sie einen regionalen Back-End-Dienst mit dem Load-Balancing-Schema INTERNAL_SELF_MANAGED und fügen Sie dem Back-End-Dienst die Systemdiagnose und eine verwaltete oder nicht verwaltete Instanzgruppe hinzu.

   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. Fügen Sie dem BackendService die MIG hinzu:

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

Routing mit regionaler TCPRoute einrichten

1. Erstellen Sie die TCPRoute-Spezifikation und speichern Sie sie in der Datei „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. Erstellen Sie TCPRoute mit der Spezifikation tcp_route.yaml:

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

TCP-Client mit Envoy-Sidecar erstellen

1. So erstellen Sie eine VM mit Envoy, die mit Cloud Service Mesh verbunden ist:

   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. Melden Sie sich bei der erstellten VM an:

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

3. Prüfen Sie die Verbindung zu den erstellten Testdiensten:

   curl 10.0.0.1:10000 --http0.9 -v
   

   Sie sollten den Text Hello from TCP service zurückerhalten und auch den Text sehen, den Sie eingegeben haben und der vom Netcat-Dienst zurückgegeben wird, der auf der Remote-VM ausgeführt wird.

Regionales Mesh im Hostprojekt konfigurieren

Legen Sie ein Projekt als Hostprojekt fest. Jedes Dienstkonto mit der Berechtigung zum Erstellen, Aktualisieren oder Löschen von Meshs in diesem Projekt kann die Routingkonfigurationen steuern, die mit regionalen Meshs in diesem Projekt verknüpft sind.

1. Definieren Sie eine Variable, die im gesamten Beispiel verwendet wird:

   export REGION="us-central1"
   

   Optional können Sie us-central1 durch eine andere Region ersetzen, die Sie verwenden möchten.

2. Erstellen Sie die Mesh-Spezifikation und speichern Sie sie in der Datei „mesh.yaml“:

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

3. Definieren Sie in diesem Projekt eine Mesh-Ressource mit der erforderlichen Konfiguration:

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

   Notieren Sie sich den vollständigen URI dieser Mesh-Ressource. Dienstinhaber benötigen sie in Zukunft, um ihre Routen an dieses Mesh anzuhängen.

4. Erteilen Sie diesem Mesh und den projektübergreifenden Dienstkonten, die in der Lage sein sollen, ihre Dienstinformationen an dieses Mesh anzuhängen, die IAM-Berechtigung networkservices.meshes.use:

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

   Alle Dienstinhaber, denen die Berechtigung networkservices.meshes.use zugewiesen wurde, können diesem Mesh ihre Routingregeln hinzufügen.

Routenkonfiguration in Dienstprojekten

Jeder Dienstinhaber muss in seinem Projekt regionale Backend-Dienste und regionale Routenressourcen erstellen, ähnlich wie unter Envoy-Proxys mit HTTP-Diensten einrichten beschrieben. Der einzige Unterschied besteht darin, dass jede HTTPRoute/GRPCRoute/TCPRoute den URI der Mesh-Ressource des Hostprojekts im Feld meshes hätte.

1. Erstellen Sie eine 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}
   

Clientdienste in Dienstprojekten konfigurieren

Beim Konfigurieren eines Cloud Service Mesh-Clients (Envoy-Proxy oder proxyless), der sich in einem Dienstprojekt befindet, muss in der Bootstrap-Konfiguration die Projektnummer, in der sich die Mesh-Ressource befindet, und der Mesh-Name angegeben werden:

TRAFFICDIRECTOR_GCP_PROJECT_NUMBER=HOST_PROJECT_NUMBER
TRAFFICDIRECTOR_MESH_NAME=MESH_NAME

Gateway-TLS-Routing

In diesem Abschnitt wird gezeigt, wie Sie ein Envoy-Proxy-basiertes Ingress-Gateway mit regionalen Gateway- und regionalen TLSRoute-Ressourcen einrichten.

Ein regionaler externer Passthrough-Network Load Balancer leitet den Traffic an Envoy-Proxys weiter, die als Ingress-Gateway fungieren. Die Envoy-Proxys verwenden TLS-Passthrough-Routing und leiten Traffic an HTTPS-Server weiter, die auf den Backend-VM-Instanzen ausgeführt werden.

Definieren Sie einige Variablen, die im gesamten Beispiel verwendet werden.

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

Ersetzen Sie Folgendes: default

• PROJECT_ID durch Ihre Projekt-ID,
• PROJECT_NUMBER durch Ihre Projektnummer,

Optional können Sie Folgendes ersetzen:

• us-central1 durch eine andere Region, die Sie verwenden möchten.
• us-central1-b durch eine andere Zone, die Sie verwenden möchten.
• Ersetzen Sie default durch einen anderen Netzwerknamen, den Sie verwenden möchten.

Querverweise auf regionale Mesh- und regionale Routenressourcen in einer Umgebung mit freigegebene VPC mit mehreren Projekten

Es gibt Szenarien, in denen die Service Mesh-Konfiguration aus Diensten besteht, die zu verschiedenen Projekten gehören. Bei Bereitstellungen mit freigegebene VPC oder Peering-VPC kann beispielsweise jeder Projektinhaber eigene Dienste definieren, um diese Dienste für alle anderen Projekte verfügbar zu machen.

Diese Konfiguration ist „projektübergreifend“, da mehrere in verschiedenen Projekten definierte Ressourcen zu einer einzelnen Konfiguration kombiniert werden, die auf einem Proxy-Client oder proxylosen Client bereitgestellt werden kann.

Hinweis :Referenzen zwischen regionalen Ressourcen müssen in derselben Region vorhanden sein.

Firewallregeln konfigurieren

1. Konfigurieren Sie Firewallregeln, um Traffic von jeder Quelle zuzulassen. Bearbeiten Sie die Befehle für Ihre Ports und Quell-IP-Adressbereiche.

   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
   

IAM-Berechtigungen konfigurieren

1. Erstellen Sie eine Dienstkontoidentität für die Gateway-Proxys:

   gcloud iam service-accounts create gateway-proxy
   

2. Weisen Sie der Dienstkontoidentität die erforderlichen IAM-Rollen zu:

   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"
   

Regionales Gateway konfigurieren:

1. Erstellen Sie in einer Datei mit dem Namen „gateway8443.yaml“ die Gateway-Spezifikation für HTTP-Traffic:

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

2. Erstellen Sie die regionale Gateway-Ressource mit der Spezifikation „gateway8443.yaml“:

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

Verwaltete Instanzgruppe mit Envoy-Proxys erstellen

In diesem Abschnitt erstellen Sie eine Instanzvorlage für eine VM, auf der ein automatisch bereitgestellter Envoy-Dienstproxy ausgeführt wird. Bei den Envoys ist der Bereich auf gateway-proxy festgelegt. Übergeben Sie den Bereitstellungsport nicht als Parameter des Flags --service-proxy.

1. So erstellen Sie eine verwaltete Instanzgruppe mit Envoy-Proxys:

   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. Erstellen Sie eine regional verwaltete Instanzgruppe anhand der Instanzvorlage.

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

3. Legen Sie den Namen des Bereitstellungsports für die verwaltete Instanzgruppe fest:

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

Regionalen externen Passthrough-Network Load Balancer einrichten

1. Erstellen Sie eine statische, externe, regionale IP-Adresse:

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

2. Rufen Sie die IP-Adresse ab, die für den externen Load-Balancer reserviert ist:

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

3. Erstellen Sie eine Systemdiagnose für die Gateway-Proxys.

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

4. Erstellen Sie einen Backend-Dienst für die Gateway-Proxys:

   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. Fügen Sie die verwaltete Instanzgruppe als Backend hinzu.

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

6. Erstellen Sie eine Weiterleitungsregel, um Traffic an die Gateway-Proxys weiterzuleiten:

   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}
   

Verwaltete Instanzgruppe konfigurieren, die einen HTTPS-Dienst ausführt

1. Erstellen Sie eine Instanzvorlage mit einem HTTPS-Dienst, der über Port 8443 verfügbar gemacht wird:

   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. Erstellen Sie anhand der Instanzvorlage eine verwaltete Instanzgruppe:

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

3. Legen Sie den Namen des Bereitstellungsports für die verwaltete Instanzgruppe fest:

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

4. Erstellen Sie eine Systemdiagnose.

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

5. Erstellen Sie eine Firewallregel, um eingehende Systemdiagnoseverbindungen zu Instanzen in Ihrem Netzwerk zuzulassen.

   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. Erstellen Sie einen regionalen Back-End-Dienst mit dem Load-Balancing-Schema INTERNAL_SELF_MANAGED und fügen Sie die Systemdiagnose hinzu:

   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. Fügen Sie dem Backend-Dienst die verwaltete Instanzgruppe als Backend hinzu:

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

Routing mit einer TLSRoute-Ressource einrichten

1. Erstellen Sie in einer Datei mit dem Namen tls_route.yaml die TLSRoute-Spezifikation:

   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
   

   In der vorherigen Anweisung stimmt TLSRoute mit „example.com“ als SNI und „h2“ als ALPN überein. Wenn die Übereinstimmungen so geändert werden, stimmt TLSRoute mit SNI oder ALPN überein:

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

2. Verwenden Sie die Spezifikation „tls_route.yaml“, um die TLSRoute-Ressource zu erstellen:

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

Deployment validieren

1. Führen Sie den folgenden curl-Befehl aus, um die HTTP-Konnektivität zu den von Ihnen erstellten Testdiensten zu überprüfen:

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

2. Der Befehl gibt eine Antwort von einer der VMs in der verwalteten Instanzgruppe zurück. Die Ausgabe sieht etwa so aus:

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

Mit negativer Verifizierung prüfen

1. Im folgenden Befehl stimmt die SNI nicht mit „example.com“ überein, sodass das Gateway die Verbindung ablehnt.

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

2. Im folgenden Befehl stimmt die ALPN nicht mit h2 (HTTP2-Protokoll) überein, sodass das Gateway die Verbindung ablehnt.

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

   Die vorherigen Befehle geben alle den folgenden Fehler zurück:

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

3. Im folgenden Befehl erstellt der Client eine Nur-Text-Verbindung (unverschlüsselt), also lehnt das Gateway die Verbindung mit dem Fehler „404 Not Found“ ab:

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