Écrire des fonctions Cloud

Cloud Functions est compatible avec l'écriture de code source dans certains 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 la mise en œuvre de votre fonction. Cette page présente les types de fonctions Cloud et les attentes concernant le code source.

Types de fonctions cloud

Il existe deux types de fonctions Cloud :

Les fonctions HTTP, qui gèrent les requêtes HTTP et utilisent des déclencheurs HTTP. Pour en savoir plus sur la mise en œuvre de fonctions HTTP, consultez la page Écrire des fonctions HTTP.
Les fonctions basées sur des événements, qui gèrent les événements de votre environnement cloud et utilisent des déclencheurs d'événements, comme décrit dans la section Déclencheurs Cloud Functions. Pour en savoir plus sur la mise en œuvre de fonctions basées sur des événements, consultez la page Écrire des fonctions basées sur des événements.

Utilisez une fonction HTTP lorsque vous souhaitez 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 lorsque votre fonction doit être déclenchée directement en réponse à des événements de votre projet Google Cloud, tels que des messages sur un sujet Pub/Sub ou des modifications dans un bucket Cloud Storage.

Structure des répertoires sources

Pour que Cloud Functions trouve la définition de votre fonction, chaque environnement d'exécution de langage a des exigences concernant la structuration de votre code source. La structure de répertoire de base d'une fonction dans chaque environnement d'exécution est présentée ci-dessous.

Node.js

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

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

Par défaut, Cloud Functions tente de charger le code source depuis 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 du fichier principal doit définir le point d'entrée de la fonction et peut importer normalement un autre code et d'autres modules Node.js. 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 de répertoire de base pour les fonctions Python est la suivante:

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

Cloud Functions charge 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 votre point d'entrée de fonction, et peut importer normalement d'autres dépendances de code et externes. 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 de répertoire de base pour les 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, à l'exception de la fonction qui se trouve 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 Go en tant que dépendance:

module example.com/my-module

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

Le code du package racine doit définir votre point d'entrée de 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 de répertoire de base pour les 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 sources 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 le point d'entrée de votre fonction et peut importer d'autres codes et dépendances externes comme d'habitude. Vos fichiers source peuvent également définir plusieurs points d'entrée de fonction pouvant être déployés séparément.

C#

La structure de répertoire de base pour les 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 à vos fichiers sources.

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

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

Vous pouvez également utiliser le package de modèles Cloud Functions pour .NET afin de 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

Cloud Functions charge 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 votre point d'entrée de fonction, et peut importer normalement d'autres dépendances de code et externes. 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 de répertoire de base pour les fonctions PHP est la suivante:

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

Cloud Functions charge 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 votre point d'entrée de fonction, et peut importer normalement d'autres dépendances de code et externes. 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. Toutefois, certaines fonctions ne nécessitent pas l'ensemble des dépendances.

Dans la mesure du possible, nous vous recommandons de diviser les codebases multifonctions de grande taille 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 qui est exécuté lorsque la fonction Cloud est appelée. Vous spécifiez ce point d'entrée lorsque vous déployez votre fonction.

La manière dont vous définissez le point d'entrée dépend de l'environnement d'exécution du langage que vous utilisez. Pour certains langages, le point d'entrée est une fonction, tandis que pour d'autres, le point d'entrée est une classe. Pour en savoir plus sur la définition des points d'entrée et la mise en œuvre de Cloud Functions dans différents langages, consultez la page É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 plus d'informations, consultez la page appropriée:

Étapes suivantes

Découvrez comment écrire des fonctions HTTP.
Découvrez comment écrire des fonctions basées sur des événements.
Découvrez les déclencheurs de Cloud Functions.