Um die Suche zu vereinfachen und die Dokumentation zu verbessern, teilen wir die Dokumentation der 1. Generation und der 2. Generation in separate Gruppen ein.

Funktionen mit Functions Framework ausführen

Cloud Functions verwendet die Open-Source-Bibliotheken Functions Framework, um Ihre bereitgestellten Funktionen in einer nichtflüchtigen HTTP-Anwendung zu verpacken.

Das Functions Framework kann auch auf jeder anderen Plattform ausgeführt werden, die die Sprache selbst unterstützt, darunter lokale Computer, lokale Server, Compute Engine und Cloud Run

Abhängigkeiten installieren

Installieren Sie im Verzeichnis der Funktion die Functions Framework-Bibliothek für Ihre Sprache:

Weitere Informationen finden Sie in der Java Functions Framework-Bibliothek.

Node.js

npm install --save-dev @google-cloud/functions-framework

Python

pip install functions-framework

Go

go install github.com/GoogleCloudPlatform/functions-framework-go/funcframework

Java

Maven

Wenn Sie Maven verwenden, fügen Sie der Datei pom.xml Folgendes hinzu:

<dependency>
  <groupId>com.google.cloud.functions</groupId>
  <artifactId>functions-framework-api</artifactId>
  <version>1.1.0</version>
  <scope>provided</scope>
</dependency>

Gradle

Wenn Sie Gradle verwenden, fügen Sie der Datei build.gradle Folgendes hinzu:

dependencies {
  // Every function needs this dependency to get the Functions Framework API.
  compileOnly 'com.google.cloud.functions:functions-framework-api:1.1.0'

  // To run function locally using Functions Framework's local invoker
  invoker 'com.google.cloud.functions.invoker:java-function-invoker:1.3.1'
}

C#

Die folgenden Befehle verwenden .NET-Vorlagen, um eine neue .NET Cloud Functions-Codebasis mit der .NET Functions Framework-Bibliothek als Abhängigkeit zu erstellen:

# HTTP functions
dotnet new gcf-http

# CloudEvent functions
dotnet new gcf-event

Ruby

In Ruby muss das Functions Framework den Funktionsabhängigkeiten hinzugefügt werden, um sie in Cloud Functions bereitstellen zu können:

bundle add functions_framework

PHP

composer require google/cloud-functions-framework

Functions Framework konfigurieren

Bevor Sie eine Funktion mit dem Functions Framework ausführen, müssen Sie den Typ und den Namen der Funktion angeben, die Sie ausführen möchten. Diese Attribute können entweder als Flags in der Befehlszeile oder als Umgebungsvariablen angegeben werden.

Unterstützte Funktionstypen

Gemeinsam unterstützt das Functions Framework alle drei Funktionstypen, die von Cloud Functions unterstützt werden. Alle Sprachlaufzeiten unterstützen http und entweder event oder cloudevent.

Funktionstyp	Signaturtyp	Beschreibung	Unterstützende Laufzeiten
Durch HTTP ausgelöste Funktionen	`http`	Funktionen, die HTTP-Anfragen empfangen und beantworten.	Alle Laufzeiten
Hintergrundfunktionen	`event`	Cloud Functions-spezifische Ereignisformat	Nur 1. Generation: Node.js, Python, Go, Java
CloudEvent-Funktionen	`cloudevent`	Branchenstandard-Ereignisformat	2. Generation: Alle Laufzeiten 1. Generation: .NET, Ruby, PHP

Auszuführende Funktion angeben

Bevor Sie eine Funktion mit dem Functions Framework ausführen, müssen Sie festlegen, welche Funktion im Code ausgeführt werden soll. Für die meisten Sprachen können Sie dafür den Methodennamen der Zielfunktion angeben, wie in den folgenden Tabellen dargestellt. (Ausnahmen zu dieser Regel, z. B. Java und .NET, finden Sie ebenfalls unten.)

Anleitungen für die einzelnen Sprachen

