GSP1089
Übersicht
Cloud Run Functions ist das
FaaS-Angebot (Functions-as‑a‑Service) von Google Cloud. Es ist mit einem
erweiterten Feature-Set ausgestattet und basiert auf
Cloud Run und
Eventarc. So haben Sie
mehr Kontrolle über Leistung und Skalierbarkeit sowie über die Laufzeit und
Trigger der Funktionen aus über 90 Ereignisquellen.
In diesem Lab erstellen Sie Cloud Run Functions, die auf HTTP-Aufrufe
reagieren und durch Cloud Storage-Ereignisse und Cloud-Audit-Logs getriggert
werden. Sie stellen auch mehrere Versionen einer Cloud Run-Funktion bereit und
testen neue Einstellungen.
Das ist neu
Diese neue Version von Cloud Run Functions bietet eine verbesserte
FaaS-Funktion, die auf Cloud Run, Cloud Build, Artifact Registry und Eventarc
basiert.
Erweiterte Infrastruktur
-
Längere Verarbeitung von Anfragen: Führen Sie Ihre Cloud
Run Functions länger als die standardmäßigen 5 Minuten aus. So können Sie
leichter zeitaufwendigere Arbeitslasten ausführen, beispielsweise bei der
Verarbeitung großer Datenströme aus Cloud Storage oder BigQuery. Bei
HTTP-Funktionen sind das bis zu 60 Minuten. Bei ereignisgesteuerten
Funktionen beträgt die Dauer derzeit bis zu 10 Minuten.
-
Größere Instanzen: Nutzen Sie bis zu 16 GB RAM und 4 vCPUs
mit Cloud Run Functions, wodurch größere speicherinterne, rechenintensive
und parallele Arbeitslasten möglich sind.
-
Nebenläufigkeit: Verarbeiten Sie bis zu 1.000 gleichzeitige
Anfragen mit einer einzelnen Funktionsinstanz. So werden Kaltstarts
minimiert und die Latenz beim Skalieren verbessert.
-
Mindestinstanzen: Stellen Sie vorbereitete Instanzen
bereit, um Kaltstarts zu minimieren und dafür zu sorgen, dass die
Bootstrap-Zeit Ihrer Anwendung nicht die Anwendungsleistung beeinträchtigt.
-
Aufteilung des Traffics: Unterstützen Sie mehrere Versionen
Ihrer Funktionen, teilen Sie den Traffic auf verschiedene Versionen auf und
setzen Sie Ihre Funktion auf eine frühere Version zurück.
Umfassendere Ereignisabdeckung und CloudEvents-Unterstützung
-
Integration von Eventarc: Cloud Run Functions bietet jetzt
native Unterstützung für Eventarc, wodurch über
125 Ereignisquellen
mit Cloud-Audit-Logs (BigQuery, Cloud SQL, Cloud Storage usw.) verfügbar
sind. Natürlich werden in Cloud Run Functions weiterhin Ereignisse aus
benutzerdefinierten Quellen unterstützt, indem direkt in Cloud Pub/Sub
veröffentlicht wird.
-
CloudEvent-Format: Alle ereignisgesteuerten Funktionen
entsprechen unabhängig von der Quelle dem Branchenstandard CloudEvents (cloudevents.io), um eine konsistente Entwicklerumgebung zu gewährleisten. Die Nutzlasten
werden über ein strukturiertes CloudEvent mit einer
cloudevent.data-Nutzlast
gesendet und entsprechen dem CloudEvent-Standard.
Ziele
Aufgaben in diesem Lab:
- Funktion schreiben, die auf HTTP-Aufrufe reagiert
- Funktion schreiben, die auf Cloud Storage-Ereignisse reagiert
- Funktion schreiben, die auf Cloud-Audit-Logs reagiert
- Mehrere Versionen einer Cloud Run-Funktion bereitstellen
- Kaltstarts mit Mindestanzahl von Instanzen vermeiden
- Nebenläufigkeit einrichten
Einrichtung und Anforderungen
Vor dem Klick auf „Start Lab“ (Lab starten)
Lesen Sie diese Anleitung. Labs sind zeitlich begrenzt und können nicht pausiert werden. Der Timer beginnt zu laufen, wenn Sie auf Lab starten klicken, und zeigt Ihnen, wie lange Google Cloud-Ressourcen für das Lab verfügbar sind.
In diesem praxisorientierten Lab können Sie die Lab-Aktivitäten in einer echten Cloud-Umgebung durchführen – nicht in einer Simulations- oder Demo-Umgebung. Dazu erhalten Sie neue, temporäre Anmeldedaten, mit denen Sie für die Dauer des Labs auf Google Cloud zugreifen können.
Für dieses Lab benötigen Sie Folgendes:
- Einen Standardbrowser (empfohlen wird Chrome)
Hinweis: Nutzen Sie den privaten oder Inkognitomodus (empfohlen), um dieses Lab durchzuführen. So wird verhindert, dass es zu Konflikten zwischen Ihrem persönlichen Konto und dem Teilnehmerkonto kommt und zusätzliche Gebühren für Ihr persönliches Konto erhoben werden.
- Zeit für die Durchführung des Labs – denken Sie daran, dass Sie ein begonnenes Lab nicht unterbrechen können.
Hinweis: Verwenden Sie für dieses Lab nur das Teilnehmerkonto. Wenn Sie ein anderes Google Cloud-Konto verwenden, fallen dafür möglicherweise Kosten an.
Lab starten und bei der Google Cloud Console anmelden
-
Klicken Sie auf Lab starten. Wenn Sie für das Lab bezahlen müssen, wird ein Dialogfeld geöffnet, in dem Sie Ihre Zahlungsmethode auswählen können.
Auf der rechten Seite befindet sich der Bereich Lab-Einrichtung und ‑Zugriff:
- Button Google Cloud Console öffnen
- Die temporären Anmeldedaten (Nutzername und Passwort), die Sie für dieses Lab verwenden müssen
- Gegebenenfalls weitere Informationen für dieses Lab
Der Lab-Timer befindet sich oben auf der Seite und zeigt die verbleibende Zeit an.
-
Klicken Sie auf Google Cloud Console öffnen. Wenn Sie Chrome verwenden, können Sie auch rechtsklicken und Link in Inkognitofenster öffnen auswählen.
Im Lab werden Ressourcen aktiviert. Anschließend wird ein weiterer Tab mit der Seite „Anmelden“ geöffnet.
Tipp: Ordnen Sie die Tabs nebeneinander in separaten Fenstern an.
Hinweis: Wird das Dialogfeld Konto auswählen angezeigt, klicken Sie auf Anderes Konto verwenden.
-
Kopieren Sie bei Bedarf den folgenden Nutzernamen und fügen Sie ihn in das Dialogfeld Anmelden ein.
{{{user_0.username | "Username"}}}
Sie finden den Nutzernamen auch im Bereich Lab-Einrichtung und ‑Zugriff.
-
Klicken Sie auf Weiter.
-
Kopieren Sie das folgende Passwort und fügen Sie es in das Dialogfeld Willkommen ein.
{{{user_0.password | "Password"}}}
Sie finden das Passwort auch im Bereich Lab-Einrichtung und ‑Zugriff.
-
Klicken Sie auf Weiter.
Wichtig: Sie müssen die für das Lab bereitgestellten Anmeldedaten verwenden. Nutzen Sie nicht die Anmeldedaten Ihres Google Cloud-Kontos.
Hinweis: Wenn Sie Ihr eigenes Google Cloud-Konto für dieses Lab nutzen, können zusätzliche Kosten anfallen.
-
Klicken Sie sich durch die nachfolgenden Seiten:
- Akzeptieren Sie die Nutzungsbedingungen.
- Fügen Sie keine Wiederherstellungsoptionen oder 2-Faktor-Authentifizierung hinzu, da dies nur ein temporäres Konto ist.
- Melden Sie sich nicht für kostenlose Testversionen an.
Nach wenigen Augenblicken wird die Google Cloud Console in diesem Tab geöffnet.
Hinweis: Wenn Sie auf Google Cloud-Produkte und ‑Dienste zugreifen möchten, klicken Sie auf das Navigationsmenü oder geben Sie den Namen des Produkts oder Dienstes in das Feld Suchen ein.
Cloud Shell aktivieren
Cloud Shell ist eine virtuelle Maschine, auf der Entwicklertools installiert sind. Sie bietet ein Basisverzeichnis mit 5 GB nichtflüchtigem Speicher und läuft auf Google Cloud. Mit Cloud Shell erhalten Sie Befehlszeilenzugriff auf Ihre Google Cloud-Ressourcen.
-
Klicken Sie oben in der Google Cloud Console auf Cloud Shell aktivieren
.
-
Klicken Sie sich durch die folgenden Fenster:
- Fahren Sie mit dem Informationsfenster zu Cloud Shell fort.
- Autorisieren Sie Cloud Shell, Ihre Anmeldedaten für Google Cloud API-Aufrufe zu verwenden.
Wenn eine Verbindung besteht, sind Sie bereits authentifiziert und das Projekt ist auf Project_ID, eingestellt. Die Ausgabe enthält eine Zeile, in der die Project_ID für diese Sitzung angegeben ist:
Ihr Cloud-Projekt in dieser Sitzung ist festgelegt als {{{project_0.project_id | "PROJECT_ID"}}}
gcloud ist das Befehlszeilentool für Google Cloud. Das Tool ist in Cloud Shell vorinstalliert und unterstützt die Tab-Vervollständigung.
- (Optional) Sie können den aktiven Kontonamen mit diesem Befehl auflisten:
gcloud auth list
- Klicken Sie auf Autorisieren.
Ausgabe:
ACTIVE: *
ACCOUNT: {{{user_0.username | "ACCOUNT"}}}
Um das aktive Konto festzulegen, führen Sie diesen Befehl aus:
$ gcloud config set account `ACCOUNT`
- (Optional) Sie können die Projekt-ID mit diesem Befehl auflisten:
gcloud config list project
Ausgabe:
[core]
project = {{{project_0.project_id | "PROJECT_ID"}}}
Hinweis: Die vollständige Dokumentation für gcloud finden Sie in Google Cloud in der Übersicht zur gcloud CLI.
Aufgabe 1: APIs aktivieren
Bevor Sie die Cloud Run-Funktionen erstellen, müssen Sie die nötigen APIs
aktivieren.
-
Führen Sie zur Aktivierung aller erforderlichen Dienste den folgenden Befehl
aus.
gcloud services enable \
artifactregistry.googleapis.com \
cloudfunctions.googleapis.com \
cloudbuild.googleapis.com \
eventarc.googleapis.com \
run.googleapis.com \
logging.googleapis.com \
pubsub.googleapis.com \
cloudquotas.googleapis.com \
monitoring.googleapis.com
Aufgabe 2: HTTP-Funktion erstellen
Für die erste Funktion erstellen Sie eine
authentifizierte Node.js-Funktion, die auf HTTP-Anfragen
reagiert. Verwenden Sie ein Zeitlimit von 10 Minuten, um zu zeigen, wie eine
Funktion mehr Zeit für die Reaktion auf HTTP-Anfragen erhalten kann.
Erstellen
-
Führen Sie im Cloud Shell-Terminal den folgenden Befehl aus, um den Ordner
und die Dateien für die App zu erstellen und den Ordner zu öffnen:
mkdir ~/hello-http && cd $_
touch index.js && touch package.json
-
Klicken Sie in der Symbolleiste von Cloud Shell auf den Button
Editor öffnen.
-
Fügen Sie in der Datei hello-http/index.js den folgenden Code
hinzu, der einfach auf HTTP-Anfragen reagiert:
const functions = require('@google-cloud/functions-framework');
functions.http('helloWorld', (req, res) => {
res.status(200).send('HTTP with Node.js in GCF 2nd gen!');
});
-
Fügen Sie in der Datei
hello-http/package.json den folgenden
Inhalt hinzu, um die Abhängigkeiten anzugeben:
{
"name": "nodejs-functions-gen2-codelab",
"version": "0.0.1",
"main": "index.js",
"dependencies": {
"@google-cloud/functions-framework": "^2.0.0"
}
}
Bereitstellen
-
Führen Sie im Cloud Shell-Terminal den folgenden Befehl aus, um die Funktion
bereitzustellen:
gcloud run deploy nodejs-http-function \
--source . \
--function helloWorld \
--base-image {{{project_0.startup_script.node_gcp_runtime | node_gcp_runtime}}} \
--region {{{project_0.default_region|Region}}} \
--timeout 600s \
--max-instances 1 \
--no-allow-unauthenticated
Hinweis: Wenn ein Berechtigungsfehler ausgegeben wird, warten Sie ein paar Minuten und versuchen Sie es dann noch einmal. Es dauert einige Minuten, bis die APIs aktiviert werden.
Die in diesem Befehl verwendeten Flags sind:
-
--source .: weist Cloud Run an, die Funktion mithilfe von
Buildpacks in ein Container-Image zu erstellen.
-
--function helloWorld: Legt den aufzurufenden
Funktionseinstiegspunkt fest.
-
--base-image {{{project_0.startup_script.node_gcp_runtime |
node_gcp_runtime}}}: Gibt das Laufzeit-Basis-Image an und aktiviert automatische
Basis-Image-Updates für Sicherheitskorrekturen.
-
--timeout 600s: So kann die Funktion länger (600 Sekunden) auf
HTTP-Anfragen reagieren.
-
--max-instances 1: Legt die maximale Anzahl von Instanzen auf 1
fest.
-
--no-allow-unauthenticated: Sorgt dafür, dass die Funktion eine
Authentifizierung erfordert.
-
Sobald die Funktion bereitgestellt wurde, rufen Sie im Navigationsmenü der
Google Cloud Console Cloud Run auf und prüfen Sie, ob
nodejs-http-function aufgeführt ist.
Test
-
Rufen Sie in Cloud Shell die Dienst-URL Ihrer Funktion ab und speichern Sie
sie in einer Umgebungsvariablen:
SERVICE_URL="$(gcloud run services describe nodejs-http-function --region {{{project_0.default_region|Region}}} --format 'value(status.url)')"
-
Testen Sie die authentifizierte HTTP-Funktion, indem Sie Ihr Identitätstoken
im Autorisierungsheader übergeben:
curl -H "Authorization: Bearer $(gcloud auth print-identity-token)" $SERVICE_URL
Sie sollten als Antwort die folgende Mitteilung sehen:
HTTP with Node.js in GCF 2nd gen!
Klicken Sie auf Fortschritt prüfen.
HTTP-Funktion erstellen
Aufgabe 3: Cloud Storage-Funktion erstellen
In diesem Abschnitt erstellen Sie eine Node.js-Funktion, die mithilfe eines
Eventarc-Triggers auf Ereignisse aus einem Cloud Storage-Bucket reagiert.
Einrichten
-
Führen Sie die folgenden Befehle aus, um den Dienstkonten von Cloud Storage
und Compute Engine die erforderlichen IAM-Rollen zuzuweisen:
PROJECT_NUMBER=$(gcloud projects list --filter="project_id:{{{ project_0.project_id | PROJECT_ID }}}" --format='value(project_number)')
SERVICE_ACCOUNT=$(gcloud storage service-agent --project="$PROJECT_NUMBER" | xargs)
gcloud projects add-iam-policy-binding {{{ project_0.project_id | PROJECT_ID }}} \
--member serviceAccount:$SERVICE_ACCOUNT \
--role roles/pubsub.publisher
gcloud projects add-iam-policy-binding {{{ project_0.project_id | PROJECT_ID }}} \
--member serviceAccount:$PROJECT_NUMBER-compute@developer.gserviceaccount.com \
--role roles/eventarc.eventReceiver
Erstellen
-
Führen Sie den folgenden Befehl aus, um den Ordner und die Dateien für die
App zu erstellen und den Ordner zu öffnen:
mkdir ~/hello-storage && cd $_
touch index.js && touch package.json
-
Klicken Sie in der Symbolleiste von Cloud Shell auf den Button
Editor öffnen.
-
Fügen Sie in der Datei hello-storage/index.js den folgenden
Code hinzu, der einfach auf Cloud Storage-Ereignisse reagiert:
const functions = require('@google-cloud/functions-framework');
functions.cloudEvent('helloStorage', (cloudevent) => {
console.log('Cloud Storage event with Node.js in GCF 2nd gen!');
console.log(cloudevent);
});
-
Fügen Sie in der Datei
hello-storage/package.json den folgenden
Inhalt hinzu, um die Abhängigkeiten anzugeben:
{
"name": "nodejs-functions-gen2-codelab",
"version": "0.0.1",
"main": "index.js",
"dependencies": {
"@google-cloud/functions-framework": "^2.0.0"
}
}
Bereitstellen
-
Generieren Sie zuerst mit dem folgenden Befehl einen Cloud Storage-Bucket
für Ereignisse:
export BUCKET_NAME="gcf-gen2-storage-{{{ project_0.project_id | PROJECT_ID }}}"
gcloud storage buckets create gs://$BUCKET_NAME --location={{{project_0.default_region|Region}}}
-
Führen Sie den folgenden Befehl aus, um die Cloud Run-Funktion
bereitzustellen:
gcloud run deploy nodejs-storage-function \
--source . \
--function helloStorage \
--base-image {{{project_0.startup_script.node_gcp_runtime | node_gcp_runtime}}} \
--region {{{project_0.default_region|Region}}} \
--max-instances 1 \
--no-allow-unauthenticated
Hinweis: Wenn ein Berechtigungsfehler ausgegeben wird, warten Sie ein paar Minuten und versuchen Sie es dann noch einmal. Es kann einige Minuten dauern, bis die APIs aktiviert werden.
-
Erstellen Sie nun den Eventarc-Trigger, um Ereignisse zur Erstellung von
Cloud Storage-Objekten an die bereitgestellte Funktion weiterzuleiten:
gcloud eventarc triggers create nodejs-storage-function-trigger \
--location={{{project_0.default_region|Region}}} \
--destination-run-service=nodejs-storage-function \
--destination-run-region={{{project_0.default_region|Region}}} \
--event-filters="type=google.cloud.storage.object.v1.finalized" \
--event-filters="bucket=$BUCKET_NAME" \
--service-account=$PROJECT_NUMBER-compute@developer.gserviceaccount.com
-
Sobald die Funktion und der Trigger bereitgestellt wurden, überprüfen Sie,
ob
nodejs-storage-function in der
Cloud Run-Konsole angezeigt wird.

