Sie sehen sich die Service Mesh-Dokumentation für Version 1.21 an.

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.

Cloud Service Mesh für Cloud Run konfigurieren

Auf dieser Seite wird beschrieben, wie Sie Cloud Service Mesh für die Ausführung auf einer Reihe von Recheninfrastrukturen für Cloud Run-Dienste konfigurieren.

Mit Cloud Service Mesh können Sie erweiterte Funktionen zur Trafficverwaltung wie die gewichtete Trafficaufteilung und das globale Load Balancing sowie Observability- und Sicherheitsrichtlinien für Traffic von einem Cloud Run-Dienst zu einem anderen aktivieren. Außerdem erhalten Sie eine vollständig verwaltete Lösung für die Datenebene, die den operativen Aufwand für die Wartung eigener Service Mesh-Sidecars eliminiert.

Hinweise

Sie sollten mit Cloud Service Mesh vertraut sein.

Projekt festlegen

gcloud config set core/project PROJECT_ID

Aktivieren Sie in der Google Cloud Console die folgenden APIs für Ihr Projekt:
- Cloud DNS API
- Network Services API
- Network Security API
- Traffic Director API
- Serverless VPC Access API, wenn Sie für den Netzwerkausgang einen Connector für Serverloser VPC-Zugriff und nicht Direct VPC verwenden.
Aktualisieren Sie die gcloud-Komponenten auf die neueste Version (488.0.0 oder höher):
```
gcloud components update
```

Erforderliche Rollen

Bitten Sie Ihren Administrator, Ihnen die folgenden IAM-Rollen zuzuweisen, um die Berechtigungen zu erhalten, die Sie zum Konfigurieren und Bereitstellen von Cloud Run-Diensten benötigen:

Rolle Cloud Run Entwickler (roles/run.developer) im Cloud Run-Dienst
Dienstkontonutzer (roles/iam.serviceAccountUser) für die Dienstidentität

Das Dienstkonto des Cloud Run-Clients muss außerdem die folgenden Rollen haben:

Traffic Director-Client (roles/trafficdirector.client) für den Zugriff auf die Service Routing APIs
Cloud Trace-Agent (roles/cloudtrace.agent), um das Tracing zu aktivieren

Eine Liste der IAM-Rollen und -Berechtigungen im Zusammenhang mit Cloud Run finden Sie unter IAM-Rollen für Cloud Run und IAM-Berechtigungen für Cloud Run. Wenn Ihr Cloud Run Service mit Google Cloud APIs wie Cloud-Clientbibliotheken verknüpft ist, lesen Sie die Konfigurationsanleitung für Dienstidentitäten. Weitere Informationen zum Zuweisen von Rollen finden Sie unter Bereitstellungsberechtigungen und Zugriff verwalten.

Aufrufe zwischen Cloud Run-Diensten mit Cloud Service Mesh

Cloud Run verwendet die Dienst-Routing-APIs von Cloud Service Mesh. Mit diesen APIs kann ein Cloud Run-Dienst andere Cloud Run-Dienste über eine benutzerdefinierte URL statt über die bereitgestellte run.app-URL aufrufen. Außerdem authentifiziert sich Cloud Run automatisch beim Ziel-Cloud Run-Dienst, sodass Sie keine eigene Authentifizierung konfigurieren müssen, um Anmeldedaten für Anfragen an andere Cloud Run-Dienste anzuhängen.

So rufen Sie mit Cloud Service Mesh einen Cloud Run-Dienst von einem anderen auf:

Cloud Service Mesh einrichten
Cloud DNS einrichten
Ziel-Cloud Run-Dienst erstellen
Serverlose NEG erstellen
Cloud Run-Dienst für den Client erstellen
Dienst über den Mesh-Client aufrufen

Cloud Service Mesh einrichten

