Private Service Connect: Dienste mit Cloud Run veröffentlichen und nutzen

Informationen zu diesem Codelab

61 Minuten

Zuletzt aktualisiert: 28. März 2025

Verfasst von Lorin Price

1. Einführung

Private Service Connect (PSC) ist eine Funktion des Google Cloud-Netzwerks, mit der Nutzer privat aus ihrem VPC-Netzwerk auf verwaltete Dienste zugreifen können. Ebenso können Ersteller verwalteter Dienste diese Dienste in ihren eigenen separaten VPC-Netzwerken hosten und ihren Nutzern eine private Verbindung bieten.

Cloud Run ist eine verwaltete Computing-Plattform, mit der Sie Container direkt auf der skalierbaren Infrastruktur von Google ausführen können.

Cloud Run kann auf zwei verschiedene Arten als PSC-Dienst genutzt werden.

Über PSC für Google APIs, indem Cloud Run über die von Cloud Run bereitgestellte run.app-URL aufgerufen wird
Über einen benutzerdefinierten PSC-Produzentendienst, bei dem Cloud Run über einen Dienstanhang über einen internen Application Load Balancer mit einer serverlosen NEG verfügbar gemacht wird.

In diesem Codelab erfahren Sie, wie Sie Cloud Run mit PSC für beide Szenarien einrichten.

Aufgaben in diesem Lab

Einfache Apps in Cloud Run bereitstellen
Cloud Run-Steuerelemente für ein- und ausgehenden Traffic
Cloud Run über einen internen Application Load Balancer mit einer serverlosen NEG bereitstellen
PSC-Diensterstellerdienst über einen Dienstanhang einrichten
PSC-Endpunkte bereitstellen

Voraussetzungen

Google Cloud-Projekt mit Inhaberberechtigungen

2. Codelab-Topologie

In diesem Codelab stellen Sie zwei Cloud Run-Dienste bereit, auf die über PSC zugegriffen werden kann – zuerst als benutzerdefinierter veröffentlichter Dienst mit PSC und dann als PSC für Google APIs. Sie erstellen zwei VPCs, eine Nutzer-VPC und eine Produzenten-VPC. Sie stellen zuerst den Hello World-Cloud Run-Dienst bereit und machen ihn über einen regionalen internen Application Load Balancer und eine serverlose NEG im VPC des Dienstanbieters zugänglich. Sie prüfen, ob der Dienst über den Load Balancer über den Produzentenclient funktioniert, bevor Sie den Cloud Run-Dienst so einrichten, dass er über einen Dienstanhang als PSC-Produzentendienst zugänglich ist.

In der Nutzer-VPC stellen Sie einen PSC-Endpunkt bereit, der auf den Cloud Run-Dienstanhang verweist, den wir in der Producer-VPC eingerichtet haben. Prüfen Sie dann, ob der Dienst über PSC von einem Nutzerclient im Nutzer-VPC aus erreichbar ist. Als Nächstes erstellen Sie einen weiteren Cloud Run-Dienst, der Ihren PSC-Endpunkt aufruft. Zum Schluss stellen Sie einen PSC-Endpunkt für Google APIs bereit. Über den Nutzerclient greifen Sie auf Cloud Run über die von Cloud Run bereitgestellte URL zu. Dabei wird der PSC für den Google APIs-Endpunkt verwendet.

3. Einrichtung und Anforderungen

Einrichtung der Umgebung im eigenen Tempo

Melden Sie sich in der Google Cloud Console an und erstellen Sie ein neues Projekt oder verwenden Sie ein vorhandenes. Wenn Sie noch kein Gmail- oder Google Workspace-Konto haben, müssen Sie ein Konto erstellen.

Der Projektname ist der Anzeigename für die Teilnehmer dieses Projekts. Es ist ein Zeichenstring, der von Google APIs nicht verwendet wird. Sie können ihn jederzeit aktualisieren.
Die Projekt-ID ist für alle Google Cloud-Projekte eindeutig und kann nach der Festlegung nicht mehr geändert werden. In der Cloud Console wird automatisch ein eindeutiger String generiert. In der Regel spielt es keine Rolle, wie er lautet. In den meisten Codelabs müssen Sie auf Ihre Projekt-ID verweisen (normalerweise als PROJECT_ID gekennzeichnet). Wenn Ihnen die generierte ID nicht gefällt, können Sie eine andere zufällige generieren. Alternativ können Sie Ihr eigenes Konto ausprobieren und prüfen, ob es verfügbar ist. Sie kann nach diesem Schritt nicht mehr geändert werden und bleibt für die Dauer des Projekts bestehen.
Zur Information: Es gibt einen dritten Wert, die Projektnummer, die von einigen APIs verwendet wird. Weitere Informationen zu diesen drei Werten finden Sie in der Dokumentation.