Die folgende Tabelle enthält eine Liste der Konfigurationsoptionen, die von den einzelnen Sprachen unterstützt werden.

Node.js

Befehlszeilenargument	Umgebungsvariable	Beschreibung
`--port`	`PORT`	Der Port, auf dem Anfragen überwacht werden sollen. (Standardeinstellung: `8080`)
`--target`	`FUNCTION_TARGET`	Der Name der `export`ierten Funktion, die aufgerufen werden soll. (Standardeinstellung: `function`)
`--signature-type`	`FUNCTION_SIGNATURE_TYPE`	Der von der Funktion verwendete Signaturtyp. Kann `http` (Standardeinstellung), `event` oder `cloudevent` sein.

Python

Befehlszeilenargument	Umgebungsvariable	Beschreibung
`--port`	`PORT`	Der Port, auf dem Anfragen überwacht werden sollen. (Standardeinstellung: `8080`)
`--target`	`FUNCTION_TARGET`	Der Name der `export`ierten Funktion, die aufgerufen werden soll. (Standardeinstellung: `function`)
`--signature-type`	`FUNCTION_SIGNATURE_TYPE`	Der von der Funktion verwendete Signaturtyp. Kann `http` (Standardeinstellung), `event` oder `cloudevent` sein.

Go

Umgebungsvariable	Beschreibung
`PORT`	Der Port, auf dem Anfragen überwacht werden sollen. (Standard: `8080`)

Java

Name des Arguments	Umgebungsvariable	Beschreibung
`run.port`	`PORT`	Der Port, auf dem Anfragen überwacht werden sollen. (Standardeinstellung: `8080`)
`run.functionTarget`	`FUNCTION_TARGET`	Der Name der `export`ierten Funktion, die aufgerufen werden soll. (Standardeinstellung: `function`)

C#

Befehlszeilenargument	Umgebungsvariable	Beschreibung
`--port`	`PORT`	Der Port, auf dem Anfragen überwacht werden sollen. (Standardeinstellung: `8080`)
`--target` (oder nur Argument)	`FUNCTION_TARGET`	Der classname der aufzurufenden Funktion. (Standardeinstellung: `function`)

Ruby

Befehlszeilenargument	Umgebungsvariable	Beschreibung
`--port`	`PORT`	Der Port, auf dem Anfragen überwacht werden sollen. (Standardeinstellung: `8080`)
`--target`	`FUNCTION_TARGET`	Der Name der `export`ierten Funktion, die aufgerufen werden soll. (Standardeinstellung: `function`)

PHP

Umgebungsvariable	Beschreibung
`FUNCTION_TARGET`	Der Name der Funktion, die aufgerufen werden soll. (Standard: `function`)
`FUNCTION_SIGNATURE_TYPE`	Der von der Funktion verwendete Signaturtyp. Kann `http` (Standardeinstellung), `event` oder `cloudevent` sein.

Folgen Sie der Anleitung unten, um das Functions Framework zu konfigurieren und auszuführen:

Node.js

Mit dem Node.js Functions Framework können Sie den Namen und den Signaturtyp der Funktion als Befehlszeilenargumente oder Umgebungsvariablen angeben.

Sie können diese Werte auch in der Build-Datei package.json angeben. Dazu fügen Sie ein start-Skript mit den erforderlichen Befehlszeilenargumenten hinzu, wie im folgenden Beispiel gezeigt.

"scripts": {
  "start": "npx functions-framework --target=YOUR_FUNCTION_NAME [--signature-type=YOUR_SIGNATURE_TYPE]"
}

Ersetzen Sie YOUR_FUNCTION_NAME durch den Methodennamen Ihrer Funktion und YOUR_SIGNATURE_TYPE (falls zutreffend) durch den Signaturtyp der Funktion, wie in der Tabelle oben dargestellt.

Python

Mit dem Python Functions Framework können Sie den Namen und den Signaturtyp der Funktion als Befehlszeilenargumente oder Umgebungsvariablen angeben. Befehlszeilenargumente müssen beim Ausführen des Frameworks angegeben werden.