Wenn Sie eine Dienstroute mit der Standard-URL erstellen möchten, speichern Sie die Mesh-Spezifikation in einer Datei mit dem Namen mesh.yaml:
```
name: MESH_NAME
```
Ersetzen Sie MESH_NAME durch den Namen der Mesh-Ressource.
Importieren Sie die Mesh-Ressource aus der Spezifikation mit dem folgenden Befehl:
```
gcloud network-services meshes import MESH_NAME \
  --source=mesh.yaml \
  --location=global
```
Ersetzen Sie MESH_NAME durch den Namen der Mesh-Ressource.

Cloud DNS einrichten

Wenn Sie einen Private Service Connect-Endpunkt mit der vollständigen run.app-URL-Adresse als Hostnamen verwenden, können Sie die Cloud DNS-Einrichtung überspringen und mit dem nächsten Abschnitt fortfahren, da nur private IP-Adressen erfasst werden.

Wenn ein Mesh-Client den Zieldienst aufruft, muss der in der Anfrage verwendete Hostname über DNS aufgelöst werden können. Jede gültige RFC 1918-IP-Adresse ist zulässig, da der Sidecar den gesamten IP-Traffic an diese IP-Adressbereiche erfasst und entsprechend weiterleitet.

Im folgenden Beispiel wird gezeigt, wie Sie einen Wildcard-Eintrag * in der Cloud DNS-Zone erstellen, der auf eine einzelne IP-Adresse verweist. Wenn Sie keine Cloud DNS-Zone verwenden möchten, erstellen Sie für jeden Hostnamen einen Cloud DNS-Eintrag, der den Cloud Run-Diensten entspricht, die über das Mesh ansprechbar sein sollen.

Führen Sie die folgenden Befehle aus, um einen Cloud DNS-Eintrag in einer exklusiven Zone zu erstellen:
1. Erstellen Sie eine verwaltete private DNS-Zone in Cloud DNS für ein Dienstnetzwerk.
```
gcloud dns managed-zones create MESH_NAME \
--description="Domain for DOMAIN_NAME service mesh routes" \
--dns-name=DOMAIN_NAME. \
--network=VPC_NETWORK_NAME \
--visibility=private
```
2. Erstellen Sie einen DNS-Eintrag in der neu erstellten verwalteten privaten Zone. Die IP-Adresse 10.0.0.1 darf nicht verwendet werden.
```
gcloud dns record-sets create "*.DOMAIN_NAME." \
--type=A \
--zone="MESH_NAME" \
--rrdatas=10.0.0.1 \
--ttl=3600
```
  Ersetzen Sie Folgendes:
  - DOMAIN_NAME: der Name der DNS-Domain.
  - MESH_NAME: der Name der Mesh-Ressource.
  - VPC_NETWORK_NAME: der Name Ihres VPC-Netzwerks, z. B. „standard“

Mit Cloud Service Mesh auf interne Dienste zugreifen

Mit Cloud Run können Sie den eingehenden Netzwerkverkehr auf „intern“ beschränken. Wenn diese Einschränkung für Ihren Dienst aktiviert ist, kann Traffic, der von Ihrem Mesh durch das Virtual Private Cloud-Netzwerk fließt, als „intern“ festgelegt werden, wenn Sie einen Zugriffspfad auf Cloud Run aktivieren.

Verwenden Sie eine der folgenden Methoden, um mit Cloud Service Mesh auf interne Dienste zuzugreifen:

Konfigurieren Sie den privaten Google-Zugriff für Ihr VPC-Netzwerk. Sie müssen keinen benutzerdefinierten DNS-Eintrag einrichten.
Private Service Connect-Endpunkt an Cloud Service Mesh anhängen Dazu muss für die Standard-*.run.app-URL ein benutzerdefinierter DNS-Eintrag eingerichtet werden, um die Private Service Connect-Endpunktadresse zu verwenden.

Ziel-Cloud Run-Dienst erstellen

Die Standard-URL des Cloud Run-Ziels darf nicht deaktiviert sein.

Neuen oder vorhandenen Cloud Run-Dienst bereitstellen:
```
gcloud run deploy DESTINATION_SERVICE_NAME \
--no-allow-unauthenticated \
--region=REGION \
--image=IMAGE_URL 
```
Ersetzen Sie Folgendes:
- DESTINATION_SERVICE_NAME: Der Name des Cloud Run-Zieldienstes.
- REGION: der Name der Region.
- IMAGE_URL: ein Verweis auf das Container-Image, z. B. us-docker.pkg.dev/cloudrun/container/hello:latest.