Test
-
Führen Sie den folgenden Befehl aus, um eine Datei in den Bucket hochzuladen
und die Funktion zu testen:
echo "Hello World" > random.txt
gcloud storage cp random.txt gs://$BUCKET_NAME/random.txt
-
Führen Sie den folgenden Befehl aus, um die Dienstlogs zu lesen. Das
empfangene CloudEvent sollte in den Logs angezeigt werden:
gcloud run services logs read nodejs-storage-function \
--region {{{project_0.default_region|Region}}} --limit=100
Hinweis: Es kann eine Minute dauern, bis Logs generiert werden.
Die Ausgabe sieht in etwa so aus:
Ausgabe:
}
traceparent: '00-c74cb472d1e78f7225b6f617a31d9c08-96f0380bb62be2c1-01'
},
etag: 'CKOx1L3wofoCEAE='
crc32c: 'R1jUOQ==',
mediaLink: 'https://storage.googleapis.com/download/storage/v1/b/gcf-gen2-storage-qwiklabs-gcp-00-101b4b9ca9bb/o/random.txt?generation=1663625646643363&alt=media',
md5Hash: '5Z/5eUEET4XfUpfhwwLSYA==',
size: '12',
timeStorageClassUpdated: '2022-09-19T22:14:06.657Z',
storageClass: 'STANDARD',
updated: '2022-09-19T22:14:06.657Z',
timeCreated: '2022-09-19T22:14:06.657Z',
contentType: 'text/plain',
metageneration: '1',
generation: '1663625646643363',
bucket: 'gcf-gen2-storage-qwiklabs-gcp-00-101b4b9ca9bb',
name: 'random.txt',
selfLink: 'https://www.googleapis.com/storage/v1/b/gcf-gen2-storage-qwiklabs-gcp-00-101b4b9ca9bb/o/random.txt',
id: 'gcf-gen2-storage-qwiklabs-gcp-00-101b4b9ca9bb/random.txt/1663625646643363',
kind: 'storage#object',
data: {
bucket: 'gcf-gen2-storage-qwiklabs-gcp-00-101b4b9ca9bb',
time: '2022-09-19T22:14:06.657124Z',
subject: 'objects/random.txt',
type: 'google.cloud.storage.object.v1.finalized',
specversion: '1.0',
source: '//storage.googleapis.com/projects/_/buckets/gcf-gen2-storage-qwiklabs-gcp-00-101b4b9ca9bb',
id: '5693030851428996',
{
Cloud Storage event with Node.js in GCF 2nd gen!
Klicken Sie auf Fortschritt prüfen.
Cloud Storage-Funktion erstellen
Aufgabe 4: Cloud-Audit-Logs-Funktion erstellen
In diesem Abschnitt erstellen Sie eine Node.js-Funktion, die beim Erstellen
einer Compute Engine-VM-Instanz ein
Cloud-Audit-Log-Ereignis empfängt. Als Reaktion darauf wird der neu erstellten VM ein Label
hinzugefügt, das den Ersteller der VM angibt.
Neu erstellte Compute Engine-VMs überprüfen
Compute Engine gibt beim Erstellen einer VM 2 Audit-Logs aus.
Das erste wird zu Beginn der VM-Erstellung ausgegeben und sieht so aus:

Das zweite wird nach der VM-Erstellung ausgegeben und sieht so aus:

Sie sehen das Vorgangsfeld mit den Werten first: true und
last: true. Das zweite Audit-Log enthält alle Informationen, die
Sie benötigen, um einer Instanz ein Label hinzuzufügen. Verwenden Sie das Flag
last: true, um es in Cloud Run-Funktionen zu erkennen.
Einrichten
Wenn Sie Cloud-Audit-Log-Funktionen verwenden möchten, müssen Sie für Eventarc
Audit-Logs aktivieren. Darüber hinaus müssen Sie ein Dienstkonto mit der Rolle
eventarc.eventReceiver verwenden.
-
Klicken Sie im Navigationsmenü auf IAM und Verwaltung >
Audit-Logs.
Hinweis: Sie können die Warnung zur fehlenden Berechtigung resourcemanager.folders.getIamPolicy ignorieren.
-
Suchen Sie nach der Compute Engine API und klicken Sie
auf das Kästchen daneben. Wenn Sie die API nicht finden, suchen Sie auf
der nächsten Seite weiter.
-
Aktivieren Sie im Infobereich rechts die Kästchen für die Log-Typen
Lesen durch Administrator,
Daten lesen und Daten schreiben. Klicken
Sie dann auf Speichern.
-
Weisen Sie dem Compute Engine-Standarddienstkonto die IAM-Rolle
eventarc.eventReceiver zu:
gcloud projects add-iam-policy-binding {{{ project_0.project_id | PROJECT_ID }}} \
--member serviceAccount:$PROJECT_NUMBER-compute@developer.gserviceaccount.com \
--role roles/eventarc.eventReceiver
Code abrufen
-
Führen Sie den folgenden Code aus, um das Repository mit der Anwendung zu
klonen:
cd ~
git clone https://github.com/GoogleCloudPlatform/eventarc-samples.git
-
Klicken Sie in der Symbolleiste von Cloud Shell auf den Button
Editor öffnen.
-
Gehen Sie im Datei-Explorer zu
eventarc-samples > gce-vm-labeler > gcf > nodejs und öffnen
Sie index.js.
Die Datei
index.js
enthält den Anwendungscode, der das in ein CloudEvent verpackte Audit-Log
empfängt. Anschließend werden die Details der Compute Engine-VM-Instanz
extrahiert und ein Label für die VM-Instanz festgelegt. Sie können sich die
Datei
index.js
gern genauer ansehen.
Bereitstellen
-
Führen Sie im Cloud Shell-Terminal den folgenden Befehl aus, um das
App-Verzeichnis zu öffnen:
cd ~/eventarc-samples/gce-vm-labeler/gcf/nodejs
-
Führen Sie den folgenden Befehl aus, um die Cloud Run-Funktion
bereitzustellen:
gcloud run deploy gce-vm-labeler \
--source . \
--function labelVmCreation \
--base-image {{{project_0.startup_script.node_gcp_runtime | node_gcp_runtime}}} \
--region {{{project_0.default_region|Region}}} \
--max-instances 1 \
--no-allow-unauthenticated
-
Erstellen Sie den Eventarc-Trigger, um nach Audit-Logs für Compute
Engine-Instanzeinfügungen zu filtern:
gcloud eventarc triggers create gce-vm-labeler-trigger \
--location={{{project_0.default_region|Region}}} \
--destination-run-service=gce-vm-labeler \
--destination-run-region={{{project_0.default_region|Region}}} \
--event-filters="type=google.cloud.audit.log.v1.written" \
--event-filters="serviceName=compute.googleapis.com" \
--event-filters="methodName=beta.compute.instances.insert" \
--service-account=$PROJECT_NUMBER-compute@developer.gserviceaccount.com
Hinweis: Obwohl der Trigger der Audit-Log-Funktion sofort erstellt wird, kann es bis zu 10 Minuten dauern, bis Trigger vollständig funktionieren.
Klicken Sie auf Fortschritt prüfen.
Cloud-Audit-Logs-Funktion erstellen
Test
Um Ihre Audit-Log-Funktion zu testen, müssen Sie in der Cloud Console eine
Compute Engine-VM erstellen. (Sie können VMs auch mit
gcloud erstellen. Es scheinen dadurch jedoch keine Audit-Logs
generiert zu werden.)
-
Gehen Sie im Navigationsmenü zu
Compute Engine > VM-Instanzen.
-
Klicken Sie auf Instanz erstellen, legen Sie den
Namen der Instanz als instance-1 und die
Zone als
fest.
-
Übernehmen Sie für alle anderen Felder die Standardeinstellungen und
klicken Sie auf Erstellen.
Sobald die VM erstellt wurde, sollte für die VM in der Cloud Console im
Bereich Allgemeine Informationen das hinzugefügte Label
creator angezeigt werden.

- Überprüfen Sie das Label mit dem folgenden Befehl:
gcloud compute instances describe instance-1 --zone {{{project_0.default_zone | "Zone"}}}
Sie sollten in der Ausgabe das Label wie im folgenden Beispiel sehen.
Ausgabebeispiel:
...
labelFingerprint: ULU6pAy2C7s=
labels:
creator: student-02-19b599a0f901
...
Klicken Sie auf Fortschritt prüfen.
VM-Instanz erstellen
-
Führen Sie den folgenden Befehl aus, um die VM zu löschen. Geben Sie bei
Aufforderung
Y zur Bestätigung ein.
gcloud compute instances delete instance-1 --zone {{{project_0.default_zone | "Zone"}}}
Aufgabe 5: Verschiedene Versionen bereitstellen
Cloud Run Functions unterstützt mehrere Versionen Ihrer Funktionen. So können
Sie Traffic auf verschiedene Versionen aufteilen und Ihre Funktion auf eine
frühere Version zurücksetzen. In diesem Abschnitt stellen Sie zwei Versionen
Ihrer Cloud Run-Funktion bereit.
Erstellen
-
Führen Sie den folgenden Befehl aus, um den Ordner und die Dateien für die
App zu erstellen und den Ordner zu öffnen:
mkdir ~/hello-world-colored && cd $_
touch main.py
touch requirements.txt
-
Fügen Sie in der Datei
hello-world-colored/main.py den
folgenden Code mit einer Python-Funktion ein. Die Funktion liest eine
Umgebungsvariable für die Farbe aus und gibt Hello World in
dieser Hintergrundfarbe zurück.
import os
color = os.environ.get('COLOR')
def hello_world(request):
return f'<body style="background-color:{color}"><h1>Hello World!</h1></body>'
Bereitstellen
-
Führen Sie den folgenden Befehl aus, um die erste Version der Funktion mit
einem orangefarbenen Hintergrund bereitzustellen:
COLOR=orange
gcloud run deploy hello-world-colored \
--source . \
--function hello_world \
--base-image python311 \
--region {{{project_0.default_region|Region}}} \
--allow-unauthenticated \
--update-env-vars COLOR=$COLOR \
--max-instances 1
Wenn Sie die Funktion jetzt durch Öffnen der Dienst-URL (die URI-Ausgabe des
zuvor ausgeführten Bereitstellungsbefehls) in Ihrem Browser testen, sollte
Hello World mit einem orangefarbenen Hintergrund angezeigt
werden:

-
Rufen Sie in der Console die Seite Cloud Run auf und
klicken Sie auf den Dienst hello-world-colored.
-
Klicken Sie auf
Neue Überarbeitung bearbeiten und bereitstellen.
-
Lassen Sie alle Standardeinstellungen unverändert, scrollen Sie nach unten
und wählen Sie den Tab Variablen und Secrets aus.
Aktualisieren Sie im Bereich Umgebungsvariablen die
Umgebungsvariable COLOR auf yellow.

- Klicken Sie auf Bereitstellen.
Da dies die neueste Version ist, sollten Sie beim Testen der Funktion durch
Öffnen der Dienst-URL in Ihrem Browser Hello World mit einem
gelben Hintergrund sehen:

Klicken Sie auf Fortschritt prüfen.
Verschiedene Versionen bereitstellen
Aufgabe 6: Mindestanzahl von Instanzen einrichten
In Cloud Run Functions können Sie eine Mindestanzahl von Funktionsinstanzen
festlegen, die einsatzbereit sind und Anfragen verarbeiten können. Dies ist
nützlich, um die Anzahl der Kaltstarts zu begrenzen. In diesem Abschnitt
stellen Sie eine Funktion mit langsamer Initialisierung bereit. Sie beobachten
ein Kaltstartproblem. Sie stellen dann die Funktion mit dem
Mindestinstanzwert 1 bereit, um den Kaltstart zu vermeiden.
Erstellen
-
Führen Sie den folgenden Befehl aus, um den Ordner und die Dateien für die
App zu erstellen und den Ordner zu öffnen:
mkdir ~/min-instances && cd $_
touch main.go
touch go.mod
-
Fügen Sie in der Datei
min-instances/main.go den folgenden Code
hinzu. Dieser Go-Dienst hat eine init-Funktion, die 10 Sekunden
lang in den Ruhemodus wechselt, um eine lange Initialisierung zu simulieren.
Er verfügt auch über eine HelloWorld-Funktion, die auf
HTTP-Aufrufe reagiert:
package p
import (
"fmt"
"net/http"
"time"
)
func init() {
time.Sleep(10 * time.Second)
}
func HelloWorld(w http.ResponseWriter, r *http.Request) {
fmt.Fprint(w, "Slow HTTP Go in GCF 2nd gen!")
}
-
Fügen Sie in der Datei
min-instances/go.mod den folgenden Code
hinzu. Damit werden der Modulpfad und die Go-Sprachversion festgelegt:
module example.com/mod
go {{{project_0.startup_script.go_version | 1.26}}}
Bereitstellen
-
Führen Sie den folgenden Befehl aus, um die erste Version der Funktion mit
dem Standardwert für die Mindestanzahl von Instanzen (0) bereitzustellen:
gcloud run deploy slow-function \
--source . \
--function HelloWorld \
--base-image {{{project_0.startup_script.go_gcp_runtime | go126}}} \
--region {{{project_0.default_region|Region}}} \
--allow-unauthenticated \
--max-instances 4
- Testen Sie die Funktion mit diesen Befehlen:
SLOW_URL="$(gcloud run services describe slow-function --region {{{project_0.default_region|Region}}} --format 'value(status.url)')"
curl $SLOW_URL
Beim ersten Aufruf sollte es zu einer Verzögerung von 10 Sekunden (Kaltstart)
kommen, bevor die Meldung angezeigt wird. Weitere Aufrufe sollten sofort
zurückgegeben werden:
Slow HTTP Go in GCF 2nd gen!
Mindestinstanzen festlegen
Um den Kaltstart bei der ersten Anfrage zu vermeiden, stellen Sie die Funktion
mit dem Flag --min-instances, festgelegt auf den Wert 1, noch
einmal bereit:
-
Rufen Sie in der Console die Seite Cloud Run auf und
klicken Sie auf den Dienst slow-function.
-
Klicken Sie auf
Neue Überarbeitung bearbeiten und bereitstellen.
-
Legen Sie im Bereich Versionsskalierung für
Mindestanzahl von Instanzen den Wert 1 und
für Maximale Anzahl von Instanzen den Wert 4
fest.
-
Übernehmen Sie für alle anderen Felder die Standardeinstellungen und
klicken Sie auf Bereitstellen.
Test
-
Führen Sie den folgenden Befehl aus, um die Funktion noch einmal zu testen:
curl $SLOW_URL
Bei der ersten Anfrage sollte es nicht mehr zu einer Verzögerung von
10 Sekunden kommen. Das Kaltstartproblem für den ersten Aufruf (nach langer
Zeit ohne Aufrufe) wurde dank der Mindestanzahl von Instanzen behoben! Weitere
Informationen finden Sie unter
Mindestanzahl von Instanzen für Dienste festlegen.
Klicken Sie auf Fortschritt prüfen.
Mindestanzahl von Instanzen einrichten
Aufgabe 7: Funktion mit Nebenläufigkeit erstellen
In Cloud Run Functions verarbeitet eine Funktionsinstanz standardmäßig nur
eine Anfrage auf einmal. Sie können jedoch festlegen, wie viele gleichzeitige
Anfragen eine Instanz parallel verarbeiten darf. Dies kann auch nützlich sein,
um Kaltstarts zu vermeiden, da für jede parallele Anfrage keine neue
Funktionsinstanz erstellt werden muss.
In diesem Abschnitt verwenden Sie die Funktion mit langsamer Initialisierung
aus dem vorherigen Schritt. Sie senden 10 Anfragen und beobachten wieder ein
Kaltstartproblem, da zur Verarbeitung der Anfragen neue Funktionsinstanzen
erstellt werden müssen.
Um das Kaltstartproblem zu beheben, stellen Sie eine weitere Funktion mit
einem Nebenläufigkeitswert von 100 bereit. Sie stellen fest, dass die
10 Anfragen jetzt nicht mehr zu Kaltstarts führen und eine einzelne
Funktionsinstanz alle Anfragen verarbeiten kann.
Ohne Nebenläufigkeit testen
-
Installieren Sie
hey mit dem folgenden Befehl in Cloud Shell:
sudo apt install hey
-
Führen Sie den folgenden Befehl aus, um die URL der Funktion abzurufen und
als Umgebungsvariable zu speichern:
SLOW_URL=$(gcloud run services describe slow-function --region {{{project_0.default_region|Region}}} --format="value(status.url)")
-
Verwenden Sie das Open-Source-Benchmarking-Tool
hey, um 10 gleichzeitige Anfragen an die langsame Funktion zu senden:
hey -n 10 -c 10 $SLOW_URL
In der Ausgabe von hey sollten Sie sehen, dass einige Anfragen
lange dauern.
Ausgabe:
Summary:
Total: 10.9053 secs
Slowest: 10.9048 secs
Fastest: 0.4439 secs
Average: 9.7930 secs
Requests/sec: 0.9170
Total data: 310 bytes
Size/request: 31 bytes
Response time histogram:
0.444 [1] |■■■■
1.490 [0] |
2.536 [0] |
3.582 [0] |
4.628 [0] |
5.674 [0] |
6.720 [0] |
7.767 [0] |
8.813 [0] |
9.859 [0] |
10.905 [9] |■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■
Das liegt daran, dass mehr Funktionsinstanzen erstellt werden, um die Anfragen
zu verarbeiten. Wenn Sie die Anzahl der aktiven Instanzen für die Funktion
prüfen, sollten Sie auch sehen, dass zu einem bestimmten Zeitpunkt mehr als
eine Instanz erstellt wurde, was das Kaltstartproblem verursacht.
-
Führen Sie den folgenden Befehl aus, um die Funktion zu löschen. Geben Sie
bei Aufforderung
Y zur Bestätigung ein:
gcloud run services delete slow-function --region {{{project_0.default_region | "Region"}}}
Bereitstellen
-
Führen Sie den folgenden Befehl aus, um eine neue Funktion bereitzustellen,
die mit der vorherigen Funktion identisch ist. Nach der Bereitstellung
können Sie die Nebenläufigkeit erhöhen:
gcloud run deploy slow-concurrent-function \
--source . \
--function HelloWorld \
--base-image {{{project_0.startup_script.go_gcp_runtime | go126}}} \
--region {{{project_0.default_region|Region}}} \
--allow-unauthenticated \
--min-instances 1 \
--max-instances 4
Nebenläufigkeit festlegen
Legen Sie nun die Nebenläufigkeit des zugrunde liegenden Cloud Run-Dienstes
für die Funktion auf 100 fest (maximal 1.000). So wird dafür
gesorgt, dass von einer einzelnen Funktionsinstanz mindestens 100 Anfragen
verarbeitet werden können.
-
Rufen Sie im Navigationsmenü Cloud Run auf.
-
Klicken Sie auf den Dienst slow-concurrent-function.
-
Klicken Sie auf
Neue Überarbeitung bearbeiten und bereitstellen.
-
Legen Sie im Bereich Ressourcen für
CPU den Wert 1 fest.
-
Legen Sie unter Anfragen für
Maximale Anzahl gleichzeitiger Anfragen pro Instanz den
Wert 100 fest.
-
Legen Sie unter Versionsskalierung für
Maximale Anzahl von Instanzen den Wert 4
fest.
-
Übernehmen Sie für alle anderen Felder die Standardeinstellungen und
klicken Sie auf Bereitstellen.
Mit Nebenläufigkeit testen
-
Nachdem Ihre Funktion bereitgestellt wurde, führen Sie den folgenden Befehl
aus, um die URL der neuen Funktion abzurufen und als Umgebungsvariable zu
speichern:
SLOW_CONCURRENT_URL=$(gcloud run services describe slow-concurrent-function --region {{{project_0.default_region|Region}}} --format="value(status.url)")
-
Verwenden Sie jetzt
hey, um 10 gleichzeitige Anfragen zu senden:
hey -n 10 -c 10 $SLOW_CONCURRENT_URL
In der Ausgabe von hey sollten Sie sehen, dass alle Anfragen
schnell verarbeitet werden.
Ausgabe:
Summary:
Total: 0.0652 secs
Slowest: 0.0651 secs
Fastest: 0.0619 secs
Average: 0.0636 secs
Requests/sec: 153.3751
Total data: 280 bytes
Size/request: 28 bytes
Response time histogram:
0.062 [1] |■■■■■■■■■■■■■■■■■■■■
0.062 [1] |■■■■■■■■■■■■■■■■■■■■
0.063 [0] |
0.063 [0] |
0.063 [0] |
0.063 [1] |■■■■■■■■■■■■■■■■■■■■
0.064 [2] |■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■
0.064 [2] |■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■
0.064 [2] |■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■
0.065 [0] |
0.065 [1] |■■■■■■■■■■■■■■■■■■■■
Eine einzelne Funktionsinstanz konnte alle Anfragen verarbeiten und das
Kaltstartproblem wurde dank der erhöhten Nebenläufigkeit behoben. Weitere
Informationen finden Sie in der Dokumentation zur
Nebenläufigkeit.
Klicken Sie auf Fortschritt prüfen.
Funktion mit Nebenläufigkeit erstellen
Das wars! Sie haben das Lab erfolgreich abgeschlossen.
In diesem Lab haben Sie mehrere Cloud Run Functions bereitgestellt, die auf
HTTP-Aufrufe, Cloud Storage-Ereignisse und Cloud-Audit-Logs reagiert haben.
Anschließend haben Sie mehrere Versionen der Cloud Run-Dienste bereitgestellt,
in denen die Funktionen ausgeführt werden, und Nebenläufigkeitswerte
festgelegt. Außerdem haben Sie durch die Mindestanzahl an Instanzen Kaltstarts
vermieden.
Weitere Informationen
Weitere Informationen zu Cloud Run Functions finden Sie hier:
Google Cloud-Schulungen und -Zertifizierungen
In unseren Schulungen erfahren Sie alles zum optimalen Einsatz unserer Google Cloud-Technologien und können sich entsprechend zertifizieren lassen. Unsere Kurse vermitteln technische Fähigkeiten und Best Practices, damit Sie möglichst schnell mit Google Cloud loslegen und Ihr Wissen fortlaufend erweitern können. Wir bieten On-Demand-, Präsenz- und virtuelle Schulungen für Anfänger wie Fortgeschrittene an, die Sie individuell in Ihrem eigenen Zeitplan absolvieren können. Mit unseren Zertifizierungen weisen Sie nach, dass Sie Experte im Bereich Google Cloud-Technologien sind.
Anleitung zuletzt am 19. August 2026 aktualisiert
Lab zuletzt am 19. August 2026 getestet
© 2026 Google LLC. Alle Rechte vorbehalten. Google und das Google-Logo sind Marken von Google LLC. Alle anderen Unternehmens- und Produktnamen können Marken der jeweils mit ihnen verbundenen Unternehmen sein.