Als Nächstes müssen Sie die Abrechnung in der Cloud Console aktivieren, um Cloud-Ressourcen/-APIs verwenden zu können. Die Durchführung dieses Codelabs ist kostenlos oder kostet nur sehr wenig. Wenn Sie die Ressourcen deaktivieren möchten, um weitere Kosten nach Abschluss dieser Anleitung zu vermeiden, können Sie die von Ihnen erstellten Ressourcen oder das Projekt löschen. Neuen Google Cloud-Nutzern steht das kostenlose Testprogramm mit einem Guthaben von 300$ zur Verfügung.

Cloud Shell starten

Sie können Google Cloud zwar per Fernzugriff von Ihrem Laptop aus nutzen, in diesem Codelab verwenden Sie jedoch Google Cloud Shell, eine Befehlszeilenumgebung, die in der Cloud ausgeführt wird.

Klicken Sie in der Google Cloud Console oben rechts in der Symbolleiste auf das Cloud Shell-Symbol:

Die Bereitstellung und Verbindung mit der Umgebung sollte nur wenige Minuten dauern. Wenn der Vorgang abgeschlossen ist, sollte in etwa Folgendes angezeigt werden:

Diese virtuelle Maschine verfügt über sämtliche Entwicklertools, die Sie benötigen. Sie bietet ein Basisverzeichnis mit 5 GB nichtflüchtigem Speicher und läuft auf Google Cloud. Dadurch werden Netzwerkleistung und Authentifizierung erheblich verbessert. Alle Aufgaben in diesem Codelab können in einem Browser ausgeführt werden. Sie müssen nichts installieren.

4. Hinweis

APIs aktivieren

Prüfen Sie in Cloud Shell, ob Ihr Projekt eingerichtet ist, und konfigurieren Sie Variablen.

gcloud auth login
gcloud config list project
gcloud config set project [YOUR-PROJECT-ID]
export projectid=[YOUR-PROJECT-ID]
export projectnum=[YOUR-PROJECT-NUM]
export region=us-central1
export zone=us-central1-a
echo $projectid
echo $projectnum
echo $region
echo $zone

Alle erforderlichen Dienste aktivieren

gcloud services enable compute.googleapis.com
gcloud services enable run.googleapis.com
gcloud services enable servicedirectory.googleapis.com
gcloud services enable dns.googleapis.com
gcloud services enable cloudbuild.googleapis.com
gcloud services enable cloudresourcemanager.googleapis.com

5. Ersteller-VPC-Netzwerk erstellen

VPC-Netzwerk

Über Cloud Shell

gcloud compute networks create producer-vpc --subnet-mode custom

Subnetze erstellen

Über Cloud Shell

gcloud compute networks subnets create producer-subnet \
    --network=producer-vpc \
    --range=10.0.0.0/28 \
    --region=$region

gcloud compute networks subnets create lb-proxy-subnet \
    --network=producer-vpc \
    --range=10.100.100.0/24 \
    --region=$region \
    --purpose=REGIONAL_MANAGED_PROXY \
    --role=ACTIVE

gcloud compute networks subnets create psc-nat-subnet \
    --network=producer-vpc \
    --region=$region \
    --range=10.100.101.0/24 \
    --purpose=PRIVATE_SERVICE_CONNECT

Das PSC-Subnetz wird dem PSC-Dienstanhang zum Zweck der Network Address Translation zugeordnet. Für Produktionsanwendungen muss dieses Subnetz entsprechend der Anzahl der angeschlossenen Endpunkte dimensioniert sein. Weitere Informationen finden Sie in der Dokumentation zur PSC-NAT-Subnetzgröße.

Netzwerk-Firewallrichtlinie und Firewallregeln für Produzenten erstellen

Über Cloud Shell

gcloud compute network-firewall-policies create producer-vpc-policy --global