Serverlose Netzwerk-Endpunktgruppe erstellen

Erstellen Sie die Ziel-NEG mit dem folgenden Befehl:

gcloud compute network-endpoint-groups create destination-neg \
--region=REGION \
--network-endpoint-type=serverless \
--cloud-run-service=DESTINATION_SERVICE_NAME

Ersetzen Sie Folgendes:

REGION: der Name der Region.
DESTINATION_SERVICE_NAME: Der Name des Cloud Run-Zieldienstes.

Erstellen Sie einen internen selbstverwalteten Back-End-Dienst, der auf die serverlose NEG verweist.
1. Erstellen Sie den Back-End-Dienst:
```
gcloud compute backend-services create DESTINATION_SERVICE_NAME-REGION \
--global \
--load-balancing-scheme=INTERNAL_SELF_MANAGED
```
  Ersetzen Sie DESTINATION_SERVICE_NAME durch den Namen des Zieldienstes und REGION durch den Namen der Region.
2. Fügen Sie dem Backend-Dienst das serverlose Backend hinzu:
```
gcloud compute backend-services add-backend DESTINATION_SERVICE_NAME-REGION \
--global \
--network-endpoint-group=destination-neg \
--network-endpoint-group-region=REGION
```
  Ersetzen Sie DESTINATION_SERVICE_NAME durch den Namen des Zieldienstes und REGION durch den Namen der Region.
Erstellen Sie eine HTTP-Route, die auf den Back-End-Dienst verweist.

Die Ressource Mesh und die Dienste sind konfiguriert. Verbinden Sie sie mit einer HTTPRoute-Ressource, die einen Hostnamen mit einem Backend-Dienst verknüpft.
1. Erstellen Sie die Spezifikation HTTPRoute und speichern Sie sie in einer Datei mit dem Namen http_route.yaml:
```
name: "DESTINATION_SERVICE_NAME-route"
hostnames:
- "DESTINATION_SERVICE_NAME.DOMAIN_NAME"
meshes:
- "projects/PROJECT_ID/locations/global/meshes/MESH_NAME"
rules:
- action:
   destinations:
   - serviceName: "projects/PROJECT_ID/locations/global/backendServices/DESTINATION_SERVICE_NAME-REGION"
```
  Legen Sie die Hostnamen auf die Namen fest, die Sie für die Adressierung des Dienstes verwenden möchten. Alle Clients im selben Service Mesh können diesen Dienst über die http://<HOSTNAME>-URL aufrufen, unabhängig von der Region und dem Projekt des Aufrufers. Wenn Sie Cloud DNS so eingerichtet haben, dass eine private IP-Adresse verwendet wird, kann der Routen-Hostname auch die vollständige run.app-URL-Adresse sein. In diesem Fall können Sie den Cloud DNS-Einrichtungsschritt überspringen.
  
  Ersetzen Sie Folgendes:
  - DESTINATION_SERVICE_NAME: Der Name des Cloud Run-Zieldienstes.
  - DOMAIN_NAME: der Name der DNS-Domain.
  - PROJECT_ID: die ID des Projekts.
  - MESH_NAME: der Name des Mesh.
  - REGION: der Name der Region.
2. Erstellen Sie die HTTPRoute-Ressource mithilfe der Spezifikation in der Datei http_route.yaml:
```
gcloud network-services http-routes import DESTINATION_SERVICE_NAME-route \
--source=http_route.yaml \
--location=global
```
3. Weisen Sie dem Cloud Run-Zieldienst die Rolle Cloud Run Invoker (roles/iam.invoker) zu. Führen Sie dazu den folgenden Befehl aus:
```
gcloud run services add-iam-policy-binding DESTINATION_SERVICE_NAME \
--region REGION \
--member=serviceAccount:PROJECT_NUMBER-compute@developer.gserviceaccount.com \
--role=roles/run.invoker
```
  Ersetzen Sie Folgendes:
  - DESTINATION_SERVICE_NAME: Der Name des Cloud Run-Zieldienstes.
  - REGION: der Name der Region.
  - PROJECT_NUMBER: die Nummer des Projekts.