Go

Das Go Functions Framework verwendet funcframework.RegisterHTTPFunctionContext, um das Funktionsziel und den Signaturtyp anzugeben.

Java

Das Java Functions Framework akzeptiert Konfigurationsdaten aus drei verschiedenen Quellen in der folgenden Prioritätsreihenfolge (spezifischste zuerst):

Befehlszeilenargumente
Buildfiles
Umgebungsvariablen

Befehlszeilenargumente

Maven

Zum Angeben der auszuführenden Funktion fügen Sie den mvn-Befehlen das folgende Befehlszeilen-Flag (Befehlszeile) hinzu:

-Drun.functionTarget=YOUR_FUNCTION_NAME

Sie können den Zielport auch angeben, indem Sie das folgende Befehlszeilen-Flag auf ähnliche Weise hinzufügen:

-Drun.port=12345

Gradle

Die Befehlszeilen-Flags von Gradle sind fast identisch mit denen von Maven. Der einzige Unterschied zu Gradle besteht darin, dass das vorangestellte -D in jedem Flag durch ein -P ersetzt wird, wie im folgenden Beispiel gezeigt:

# Maven version
-Drun.functionTarget=...

# Gradle version
-Prun.functionTarget=...

Buildfiles

Sie können auch die Funktion angeben, die Sie in der Build-Datei Ihres Projekts ausführen möchten. Obwohl Maven und Gradle ähnliche Befehlszeilen-Flags haben, unterscheiden sich ihre Buildfile-Klauseln erheblich.

Maven

Maven-Build-Dateien haben den Namen pom.xml. Fügen Sie der Datei die folgende Klausel hinzu, um eine Zielfunktion anzugeben:

<plugin>
  <groupId>com.google.cloud.functions</groupId>
  <artifactId>function-maven-plugin</artifactId>
  <version>0.11.0</version>
  <configuration>
    <functionTarget>functions.HelloWorld</functionTarget>
  </configuration>
</plugin>

Ersetzen Sie <functionTarget> durch den Klassennamen der Funktion. Beispiel: Eine Funktion im Paket functions mit dem Klassennamen HelloCloudFunctions hätte den Klassennamen functions.HelloCloudFunctions. Dies bezieht sich auf die übergeordnete Build-Datei, entweder pom.xml oder build.gradle).

Gradle

Gradle-Build-Dateien haben den Namen build.gradle. Fügen Sie dieser Datei die folgende Klausel hinzu, um eine Zielfunktion anzugeben:

// Register a "runFunction" task to run the function locally
tasks.register("runFunction", JavaExec) {
  main = 'com.google.cloud.functions.invoker.runner.Invoker'
  classpath(configurations.invoker)
  inputs.files(configurations.runtimeClasspath, sourceSets.main.output)
  args(
    '--target', project.findProperty('run.functionTarget') ?: '',
    '--port', project.findProperty('run.port') ?: 8080
  )
  doFirst {
    args('--classpath', files(configurations.runtimeClasspath, sourceSets.main.output).asPath)
  }
}

C#

Wenn Sie Ihr Projekt mit dotnet new und einer der oben genannten Vorlagen erstellen, erkennt das .NET Functions Framework die Funktion automatisch.

Wenn Ihr Projekt mehrere Funktionen enthält, lesen Sie den Abschnitt Framework ausführen, um Informationen zum Ausführen einer bestimmten Funktion zu erhalten.

Ruby

Mit dem Ruby Functions Framework können Sie den Namen und den Signaturtyp der Funktion als Befehlszeilenargumente oder Umgebungsvariablen angeben. Befehlszeilenargumente müssen beim Ausführen des Frameworks angegeben werden.

PHP

Im PHP Functions-Framework können Sie Umgebungsvariablen als Befehlszeilenargumente angeben.