gcloud compute network-firewall-policies associations create \
    --firewall-policy producer-vpc-policy \
    --network producer-vpc \
    --name network-producer-vpc \
    --global-firewall-policy

Damit IAP eine Verbindung zu Ihren VM-Instanzen herstellen kann, erstellen Sie eine Firewallregel, die:

Gilt für alle VM-Instanzen, die über IAP zugänglich sein sollen.
Lässt eingehenden Traffic aus dem IP-Bereich 35.235.240.0/20 zu. Dieser Bereich enthält alle IP-Adressen, die IAP für die TCP-Weiterleitung verwendet.

Über Cloud Shell

gcloud compute network-firewall-policies rules create 1000 \
    --action ALLOW \
    --firewall-policy producer-vpc-policy \
    --description "SSH with IAP" \
    --direction INGRESS \
    --src-ip-ranges 35.235.240.0/20 \
    --layer4-configs tcp:22  \
    --global-firewall-policy

6. „Hello World“-Cloud Run erstellen

Folgen Sie dieser Anleitung, um eine Beispielanwendung in Python zu schreiben. Führen Sie die folgenden Befehle in Cloud Shell aus. Nachdem Sie Schritt 3 unter „Beispielanwendung schreiben“ abgeschlossen haben, kehren Sie zu diesem Codelab zurück und folgen Sie der Anleitung unten, um die Anwendung aus der Quelle in Cloud Run bereitzustellen.

Bevor Sie Ihren Cloud Run-Dienst bereitstellen, prüfen Sie mit dem folgenden Befehl, ob Ihr Compute-Standarddienstkonto die erforderlichen Berechtigungen hat.

Über Cloud Shell

gcloud projects add-iam-policy-binding $projectid --member=serviceAccount:$projectnum-compute@developer.gserviceaccount.com --role=roles/run.builder

HINWEIS:In diesem Codelab wird davon ausgegangen, dass in Ihrer Organisation die Organisationsrichtlinie für die domaineingeschränkte Freigabe nicht aktiviert ist. Wenn Sie diese Richtlinie aktiviert haben, müssen Sie zusätzliche Schritte ausführen, um Cloud Run mit Authentifizierung bereitzustellen, einen OAuth-Zustimmungsbildschirm zu konfigurieren und IAP für Ihr Load Balancer-Backend einzurichten. Es wird empfohlen, alle diese Konfigurationsschritte in einer Produktionsumgebung auszuführen.

Über Cloud Shell

gcloud beta run deploy helloworld \
    --source . \
    --platform=managed \
    --ingress=internal \
    --allow-unauthenticated \
    --no-default-url \
    --region=$region

Wenn Sie das Flag --no-default-url verwenden, wird Ihr Cloud Run-Dienst ohne die angegebene run.app-URL bereitgestellt. Wir verwenden die URL für diesen Dienst nicht. Zum Zeitpunkt der Veröffentlichung dieses Codelabs befindet sich diese Funktion noch in der Vorabversion.

Wechseln Sie vor dem Fortfahren zurück zum Hauptverzeichnis Ihrer Cloud Shell.

Über Cloud Shell

cd ..

7. Hello World Cloud Run über einen internen Application Load Balancer bereitstellen

Reservieren Sie eine statische interne IP-Adresse für die Weiterleitungsregel des Load Balancers.

In Cloud Shell

gcloud compute addresses create cloudrun-ip \
 --region=$region \
 --subnet=producer-subnet

gcloud compute addresses describe cloudrun-ip --region=$region

Beispielausgabe

address: 10.0.1.31
addressType: INTERNAL
creationTimestamp: '2025-03-17T09:04:06.620-07:00'
description: ''
id: 'xxxx'
kind: compute#address
labelFingerprint: xxxx
name: cloudrun-ip
networkTier: PREMIUM
purpose: GCE_ENDPOINT
region: https://www.googleapis.com/compute/v1/projects/$projectid/regions/$region
selfLink: https://www.googleapis.com/compute/v1/projects/$projectid/regions/$region/addresses/cloudrun-ip
status: RESERVED
subnetwork: https://www.googleapis.com/compute/v1/projects/$projectid/regions/$region/subnetworks/producer-subnet

Notieren Sie sich die IP-Adresse, die Sie gerade erstellt haben.

Regionalen internen Application Load Balancer erstellen

