Écrire des fonctions Cloud Run

Les fonctions Cloud Run prennent en charge la rédaction de code source dans divers langages de programmation. L'environnement d'exécution du langage que vous choisissez et le type de fonction que vous souhaitez écrire déterminent la structure de votre code et l'implémentation de la fonction. Cette page présente les types de fonctions Cloud Run et les attentes concernant le code source.

Types de fonctions Cloud Run

Il existe deux types de fonctions Cloud Run :

Utilisez une fonction HTTP lorsque vous avez besoin que votre fonction dispose d'un point de terminaison d'URL et réponde aux requêtes HTTP, par exemple pour les webhooks. Utilisez une fonction basée sur des événements lorsqu'elle doit être déclenchée directement en réponse à des événements au sein de votre projet Google Cloud, tels que des messages sur un sujet Pub/Sub ou des modifications dans un bucket Cloud Storage.

Structure du répertoire source

Pour que les fonctions Cloud Run puissent localiser votre définition de fonction, chaque environnement d'exécution de langage comporte des exigences concernant la structuration de votre code source. La structure du répertoire de base d'une fonction dans chaque environnement d'exécution est illustrée ci-dessous.

Node.js

La structure du répertoire de base des fonctions Node.js est la suivante :

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

Par défaut, les fonctions Cloud Run tentent de charger le code source à partir d'un fichier nommé index.js à la racine du répertoire de votre fonction. Pour spécifier un autre fichier source principal, utilisez le champ main dans votre fichier package.json.

Votre fichier package.json doit également inclure le framework des fonctions pour Node.js en tant que dépendance :

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

Le code de votre fichier principal doit définir le point d'entrée de votre fonction et peut importer d'autres codes et modules Node.js normalement. Le fichier principal peut également définir plusieurs points d'entrée de fonction pouvant être déployés séparément.

Python

La structure du répertoire de base des fonctions Python est la suivante :

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

Les fonctions Cloud Run chargent le code source à partir d'un fichier nommé main.py à la racine du répertoire de votre fonction. Votre fichier principal doit être nommé main.py.

Votre fichier requirements.txt doit inclure le framework des fonctions pour Python en tant que dépendance :

functions-framework==3.*

Le code de votre fichier main.py doit définir le point d'entrée de votre fonction et peut importer d'autres codes et dépendances externes normalement. Le fichier main.py peut également définir plusieurs points d'entrée de fonction pouvant être déployés séparément.

Go

La structure du répertoire de base des fonctions Go est la suivante :

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

Votre fonction doit figurer dans un package Go, à la racine de votre projet. Le package et ses fichiers sources peuvent porter n'importe quel nom, sauf que votre fonction ne peut pas se trouver dans package main. Si vous avez besoin d'un package main, par exemple pour les tests locaux, vous pouvez en créer un dans un sous-répertoire :

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

Votre fichier go.mod doit inclure le framework des fonctions pour Go en tant que dépendance :

module example.com/my-module

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

Le code de votre package racine doit définir votre point d'entrée de la fonction et peut importer normalement d'autres codes à partir de sous-packages et de dépendances. Votre package peut également définir plusieurs points d'entrée de fonction pouvant être déployés séparément.

Java

La structure du répertoire de base des fonctions Java est la suivante :

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

Vos fichiers source Java doivent se trouver dans le répertoire src/main/java/ et peuvent porter n'importe quel nom. Si vos fichiers source déclarent un package, ajoutez un répertoire supplémentaire sous src/main/java avec le nom du package :

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

Nous vous recommandons de placer les tests associés dans un sous-répertoire src/test/java/.

Votre fichier pom.xml doit inclure le framework des fonctions pour Java en tant que dépendance :

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

Le code de vos fichiers source doit définir votre point d'entrée de la fonction et peut importer d'autres codes et dépendances externes normalement. Vos fichiers sources peuvent également définir plusieurs points d'entrée de fonctions pouvant être déployés séparément.

C#

La structure du répertoire de base des fonctions .NET est la suivante :

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

Vous pouvez structurer vos projets comme vous le feriez avec tout autre code source .NET. Vous pouvez attribuer n'importe quel nom aux fichiers sources.

Votre fichier de projet doit inclure le framework des fonctions pour .NET en tant que dépendance :

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

Le code de vos fichiers source doit définir votre point d'entrée de la fonction et peut importer d'autres codes et dépendances externes normalement. Vos fichiers sources peuvent également définir plusieurs points d'entrée de fonctions pouvant être déployés séparément.

Vous pouvez également utiliser le package de modèles des fonctions Cloud Run pour .NET pour générer les fichiers requis.

Ruby

La structure de répertoires de base des fonctions Ruby est la suivante:

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

Les fonctions Cloud Run chargent le code source à partir d'un fichier nommé app.rb à la racine du répertoire de votre fonction. Votre fichier principal doit être nommé app.rb.

Votre fichier Gemfile doit inclure le framework des fonctions pour Ruby en tant que dépendance :

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

Le code de votre fichier app.rb doit définir le point d'entrée de votre fonction et peut importer d'autres codes et dépendances externes normalement. Le fichier app.rb peut également définir plusieurs points d'entrée de fonction pouvant être déployés séparément.

PHP

La structure du répertoire de base des fonctions PHP est la suivante :

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

Les fonctions Cloud Run chargent le code source à partir d'un fichier nommé index.php à la racine du répertoire de votre fonction. Votre fichier principal doit être nommé index.php.

Votre fichier composer.json doit inclure le framework des fonctions pour PHP en tant que dépendance :

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

Le code de votre fichier index.php doit définir le point d'entrée de votre fonction et peut importer d'autres codes et dépendances externes normalement. Le fichier index.php peut également définir plusieurs points d'entrée de fonction pouvant être déployés séparément.

Si vous envisagez de regrouper plusieurs fonctions dans un seul projet, sachez qu'il est possible qu'elles partagent le même ensemble de dépendances. Cependant, certaines fonctions ne nécessitent pas l'ensemble des dépendances.

Dans la mesure du possible, nous vous recommandons de diviser les codebases multifonctions volumineux et de placer chaque fonction dans son propre répertoire de premier niveau, comme indiqué ci-dessus, avec ses propres fichiers de configuration source et de projet. Cette approche minimise le nombre de dépendances requises par une fonction particulière et réduit la quantité de mémoire dont votre fonction a besoin.

Point d'entrée de la fonction

Votre code source doit définir un point d'entrée pour votre fonction, qui est le code particulier exécuté lorsque la fonction Cloud Run est appelée. Vous spécifiez ce point d'entrée lorsque vous déployez votre fonction.

La façon dont vous définissez le point d'entrée dépend de l'environnement d'exécution du langage que vous utilisez. Pour certaines langues, le point d'entrée est une fonction, tandis que pour d'autres, il s'agit d'une classe. Pour en savoir plus sur la définition des points d'entrée et la mise en œuvre des fonctions Cloud Run dans différents langages, consultez les pages Écrire des fonctions HTTP et Écrire des fonctions basées sur des événements.

Dépendances

Vous pouvez gérer les dépendances à l'aide d'outils standards pour chaque environnement d'exécution. Pour en savoir plus, consultez la page appropriée :

Étapes suivantes