Sie sehen die Dokumentation zum Service Mesh für Version 1.21.

Verfügbare Versionen

Cloud Service Mesh
1.22-Archiv
1.21-Archiv
1.20-Archiv
1.19-Archiv
1.18-Archiv

Diese Seite wurde von der Cloud Translation API übersetzt.

Gateway-TLS-Routing einrichten

In dieser Anleitung wird gezeigt, wie Sie ein Envoy-Proxy-basiertes Ingress-Gateway mit den Ressourcen Gateway und TLSRoute einrichten. Sie können auch eine TLSRoute-Ressource anhängen.

Die von Ihnen konfigurierte Bereitstellung wird im folgenden Diagramm dargestellt. A Der regionale externe Passthrough-Network Load Balancer leitet Traffic an Envoy-Proxys weiter, die als ein Ingress-Gateway. Die Envoy-Proxys verwenden TLS-Passthrough-Routing und leiten Traffic an HTTPS-Server weiter, die auf den Backend-VM-Instanzen ausgeführt werden.

TLS-Weiterleitung mit einem Ingress-Gateway (zum Vergrößern klicken)

Hinweise

Führen Sie die in diesem Artikel Einrichtung mit Envoy und proxylosen Arbeitslasten vorbereiten

Firewallregeln konfigurieren

In diesem Abschnitt erstellen Sie Firewallregeln, um eingehende Systemdiagnoseverbindungen zu VM-Instanzen in Ihrem Netzwerk zuzulassen.

Firewallregel erstellen

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

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-ingress-traffic \
  --network=NETWORK_NAME \
  --direction=INGRESS \
  --action=ALLOW \
  --rules=tcp:443 \
  --source-ranges="0.0.0.0/0" \
  --target-tags=gateway-proxy

IAM-Berechtigungen (Identity and Access Management) konfigurieren

In diesem Abschnitt legen Sie das Dienstkonto für die Gateway-Proxys fest und weisen dem Dienstkonto die richtigen IAM-Rollen zu.

Erstellen Sie eine Dienstkontoidentität für die Gateway-Proxys:
```
gcloud iam service-accounts create gateway-proxy
```

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"

`Gateway`-Ressource konfigurieren

Erstellen Sie in einer Datei mit dem Namen gateway443.yaml die Gateway-Spezifikation für HTTP-Traffic:
```
name: gateway443
scope: gateway-proxy
ports:
- 443
type: OPEN_MESH
```

Erstellen Sie die Gateway-Ressource mit der Spezifikation gateway443.yaml:

gcloud network-services gateways import gateway443 \
    --source=gateway443.yaml \
    --location=global

Verwaltete Instanzgruppe mit Envoy-Proxys erstellen

In diesem Abschnitt erstellen Sie die Envoy-Proxys, die dem Ingress-Gateway zugeordnet sind.

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.

gcloud beta compute instance-templates create gateway-proxy \
  --machine-type=n1-standard-1 \
  --boot-disk-size=10GB \
  --scopes=https://www.googleapis.com/auth/cloud-platform \
  --tags=gateway-proxy \
  --network-interface=network=NETWORK_NAME,no-address \
  --service-account="gateway-proxy@PROJECT_ID.iam.gserviceaccount.com" \
  --service-proxy=enabled,scope=gateway-proxy

Erstellen Sie eine regional verwaltete Instanzgruppe anhand der Instanzvorlage.

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

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:443 \
  --region=REGION

Regionalen externen Passthrough-Network Load Balancer einrichten

In diesem Abschnitt erstellen Sie den externen Passthrough-Network Load Balancer.

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

gcloud compute addresses create xnlb-REGION \
  --region=REGION

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)'
```
Diese IP-Adresse wird später in dieser Einrichtungsanleitung als die Variable IP_ADDRESS verwendet.

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

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

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

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

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=443 \
  --backend-service=xnlb-REGION \
  --backend-service-region=REGION

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

Zu Demonstrationszwecken erstellen Sie einen Backend-Dienst mit automatisch skalierten VMs in einer verwalteten Instanzgruppe. Die VMs geben Details zu Webanfragen mithilfe des HTTPS-Protokoll an Port 443 zurück.

Erstellen Sie eine Instanzvorlage mit einem HTTPS-Dienst, der über Port 443 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-10 \
  --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 443:9999 --rm -dt mendhak/http-https-echo:22'

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

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:443 \
  --zone=ZONE

Erstellen Sie eine Systemdiagnose.

gcloud compute health-checks create https https-helloworld-health-check \
  --port=443

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:443

Erstellen Sie einen globalen Backend-Dienst mit dem Load-Balancing-Schema INTERNAL_SELF_MANAGED und fügen Sie die Systemdiagnose hinzu:

gcloud compute backend-services create https-helloworld-service \
  --global \
  --load-balancing-scheme=INTERNAL_SELF_MANAGED \
  --port-name=https \
  --health-checks https-helloworld-health-check

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 \
  --global

Routing mit einer `TLSRoute`-Ressource einrichten

In den vorherigen Abschnitten haben Sie eine Gateway-Ressource und einen HTTPS-Server konfiguriert. Als Nächstes verbinden Sie sie mithilfe einer TLSRoute-Ressource, die einen SNI-Hostnamen mit einem Backend-Dienst verknüpft.

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

name: helloworld-tls-route
gateways:
- projects/PROJECT_NUMBER/locations/global/gateways/gateway443
rules:
- matches:
  - sniHost:
    - example.com
    alpn:
    - h2
  action:
   destinations:
   - serviceName: projects/PROJECT_NUMBER/locations/global/backendServices/https-helloworld-service

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

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=global

Cloud Service Mesh ist so konfiguriert, dass Traffic für die Dienste per Load-Balancing verteilt wird angegeben in der Ressource TLSRoute für alle Back-Ends in der verwalteten Instanz Gruppe.

Deployment validieren

In diesem Abschnitt überprüfen Sie, ob Sie von einem externen Client über den externen Passthrough-Network-Load-Balancer und die Gateway-Ressource von Cloud Service Mesh auf den Dienst zugreifen können.

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 --resolve example.com:443:IP_ADDRESS -k
```

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

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

Mit negativer Verifizierung prüfen

Sie können auch eine negative Verifizierung ausführen. Wenn Sie die Befehle in diesem Abschnitt ausführen, wird die Anfrage verworfen, da sie nicht den Übereinstimmungskriterien von TLSRoute entspricht.

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

curl https://invalid-server.com --resolve invalid-server.com:443:IP_ADDRESS -k

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

curl https://example.com --resolve example.com:443:IP_ADDRESS -k --http1.1

Im folgenden Befehl erstellt der Client eine Nur-Text-Verbindung (unverschlüsselt), also lehnt Gateway die Verbindung ab:

curl example.com:443 --resolve example.com:443:IP_ADDRESS -k

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

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

Nächste Schritte

Informationen zum Auflisten von Routenressourcen, die mit einer Mesh- oder Gateway-Ressource verknüpft sind, finden Sie unter Route-Ressourcen auflisten. Diese Feature befindet sich im Vorschaumodus.