In Cloud Shell

gcloud compute network-endpoint-groups create cloudrun-producer-neg \
    --region=$region \
    --network-endpoint-type=serverless \
    --cloud-run-service=helloworld

gcloud compute backend-services create cloudrun-producer-bes \
    --load-balancing-scheme=INTERNAL_MANAGED \
    --protocol=HTTP \
    --region=$region

gcloud compute backend-services add-backend cloudrun-producer-bes \
        --region=$region \
        --network-endpoint-group=cloudrun-producer-neg \
        --network-endpoint-group-region=$region

gcloud compute url-maps create producer-urlmap \
        --default-service=cloudrun-producer-bes \
        --region=$region

gcloud compute target-http-proxies create producer-http-proxy \
        --url-map=producer-urlmap \
        --region=$region

In Cloud Shell

gcloud compute forwarding-rules create cloudrun-fr \
        --load-balancing-scheme=INTERNAL_MANAGED \
        --network=producer-vpc \
        --subnet=producer-subnet \
        --address=cloudrun-ip \
        --target-http-proxy=producer-http-proxy \
        --target-http-proxy-region=$region \
        --region=$region \
        --ports=80 \
        --allow-global-access

8. Hello World Cloud Run über Load Balancer bereitstellen und testen

Test-VM erstellen

Über Cloud Shell

gcloud compute instances create producer-client \
    --zone=$zone \
    --subnet=producer-subnet \
    --no-address \
    --scopes=cloud-platform

In Cloud Shell

gcloud compute ssh \
    --zone "$zone" "producer-client" \
    --tunnel-through-iap \
    --project $projectid

Ersetzen Sie <loadbalancer-ip> durch die zuvor erstellte IP-Adresse (z. B. 10.0.0.2).

Hello World-Test

In der Producer-VM

curl <loadbalancer-ip>

Erwartete Ausgabe

Hello World!

Beenden Sie die VM.

In der Producer-VM

exit

9. Dienstanhang erstellen

Über Cloud Shell

gcloud compute service-attachments create cloudrun-attachment \
    --region=$region \
    --producer-forwarding-rule=cloudrun-fr \
    --connection-preference=ACCEPT_MANUAL \
    --consumer-accept-list=$projectid=5 \
    --nat-subnets=psc-nat-subnet

Rufen Sie als Nächstes den URI des Dienstanhangs ab und notieren Sie sich diesen, um den PSC-Endpunkt in der Verbraucherumgebung zu konfigurieren.

In Cloud Shell

gcloud compute service-attachments describe cloudrun-attachment --region=$region

Beispiel für die erwartete Ausgabe

connectionPreference: ACCEPT_MANUAL
consumerAcceptLists:
- connectionLimit: 5
  projectIdOrNum: $projectid
creationTimestamp: '2025-03-10T08:49:08.134-07:00'
description: ''
enableProxyProtocol: false
fingerprint: -F0Kpe3Fi8o=
id: '2679595584727463707'
kind: compute#serviceAttachment
name: cloudrun-attachment
natSubnets:
- https://www.googleapis.com/compute/v1/projects/$projectid/regions/$region/subnetworks/psc-nat-subnet
pscServiceAttachmentId:
  high: 'xxxxx'
  low: 'xxxx'
reconcileConnections: false
region: https://www.googleapis.com/compute/v1/projects/$projectid/regions/$region
selfLink: https://www.googleapis.com/compute/v1/projects/$projectid/regions/$region/serviceAttachments/cloudrun-attachment
targetService: https://www.googleapis.com/compute/v1/projects/$projectid/regions/$projectid/forwardingRules/cloudrun-fr

10. Nutzer-VPC-Netzwerk erstellen

VPC-Netzwerk

Über Cloud Shell

gcloud compute networks create consumer-vpc --subnet-mode custom

Subnetz erstellen

Über Cloud Shell

gcloud compute networks subnets create consumer-subnet \
    --network=consumer-vpc \
    --range=10.0.0.0/24 \
    --region=$region \
    --enable-private-ip-google-access

gcloud compute networks subnets create cloudrun-egress \
    --network=consumer-vpc \
    --range=10.0.1.0/24 \
    --region=$region \
    --enable-private-ip-google-access

Cloud NAT erstellen

Über Cloud Shell

gcloud compute routers create central-cr \
    --network=consumer-vpc \
    --region=$region

