Déclencheurs HTTP

Vous pouvez appeler des fonctions Cloud Functions avec une requête HTTP à l'aide des méthodes HTTP POST, PUT, GET, DELETE et OPTIONS. Pour créer un point de terminaison HTTP pour votre fonction, spécifiez --trigger-http comme type de déclencheur lors du déploiement de votre fonction. Du point de vue de l'appelant, les appels HTTP sont synchrones, ce qui signifie que le résultat de l'exécution de la fonction est renvoyé dans la réponse à la demande HTTP.

Par exemple, la commande gcloud suivante déploie une fonction sur l'environnement d'exécution Node.js 10 qui sera déclenchée par les requêtes HTTP :

gcloud functions deploy FUNCTION_NAME --runtime nodejs10 --trigger-http --allow-unauthenticated

Les fonctions HTTP nécessitent une authentification par défaut. L'option --allow-unauthenticated vous permet d'accéder à la fonction sans authentification. Pour exiger une authentification, omettez cette option.

Vous pouvez utiliser l'utilitaire de ligne de commande cURL habituellement disponible pour appeler les fonctions HTTP. La commande cURL suivante envoie une requête POST avec certaines données à l'URL d'une fonction HTTP déployée :

curl -X POST "https://YOUR_REGION-YOUR_PROJECT_ID.cloudfunctions.net/FUNCTION_NAME" -H "Content-Type:application/json" --data '{"name":"Keyboard Cat"}'

Où :

  • YOUR_REGION correspond à la région dans laquelle votre fonction est déployée ;
  • YOUR_PROJECT_ID correspond à votre ID de projet Google Cloud Platform ;
  • FUNCTION_NAME correspond au nom de la fonction HTTP que vous avez déployée.

L'URL du déclencheur d'une fonction HTTP est visible après le déploiement de la fonction, et peut être interrogée à tout moment à l'aide de la commande gcloud functions describe.

Vous pouvez également déclencher vos fonctions HTTP directement via l'outil gcloud. La commande suivante appelle une fonction et lui envoie des données dans le corps d'une requête HTTP POST :

gcloud functions call FUNCTION_NAME --data '{"name":"Keyboard Cat"}'

Exemple de code

Node.js

const escapeHtml = require('escape-html');

/**
 * HTTP Cloud Function.
 *
 * @param {Object} req Cloud Function request context.
 *                     More info: https://expressjs.com/en/api.html#req
 * @param {Object} res Cloud Function response context.
 *                     More info: https://expressjs.com/en/api.html#res
 */
exports.helloHttp = (req, res) => {
  res.send(`Hello ${escapeHtml(req.query.name || req.body.name || 'World')}!`);
};

Python

from flask import escape

def hello_http(request):
    """HTTP Cloud Function.
    Args:
        request (flask.Request): The request object.
        <https://flask.palletsprojects.com/en/1.1.x/api/#incoming-request-data>
    Returns:
        The response text, or any set of values that can be turned into a
        Response object using `make_response`
        <https://flask.palletsprojects.com/en/1.1.x/api/#flask.make_response>.
    """
    request_json = request.get_json(silent=True)
    request_args = request.args

    if request_json and 'name' in request_json:
        name = request_json['name']
    elif request_args and 'name' in request_args:
        name = request_args['name']
    else:
        name = 'World'
    return 'Hello {}!'.format(escape(name))

Go


// Package helloworld provides a set of Cloud Functions samples.
package helloworld

import (
	"encoding/json"
	"fmt"
	"html"
	"net/http"
)

// HelloHTTP is an HTTP Cloud Function with a request parameter.
func HelloHTTP(w http.ResponseWriter, r *http.Request) {
	var d struct {
		Name string `json:"name"`
	}
	if err := json.NewDecoder(r.Body).Decode(&d); err != nil {
		fmt.Fprint(w, "Hello, World!")
		return
	}
	if d.Name == "" {
		fmt.Fprint(w, "Hello, World!")
		return
	}
	fmt.Fprintf(w, "Hello, %s!", html.EscapeString(d.Name))
}

Java


import com.google.cloud.functions.HttpFunction;
import com.google.cloud.functions.HttpRequest;
import com.google.cloud.functions.HttpResponse;
import com.google.gson.Gson;
import com.google.gson.JsonElement;
import com.google.gson.JsonObject;
import com.google.gson.JsonParseException;
import java.io.IOException;
import java.io.PrintWriter;
import java.util.logging.Logger;

public class HelloHttp implements HttpFunction {
  private static final Logger logger = Logger.getLogger(HelloHttp.class.getName());

  private static final Gson gson = new Gson();

  @Override
  public void service(HttpRequest request, HttpResponse response)
      throws IOException {
    // Check URL parameters for "name" field
    // "world" is the default value
    String name = request.getFirstQueryParameter("name").orElse("world");

    // Parse JSON request and check for "name" field
    try {
      JsonElement requestParsed = gson.fromJson(request.getReader(), JsonElement.class);
      JsonObject requestJson = null;

      if (requestParsed != null && requestParsed.isJsonObject()) {
        requestJson = requestParsed.getAsJsonObject();
      }

      if (requestJson != null && requestJson.has("name")) {
        name = requestJson.get("name").getAsString();
      }
    } catch (JsonParseException e) {
      logger.severe("Error parsing JSON: " + e.getMessage());
    }

    var writer = new PrintWriter(response.getWriter());
    writer.printf("Hello %s!", name);
  }
}

Structure de l'événement

Les fonctions déclenchées par HTTP reçoivent les événements via des frameworks HTTP idiomatiques. Pour plus d'informations, consultez les exemples de code ci-dessus.

Étape suivante

Reportez-vous au tutoriel HTTP pour savoir comment mettre en œuvre une fonction HTTP ou au tutoriel Fonctions HTTP pour en savoir plus sur l'écriture de fonctions HTTP.