Cloud Run-Funktionen schreiben

Cloud Run-Funktionen unterstützen das Schreiben von Quellcode in mehreren Programmiersprachen. Die von Ihnen ausgewählte Sprachlaufzeit und der Typ der Funktion, die Sie schreiben möchten, bestimmen, wie Sie Ihren Code strukturieren und Ihre Funktion implementieren. Auf dieser Seite erhalten Sie einen Überblick über die Arten von Cloud Run-Funktionen und die Erwartungen an den Quellcode.

Arten von Cloud Run-Funktionen

Es gibt zwei Arten von Cloud Run-Funktionen:

Verwenden Sie eine HTTP-Funktion, wenn Ihre Funktion einen URL-Endpunkt haben und auf HTTP-Anfragen antworten muss, z. B. für Webhooks. Verwenden Sie eine ereignisgesteuerte Funktion, wenn Ihre Funktion direkt als Reaktion auf Ereignisse in Ihrem Google Cloud-Projekt ausgelöst werden soll, z. B. Nachrichten in einem Pub/Sub-Thema oder Änderungen in einem Cloud Storage-Bucket.

Struktur des Quellverzeichnisses

Damit Cloud Run-Funktionen Ihre Funktionsdefinition finden können, benötigt jede Sprachlaufzeit Anforderungen zum Strukturieren Ihres Quellcodes. Nachfolgend wird die grundlegende Verzeichnisstruktur für eine Funktion in jeder Laufzeit dargestellt.

Node.js

Die grundlegende Verzeichnisstruktur für Node.js-Funktionen sieht so aus:

.
├── index.js
└── package.json

Standardmäßig versuchen Cloud Run-Funktionen, Quellcode aus einer Datei mit dem Namen index.js im Stammverzeichnis Ihres Funktionsverzeichnisses zu laden. Verwenden Sie das Feld main in der Datei package.json, um eine andere Hauptquelldatei anzugeben.

Die Datei package.json muss auch das Functions Framework für Node.js als Abhängigkeit enthalten:

{
  "main": "index.js",
  "dependencies": {
    "@google-cloud/functions-framework": "^3.0.0"
  }
}

Der Code in der Hauptdatei muss den Funktionseinstiegspunkt definieren und kann anderen Code und Node.js-Module wie gewohnt importieren. Die Hauptdatei kann auch mehrere Funktionseinstiegspunkte definieren, die separat bereitgestellt werden können.

Python

Die grundlegende Verzeichnisstruktur für Python-Funktionen sieht so aus:

.
├── main.py
└── requirements.txt

Cloud Run-Funktionen laden den Quellcode aus einer Datei namens main.py im Stammverzeichnis Ihres Funktionsverzeichnisses. Die Hauptdatei muss main.py heißen.

Die Datei requirements.txt muss das Functions Framework für Python als Abhängigkeit enthalten:

functions-framework==3.*

Der Code in der Datei main.py muss den Funktionseinstiegspunkt definieren und kann anderen Code und externe Abhängigkeiten wie gewohnt importieren. In der Datei main.py können auch mehrere Funktionseinstiegspunkte definiert werden, die separat bereitgestellt werden können.

Go

Die grundlegende Verzeichnisstruktur für Go-Funktionen ist so:

.
├── myfunction.go
└── go.mod

Ihre Funktion muss sich in einem Go-Paket im Stammverzeichnis des Projekts befinden. Das Paket und seine Quelldateien können einen beliebigen Namen haben, aber Ihre Funktion darf sich nicht in package main befinden. Wenn Sie ein main-Paket benötigen, z. B. für lokale Tests, können Sie eines in einem Unterverzeichnis erstellen:

.
├── myfunction.go
├── go.mod
└── cmd/
    └── main.go

Die Datei go.mod muss das Functions Framework für Go als Abhängigkeit enthalten:

module example.com/my-module

require (
  github.com/GoogleCloudPlatform/functions-framework-go v1.5.2
)

Der Code im Root-Paket muss den Funktionseinstiegspunkt definieren und anderen Code aus Unterpaketen und Abhängigkeiten wie gewohnt importieren. Mit dem Paket können auch mehrere Funktionseinstiegspunkte definiert werden, die separat bereitgestellt werden können.

Java

Die grundlegende Verzeichnisstruktur für Java-Funktionen sieht so aus:

.
├── pom.xml
└── src/
    └── main/
        └── java/
            └── MyFunction.java

Ihre Java-Quelldateien müssen sich im Verzeichnis src/main/java/ befinden und einen beliebigen Namen haben. Fügen Sie unter src/main/java ein zusätzliches Verzeichnis mit dem Namen des Pakets hinzu, wenn Ihre Quelldateien ein Paket deklarieren:

.
├── pom.xml
└── src/
    └── main/
        └── java/
            └── mypackage/
                └── MyFunction.java

Wir empfehlen, die zugehörigen Tests in einem Unterverzeichnis src/test/java/ abzulegen.