gcloud compute routers nats create central-nat \
    --router=central-cr \
    --region=$region \
    --nat-all-subnet-ip-ranges \
    --auto-allocate-nat-external-ips

Firewallrichtlinie und Firewallregeln für ein Verbrauchernetzwerk erstellen

Wir erstellen eine weitere Netzwerk-Firewallrichtlinie für das Verbraucher-VPC.

Über Cloud Shell

gcloud compute network-firewall-policies create consumer-vpc-policy --global

gcloud compute network-firewall-policies associations create --firewall-policy consumer-vpc-policy --network consumer-vpc --name network-consumer-vpc --global-firewall-policy

gcloud compute network-firewall-policies rules create 1000 --action ALLOW --firewall-policy consumer-vpc-policy --description "SSH with IAP" --direction INGRESS --src-ip-ranges 35.235.240.0/20 --layer4-configs tcp:22  --global-firewall-policy

11. PSC-Endpunkt für den „Hello World“-Cloud Run-Dienst erstellen

Jetzt erstellen wir einen PSC-Endpunkt und verbinden ihn mit dem Cloud Run-Dienst, den Sie über den Dienstanhang freigegeben haben. Verwenden Sie den URI des Dienstanhangs, den Sie zuvor in diesem Abschnitt notiert haben. Achten Sie darauf, dass das Format des URI im gcloud-Befehl mit Ihrem URI übereinstimmt.

PSC-Endpunkt erstellen

Über Cloud Shell

gcloud compute addresses create cloudrun-service-ip --region=$region --subnet=consumer-subnet --ip-version=IPV4


gcloud compute forwarding-rules create cloudrun-ep --region=$region --network=consumer-vpc --address=cloudrun-service-ip --target-service-attachment=projects/$projectid/regions/$region/serviceAttachments/cloudrun-attachment

Rufen Sie die IP-Adresse des PSC-Endpunkts ab, den Sie gerade erstellt haben. Sie verwenden die IP-Adresse im nächsten Schritt, um den Endpunkt zu testen.

Über Cloud Shell

gcloud compute addresses list --filter="name=cloudrun-service-ip"

Beispiel für die erwartete Ausgabe

NAME: cloudrun-service-ip
ADDRESS/RANGE: 10.0.0.2
TYPE: INTERNAL
PURPOSE: GCE_ENDPOINT
NETWORK: 
REGION: us-central1
SUBNET: consumer-subnet
STATUS: IN_USE

12. VM für Endnutzerclient erstellen und Verbindung zum Endpunkt testen

VM für Endkunden erstellen

Über Cloud Shell

gcloud compute instances create consumer-client \
    --zone=$zone \
    --subnet=consumer-subnet \
    --no-address \
    --metadata startup-script='#! /bin/bash
    sudo apt-get update
    sudo apt-get install dnsutils -y'

Konnektivität testen

Über Cloud Shell

gcloud compute ssh \
    --zone "$zone" "consumer-client" \
    --tunnel-through-iap \
    --project $projectid

Ersetzen Sie <cloudrun-service-ip> durch die tatsächliche IP-Adresse.

Über die VM eines Verbraucher-Clients

curl <cloudrun-service-ip>

Erwartete Ausgabe

Hello World!

Über die VM eines Verbraucher-Clients

exit

13. Cloud Run-Loop-Dienst erstellen

Als Nächstes erstellen wir einen Cloud Run-Dienst, der einen privaten Rückruf an das Verbraucher-VPC sendet, um den vorherigen Cloud Run-HelloWorld-Dienst aufzurufen, den wir über PSC offengelegt haben.

Folgen Sie der Anleitung hier, um eine Schleifenanwendung in PHP zu schreiben. Nennen Sie das Verzeichnis anstelle von „helloworld-php“ in „cloudrun-loop“ um. Führen Sie die folgenden Befehle in Cloud Shell aus. Verwenden Sie in Schritt 2 den folgenden PHP-Code in Ihrer index.php-Datei. Kehren Sie zum Codelab zurück, wenn Sie bereit sind, die Bereitstellung in Cloud Run vorzunehmen. Folgen Sie für diesen Schritt nicht der Anleitung in der Dokumentation.