Cloud Run-Dienst für den Client erstellen

Wenn Sie einen Cloud Run-Clientdienst erstellen, wird ein Envoy-Sidecar erstellt, dessen Ressourcen sich auf Ihre QPS und die Gesamtkonfigurationsgröße beziehen. In den meisten Fällen liegt die CPU-Auslastung unter 1 % einer vCPU und die Arbeitsspeicherauslastung unter 50 MB.

Sie benötigen Netzwerk-Ausgang für ein Virtual Private Cloud-Netzwerk.

Um den Clientdienst zum Testen zu erstellen, stellen Sie die Fortio-App in Cloud Run bereit, um den Traffic an HTTP-Routen weiterzuleiten:
```
gcloud beta run deploy CLIENT_SERVICE_NAME \
--region=REGION \
--image=fortio/fortio \
--network=VPC_NETWORK_NAME \
--subnet=SUBNET_NAME \
--mesh="projects/PROJECT_ID/locations/global/meshes/MESH_NAME"
```
Ersetzen Sie Folgendes:
- CLIENT_SERVICE_NAME: Der Name des Cloud Run-Dienstes des Clients.
- REGION: der Name Ihrer Region.
- VPC_NETWORK_NAME: Der Name Ihres VPC-Netzwerk, z. B. „default“.
- SUBNET_NAME: Der Name Ihres Subnetzes, z. B. „standard“.
- PROJECT_ID: die Projekt-ID.
- MESH_NAME: der Name der Mesh-Ressource.
Hinweis:
Wenn der Container nicht gestartet wird, prüfen Sie, ob Sie alle APIs aktiviert haben. Möglicherweise müssen Sie Ihrem Dienstkonto auch Zugriff auf Traffic Director gewähren. Führen Sie dazu den folgenden Befehl aus:
```
gcloud projects add-iam-policy-binding PROJECT_ID --member=serviceAccount:PROJECT_NUMBER-compute@developer.gserviceaccount.com --role=roles/trafficdirector.client
```

Dienst von einem Mesh-Client aufrufen

So leiten Sie eine Anfrage mit der Fortio-Test-App aus dem vorherigen Abschnitt Clientdienst erstellen an die Zielroute weiter:

Rufen Sie die URL des von Ihnen erstellten Cloud Run-Clientdiensts mit dem folgenden Befehl ab:
```
TEST_SERVICE_URL=$(gcloud run services describe CLIENT_SERVICE_NAME \
--region=REGION --format="value(status.url)" \
--project=PROJECT_ID)
```
Ersetzen Sie Folgendes:
- CLIENT_SERVICE_NAME: der Name des Cloud Run-Dienstes des Clients.
- REGION: der Name Ihrer Region.
- PROJECT_ID: die Projekt-ID.
Verwenden Sie den Befehl curl, um eine Anfrage an die Zielroute des Fortio-Endpunkts aus dem vorherigen Schritt zu senden:
```
curl -H "Authorization: Bearer $(gcloud auth print-identity-token)" "$TEST_SERVICE_URL/fortio/fetch/DESTINATION_SERVICE_NAME.DOMAIN_NAME"
```
Ersetzen Sie Folgendes:
- DESTINATION_SERVICE_NAME: Der Name des Cloud Run-Zieldienstes.
- DOMAIN_NAME: der Name der DNS-Domain.

Compute Engine-Back-End von Cloud Run aus aufrufen

Wenn Sie eine Compute Engine- und Cloud Service Mesh-Dienstroute mit verwalteten Instanzgruppen als Backends bereitstellen möchten, konfigurieren Sie den Compute Engine-basierten HTTP-Server in Cloud Service Mesh. So können Cloud Run-Clients diese Back-End-Dienstroute verwenden, um Anfragen direkt an Compute Engine-Instanzen zu senden.