Die Datei pom.xml muss das Functions Framework für Java als Abhängigkeit enthalten:

...
    <dependency>
      <groupId>com.google.cloud.functions</groupId>
      <artifactId>functions-framework-api</artifactId>
      <version>1.0.4</version>
    </dependency>
...

Der Code in Ihren Quelldateien muss den Funktionseinstiegspunkt definieren und kann anderen Code und externe Abhängigkeiten wie gewohnt importieren. Mit Quelldateien können auch mehrere Funktionseinstiegspunkte definiert werden, die separat bereitgestellt werden können.

C#

Die grundlegende Verzeichnisstruktur für .NET-Funktionen ist folgende:

.
├── MyFunction.cs
└── MyProject.csproj

Sie können Ihre Projekte wie jeden anderen .NET-Quellcode strukturieren. Ihre Quelldateien können einen beliebigen Namen haben.

Ihre Projektdatei muss das Functions Framework für .NET als Abhängigkeit enthalten:

...
    <PackageReference Include="Google.Cloud.Functions.Hosting" Version="1.0.0" />
...

Der Code in Ihren Quelldateien muss den Funktionseinstiegspunkt definieren und kann anderen Code und externe Abhängigkeiten wie gewohnt importieren. Mit Quelldateien können auch mehrere Funktionseinstiegspunkte definiert werden, die separat bereitgestellt werden können.

Sie können auch das Vorlagenpaket für Cloud Run-Funktionen für .NET verwenden, um die erforderlichen Dateien zu generieren.

Ruby

Die grundlegende Verzeichnisstruktur für Ruby-Funktionen sieht so aus:

.
├── app.rb
├── Gemfile
└── Gemfile.lock

Cloud Run-Funktionen laden den Quellcode aus einer Datei namens app.rb im Stammverzeichnis Ihres Funktionsverzeichnisses. Die Hauptdatei muss app.rb heißen.

Die Datei Gemfile muss das Functions Framework für Ruby als Abhängigkeit enthalten:

source "https://rubygems.org"
gem "functions_framework", "~> 1.0"

Der Code in der Datei app.rb muss den Funktionseinstiegspunkt definieren und kann anderen Code und externe Abhängigkeiten wie gewohnt importieren. In der Datei app.rb können auch mehrere Funktionseinstiegspunkte definiert werden, die separat bereitgestellt werden können.

PHP

Die grundlegende Verzeichnisstruktur für PHP-Funktionen sieht so aus:

.
├── index.php
└── composer.json

Cloud Run-Funktionen laden den Quellcode aus einer Datei namens index.php im Stammverzeichnis Ihres Funktionsverzeichnisses. Die Hauptdatei muss index.php heißen.

Die Datei composer.json muss das Functions Framework für PHP als Abhängigkeit enthalten:

{
  "require": {
    "google/cloud-functions-framework": "^1.1"
  }
}

Der Code in der Datei index.php muss den Funktionseinstiegspunkt definieren und kann anderen Code und externe Abhängigkeiten wie gewohnt importieren. In der Datei index.php können auch mehrere Funktionseinstiegspunkte definiert werden, die separat bereitgestellt werden können.

Wenn Sie mehrere Funktionen in einem Projekt gruppieren möchten, beachten Sie, dass jede Funktion möglicherweise dieselben Abhängigkeiten verwendet. Einige der Funktionen benötigen jedoch möglicherweise nicht alle Abhängigkeiten.

Wir empfehlen, möglichst große Codefunktionen mit mehreren Funktionen aufzuteilen und jede Funktion wie oben gezeigt in einem eigenen Verzeichnis der obersten Ebene mit eigenen Quell- und Projektkonfigurationsdateien zu speichern. Dieser Ansatz minimiert die Anzahl der Abhängigkeiten, die für eine bestimmte Funktion erforderlich sind. Das reduziert wiederum den Speicherbedarf für Ihre Funktion.

Funktionseinstiegspunkt

Ihr Quellcode muss einen Einstiegspunkt für Ihre Funktion definieren. Dies ist der bestimmte Code, der beim Aufrufen der Cloud Run-Funktion ausgeführt wird. Sie geben diesen Einstiegspunkt an, wenn Sie die Funktion bereitstellen.

Wie Sie den Einstiegspunkt definieren, hängt von der verwendeten Sprachlaufzeit ab. Für einige Sprachen ist der Einstiegspunkt eine Funktion, bei anderen ist der Einstiegspunkt eine Klasse. Weitere Informationen zum Definieren von Einstiegspunkten und zum Implementieren von Cloud Run-Funktionen in verschiedenen Sprachen finden Sie unter HTTP-Funktionen schreiben und Ereignisgesteuerte Funktionen schreiben.

Abhängigkeiten

Sie können Abhängigkeiten mit Standardtools für jede Laufzeit verwalten. Weitere Informationen finden Sie auf der entsprechenden Seite:

Nächste Schritte