Verwenden Sie diesen Code für Ihre index.php-Datei. Ersetzen Sie <cloudrun-service-ip> durch die IP-Adresse des PSC-Endpunkts, den Sie im vorherigen Schritt getestet haben.

Über Cloud Shell

<?php 

if(!function_exists('curl_init')) {
    die('cURL not available!');
}

$curl = curl_init();
curl_setopt($curl, CURLOPT_URL, 'http://<cloudrun-service-ip>/');
curl_setopt($curl, CURLOPT_FAILONERROR, true);
curl_setopt($curl, CURLOPT_FOLLOWLOCATION, true);
curl_setopt($curl, CURLOPT_RETURNTRANSFER, true);

$output = curl_exec($curl);
if ($output === FALSE) {
    echo 'An error has occurred: ' . curl_error($curl) . PHP_EOL;
}
else {
    echo $output;
}
?>

Wir geben in dieser Cloud Run-Bereitstellung ein Netzwerk und ein Subnetz an, da Cloud Run-Traffic zurück in das VPC geleitet werden muss, um auf den PSC-Endpunkt zuzugreifen. Wir weisen Cloud Run an, das Subnetz „cloudrun-egress“ für ausgehenden Direct VPC-Traffic zu verwenden. Wir leiten den gesamten Traffic über das Direct VPC Egress-Subnetz zurück in die VPC.

Über Cloud Shell

gcloud run deploy cloudrun-loop \
    --source . \
    --platform=managed \
    --ingress=internal \
    --allow-unauthenticated  \
    --vpc-egress=all-traffic \
    --network=consumer-vpc \
    --subnet=cloudrun-egress \
    --region=$region

Nach Abschluss der Bereitstellung des Cloud Run-Dienstes wird eine Dienst-URL im Format https://cloudrun-loop-<projectnum>.<region>.run.app angezeigt. Notieren Sie sich diese URL, da Sie sie im nächsten Schritt testen.

14. Konnektivität zu CloudRun-Loop über Cloud Run-URL testen

Über Cloud Shell

gcloud compute ssh \
    --zone "$zone" "consumer-client" \
    --tunnel-through-iap \
    --project $projectid

Ersetzen Sie <Cloud-Run-ServiceURL> durch die Dienst-URL, die Sie im vorherigen Schritt notiert haben.

Über die VM eines Verbraucher-Clients

curl <Cloud-Run-ServiceURL>

Erwartete Ausgabe

Hello World!

Dieses Ergebnis zeigt, dass unser Cloud Run-Loop-Dienst den PSC-Endpunkt, der mit unserem Hello World-Cloud Run-Dienst verbunden ist, erfolgreich im Verbraucher-VPC aufruft. Derzeit sendet unsere VM für den Verbraucherclient jedoch über unser Cloud NAT-Gateway ausgehende Traffic zum Internet, um eine öffentliche Cloud Run-URL aufzurufen. Wir können einen Dig-Befehl für die URL ausführen, um zu sehen, dass sie auf eine öffentliche IP-Adresse verweist.

Über die VM eines Verbraucher-Clients

dig <Cloud-Run-ServiceURL>

Beispielausgabe

; <<>> DiG 9.18.33-1~deb12u2-Debian <<>> https://cloudrun-loop-<projectnum>.<region>.run.app
;; global options: +cmd
;; Got answer:
;; ->>HEADER<<- opcode: QUERY, status: NOERROR, id: 1938
;; flags: qr rd ra; QUERY: 1, ANSWER: 4, AUTHORITY: 0, ADDITIONAL: 1

;; OPT PSEUDOSECTION:
; EDNS: version: 0, flags:; udp: 65494
;; QUESTION SECTION:
;https://cloudrun-loop-<projectnum>.<region>.run.app.        IN A

;; ANSWER SECTION:
https://cloudrun-loop-<projectnum>.<region>.run.app. 300 IN A 216.239.38.53
https://cloudrun-loop-<projectnum>.<region>.run.app. 300 IN A 216.239.36.53
https://cloudrun-loop-<projectnum>.<region>.run.app. 300 IN A 216.239.32.53
https://cloudrun-loop-<projectnum>.<region>.run.app. 300 IN A 216.239.34.53

;; Query time: 4 msec
;; SERVER: 127.0.0.53#53(127.0.0.53) (UDP)
;; WHEN: Tue Mar 11 19:05:36 UTC 2025
;; MSG SIZE  rcvd: 147