Sie können diese Werte auch in der Build-Datei composer.json angeben, indem Sie ein start-Skript hinzufügen, wie im folgenden Beispiel gezeigt.

"scripts": {
   "start": [
       "Composer\\Config::disableProcessTimeout",
       "FUNCTION_TARGET=YOUR_FUNCTION_NAME php -S localhost:${PORT:-8080} vendor/bin/router.php"
    ]
}

Ersetzen Sie YOUR_FUNCTION_NAME durch den Namen Ihrer Funktion und YOUR_SIGNATURE_TYPE (falls zutreffend) durch den Signaturtyp der Funktion, wie in der Tabelle oben dargestellt.

Functions Framework ausführen

Verwenden Sie den folgenden Befehl, um die Funktion mit Functions Framework auszuführen. Standardmäßig ist die Funktion unter localhost:8080 zugänglich, sofern Sie nicht explizit einen PORT-Wert angeben.

Node.js

npm start

Python

functions-framework --target=YOUR_FUNCTION_NAME

Ersetzen Sie YOUR_FUNCTION_NAME durch den Methodennamen der Funktion.

Go

cd cmd
go build
./cmd

Java

Maven

Verwenden Sie den folgenden Befehl, um eine in pom.xml angegebene Funktion auszuführen:

mvn function:run

Verwenden Sie den folgenden Befehl, um eine in einem Befehlszeilenargument angegebene Funktion auszuführen:

mvn function:run -Drun.functionTarget=YOUR_FUNCTION_NAME

Ersetzen Sie YOUR_FUNCTION_NAME durch den Klassennamen der Funktion.

Gradle

Verwenden Sie den folgenden Befehl, um eine in build.gradle angegebene Funktion auszuführen:

./gradlew runFunction

Verwenden Sie den folgenden Befehl, um eine in einem Befehlszeilenargument angegebene Funktion auszuführen:

./gradlew runFunction -Prun.functionTarget=YOUR_FUNCTION_NAME

Ersetzen Sie YOUR_FUNCTION_NAME durch den Klassennamen der Funktion.

C#

Verwenden Sie den folgenden Befehl, um die Funktion auszuführen, wenn genau eine Funktion im aktuellen .NET-Projekt vorhanden ist. Dies ist die Standardstruktur für Projekte, die aus einer Vorlage erstellt wurden.

dotnet run

Wenn Ihr .NET-Projekt mehrere Funktionen enthält, verwenden Sie den folgenden Befehl, um eine bestimmte Funktion auszuführen. Ersetzen Sie YOUR_FUNCTION_CLASSNAME durch den Klassennamen der Funktion, einschließlich des Namespace.

dotnet run YOUR_FUNCTION_CLASSNAME

Wenn Sie mehrere Funktionen gleichzeitig ausführen möchten, müssen Sie mehrere Functions Framework-Instanzen ausführen. Zur Vermeidung von Konflikten zwischen ausgeführten Framework-Instanzen sollte jede Instanz einen anderen Wert für PORT verwenden. Der folgende Befehl zeigt, wie eine Funktion mit einem PORT-Wert von 8080 ausgeführt wird.

dotnet run --target YOUR_FUNCTION_CLASSNAME --port 8080

Ruby

bundle exec functions-framework-ruby --target YOUR_FUNCTION_NAME

Ersetzen Sie YOUR_FUNCTION_NAME durch den Methodennamen der Funktion.

PHP

export FUNCTION_TARGET=YOUR_FUNCTION_NAME
php -S localhost:8080 vendor/bin/router.php

Ersetzen Sie YOUR_FUNCTION_NAME durch den Namen der Funktion.

Funktion aufrufen

Eine Anleitung zum Interagieren mit der lokal ausgeführten Funktion finden Sie auf der Seite Lokale Funktionen aufrufen.

Bereinigen

Wenn Sie die Ausführung der Funktion abgeschlossen haben, beenden Sie die ausgeführte Framework-Instanz. Drücken Sie dazu Strg + C.