Wir können einen PSC für den Google APIs-Endpunkt erstellen, um diese Auflösung in „privat“ zu ändern, damit der Traffic nicht über das öffentliche Internet läuft.

Über die VM eines Verbraucher-Clients

exit

15. PSC für Google APIs-Endpunkt erstellen

Dieser PSC-Endpunkt unterscheidet sich von dem, den wir zuvor erstellt haben. PSC für Google APIs verweist auf ein Google API-Bundle (entweder alle APIs oder VPC-SC-kompatible APIs). Die IP-Adresse stammt nicht aus einem regionalen Subnetz, sondern wird als einzelne globale /32-IP-Adresse erstellt, die sich nicht mit vorhandenen VPC-Subnetzen, VPC-Peering-Subnetzen oder Hybrid-Routen überschneiden darf.

Über Cloud Shell

export pscgoogip=100.100.100.100

echo $pscgoogip

gcloud compute addresses create psc-goog-ep-ip \
    --global \
    --purpose=PRIVATE_SERVICE_CONNECT \
    --addresses=$pscgoogip \
    --network=consumer-vpc

Über Cloud Shell

gcloud compute forwarding-rules create psc4googapi \
    --global \
    --network=consumer-vpc \
    --address=psc-goog-ep-ip \
    --target-google-apis-bundle=all-apis

16. Private Cloud DNS-Zone für run.app erstellen

Wenn ein PSC-Endpunkt für Google APIs erstellt wird, wird eine private Cloud Run-DNS-Zone für alle APIs erstellt, die zur Domain googleapis.com gehören. Da Cloud Run run.app verwendet, müssen wir eine weitere private Zone erstellen, um run.app unserem PSC für den Google APIs-Endpunkt zuzuordnen.

Über Cloud Shell

gcloud dns managed-zones create "cloudrun" \
    --dns-name=run.app \
    --description="run.app psc resolution" \
    --visibility=private \
    --networks=consumer-vpc

gcloud dns record-sets transaction start \
   --zone="cloudrun"

gcloud dns record-sets transaction add $pscgoogip \
   --name=*.run.app \
   --ttl=300 \
   --type=A \
   --zone="cloudrun"

gcloud dns record-sets transaction execute \
   --zone="cloudrun"

17. Private DNS-Auflösung testen

Melden Sie sich wieder in der VM des Verbraucherclients an und führen Sie den Befehl „dig“ noch einmal aus. Jetzt sollte die Cloud Run-URL auf unseren PSC für den Google APIs-Endpunkt verweisen.

Über Cloud Shell

gcloud compute ssh \
    --zone "$zone" "consumer-client" \
    --tunnel-through-iap \
    --project $projectid

Leeren Sie zuerst den DNS-Cache. Ersetzen Sie <Cloud-Run-ServiceURL> durch die zuvor notierte Dienst-URL.

Über die VM eines Verbraucher-Clients

sudo resolvectl flush-caches

curl <CloudRun-Loop-ServiceURL>

Die Curl-Anfrage sollte weiterhin wie gewohnt funktionieren.

Über die VM eines Verbraucher-Clients

curl <CloudRun-Loop-ServiceURL>

Erwartete Ausgabe

Hello World!

Über die VM eines Verbraucher-Clients

dig <CloudRun-Loop-ServiceURL>

Der Befehl „dig“ sollte zeigen, dass unser Cloud Run Loop-Dienst jetzt auf unseren PSC für den Google APIs-Endpunkt verweist.

Beispielausgabe

; <<>> DiG 9.18.33-1~deb12u2-Debian <<>> https://cloudrun-loop-<projectnum>.<region>.run.app
;; global options: +cmd
;; Got answer:
;; ->>HEADER<<- opcode: QUERY, status: NOERROR, id: 30179
;; flags: qr rd ra; QUERY: 1, ANSWER: 1, AUTHORITY: 0, ADDITIONAL: 1

;; OPT PSEUDOSECTION:
; EDNS: version: 0, flags:; udp: 65494
;; QUESTION SECTION:
;https://cloudrun-loop-<projectnum>.<region>.run.app.        IN A

;; ANSWER SECTION:
https://cloudrun-loop-<projectnum>.<region>.run.app. 300 IN A 100.100.100.100

;; Query time: 8 msec
;; SERVER: 127.0.0.53#53(127.0.0.53) (UDP)
;; WHEN: Tue Mar 11 20:04:05 UTC 2025
;; MSG SIZE  rcvd: 99

Erfolgreich!

18. Bereinigungsschritte

VM-Instanz beenden

exit

Über Cloud Shell

gcloud dns record-sets delete *.run.app --zone="cloudrun" --type=A -q

gcloud dns managed-zones delete "cloudrun" -q

gcloud compute instances delete consumer-client --zone=$zone --project=$projectid -q

gcloud compute forwarding-rules delete psc4googapi --global -q

gcloud compute addresses delete psc-goog-ep-ip --global -q

gcloud run services delete cloudrun-loop --region=$region -q 

gcloud artifacts docker images delete $region-docker.pkg.dev/$projectid/cloud-run-source-deploy/cloudrun-loop -q

gcloud compute forwarding-rules delete cloudrun-ep --region=$region -q

gcloud compute addresses delete cloudrun-service-ip --region=$region -q

gcloud compute network-firewall-policies rules delete 1000 --firewall-policy consumer-vpc-policy --global-firewall-policy -q

gcloud compute network-firewall-policies associations delete --firewall-policy=consumer-vpc-policy  --name=network-consumer-vpc --global-firewall-policy -q

gcloud compute network-firewall-policies delete consumer-vpc-policy --global -q

gcloud compute routers nats delete central-nat --router=central-cr --region=$region -q

gcloud compute routers delete central-cr --region=$region -q

gcloud compute networks subnets delete consumer-subnet --region $region -q

Es kann sein, dass die Ausführung der nächsten beiden Befehle mit dem Fehler „Ressource in Verwendung“ fehlschlägt. In den Cloud Run-Dokumenten wird angegeben, dass es manchmal 1 bis 2 Stunden dauert, bis Cloud Run die Subnetzressourcen freigibt, nachdem der Cloud Run-Dienst gelöscht wurde. Wenn das Löschen fehlschlägt, überspringen Sie diese beiden Befehle und fahren Sie mit dem nächsten Abschnitt fort. Kehren Sie nach einiger Zeit zurück zu diesem Abschnitt, um die Dateien zu löschen.

Über Cloud Shell

gcloud compute networks subnets delete cloudrun-egress --region $region -q

gcloud compute networks delete consumer-vpc -q

Über Cloud Shell

gcloud compute service-attachments delete cloudrun-attachment --region=$region -q

gcloud compute instances delete producer-client --zone=$zone --project=$projectid -q

gcloud compute forwarding-rules delete cloudrun-fr --region=$region -q

gcloud compute target-http-proxies delete producer-http-proxy --region=$region -q

gcloud compute url-maps delete producer-urlmap --region=$region -q

gcloud compute backend-services delete cloudrun-producer-bes --region=$region -q

gcloud compute network-endpoint-groups delete cloudrun-producer-neg --region=$region -q

gcloud compute addresses delete cloudrun-ip --region=$region -q

gcloud run services delete helloworld --region=$region -q 

gcloud artifacts docker images delete $region-docker.pkg.dev/$projectid/cloud-run-source-deploy/helloworld -q

gcloud artifacts repositories delete cloud-run-source-deploy --location=$region -q

gcloud compute network-firewall-policies rules delete 1000 --firewall-policy producer-vpc-policy --global-firewall-policy -q

gcloud compute network-firewall-policies associations delete --firewall-policy=producer-vpc-policy  --name=network-producer-vpc --global-firewall-policy -q

gcloud compute network-firewall-policies delete producer-vpc-policy --global -q

gcloud compute networks subnets delete lb-proxy-subnet --region $region -q

gcloud compute networks subnets delete psc-nat-subnet --region $region -q

gcloud compute networks subnets delete producer-subnet --region $region -q

gcloud compute networks delete producer-vpc -q

19. Glückwunsch!

Herzlichen Glückwunsch zum Abschluss des Codelabs.

Behandelte Themen

Einfache Apps in Cloud Run bereitstellen
Cloud Run-Steuerelemente für ein- und ausgehenden Traffic
Cloud Run über einen internen Application Load Balancer mit einer serverlosen NEG bereitstellen
PSC-Diensterstellerdienst über einen Dienstanhang einrichten
PSC-Endpunkte bereitstellen