Fonctions d'appel via des requêtes HTTP


Vous pouvez déclencher une fonction via une requête HTTP avec un gestionnaire de requêtes. Vous pouvez ainsi appeler une fonction via les méthodes HTTP compatibles suivantes: GET, POST, PUT, DELETE et OPTIONS.

Options HTTP supplémentaires

Option Description
region Les fonctions HTTP peuvent spécifier un tableau de régions ainsi qu'une seule région. Lorsque plusieurs régions sont spécifiées, une instance de fonction distincte est déployée pour chaque région.
timeoutSeconds (timeout_sec pour Python) Les fonctions HTTP peuvent spécifier un délai avant expiration maximal d'une heure.
cors Les fonctions HTTP peuvent spécifier des règles CORS. Vous pouvez définir cette valeur sur true pour autoriser toutes les origines ou sur string, regex ou array pour spécifier les origines autorisées. La valeur par défaut est "false"/aucune règle CORS si elle n'est pas explicitement définie.

Configurer le partage des ressources entre origines multiples (CORS)

Utilisez l'option cors pour contrôler les origines pouvant accéder à votre fonction. Par défaut, le CORS n'est pas configuré pour les fonctions HTTP. Par conséquent, toute requête inter-origine envoyée à votre fonction génère cette erreur:

request has been blocked by CORS policy: No 'Access-Control-Allow-Origin' header is present on the requested resource.

Vous pouvez également désactiver explicitement le CORS en définissant l'option cors sur false pour votre fonction.

Pour autoriser certaines requêtes inter-origines, mais pas toutes, vous pouvez transmettre une liste de domaines ou d'expressions régulières spécifiques à autoriser. Par exemple, si vous possédez les domaines firebase.com et flutter.com, et que firebase.com peut avoir de nombreux sous-domaines, vous pouvez définir l'option cors sur [/firebase\.com$/, 'flutter.com'] pour Node.js ou [r'firebase\.com$', r'https://flutter\.com'] pour Python:

Node.js

const { onRequest } = require("firebase-functions/v2/https");

exports.sayHello = onRequest(
  { cors: [/firebase\.com$/, "flutter.com"] },
  (req, res) => {
    res.status(200).send("Hello world!");
  }
);

Python

from firebase_functions import https_fn, options

@https_fn.on_request(
    cors=options.CorsOptions(
        cors_origins=[r"firebase\.com$", r"https://flutter\.com"],
        cors_methods=["get", "post"],
    )
)
def say_hello(req: https_fn.Request) -> https_fn.Response:
    return https_fn.Response("Hello world!")

Si votre fonction doit être ouvertement disponible, par exemple si elle sert une API ou un site Web public, définissez la règle cors sur true.

Déclencher une fonction avec une requête HTTP

Utilisez le gestionnaire de requêtes de votre plate-forme (onRequest() ou on_request) pour créer une fonction qui gère les événements HTTP. Les exemples de cette section sont basés sur un exemple de "serveur de temps" qui se déclenche lorsque vous envoyez une requête HTTP GET au point de terminaison des fonctions. L'exemple de fonction récupère l'heure actuelle du serveur, met en forme l'heure comme spécifié dans un paramètre de requête d'URL et envoie le résultat dans la réponse HTTP.

Utiliser des objets de requête et de réponse

L'objet de requête vous permet d'accéder aux propriétés de la requête HTTP envoyée par le client, et l'objet de réponse vous permet d'envoyer une réponse au client.

Node.js

exports.date = onRequest(
    {timeoutSeconds: 1200, region: ["us-west1", "us-east1"]},
    (req, res) => {
// ...
});

Python

@https_fn.on_request(cors=options.CorsOptions(cors_origins="*", cors_methods=["get", "post"]))
def date(req: https_fn.Request) -> https_fn.Response:
    """Get the server's local date and time."""

Utiliser des applications Express ou Flask existantes

En utilisant l'application comme argument du gestionnaire de requêtes, vous pouvez transmettre une application complète à une fonction HTTP:

Node.js

const { onRequest } = require('firebase-functions/v2/https');

const express = require('express');
const app = express();

// Add middleware to authenticate requests
app.use(myMiddleware);

// build multiple CRUD interfaces:
app.get('/:id', (req, res) => res.send(Widgets.getById(req.params.id)));
app.post('/', (req, res) => res.send(Widgets.create()));
app.put('/:id', (req, res) => res.send(Widgets.update(req.params.id, req.body)));
app.delete('/:id', (req, res) => res.send(Widgets.delete(req.params.id)));
app.get('/', (req, res) => res.send(Widgets.list()));

// Expose Express API as a single Cloud Function:
exports.widgets = onRequest(app);

Python

from firebase_admin import initialize_app, db
from firebase_functions import https_fn
import flask

initialize_app()
app = flask.Flask(__name__)

# Build multiple CRUD interfaces:


@app.get("/widgets")
@app.get("/widgets/<id>")
def get_widget(id=None):
    if id is not None:
        return db.reference(f"/widgets/{id}").get()
    else:
        return db.reference("/widgets").get()


@app.post("/widgets")
def add_widget():
    new_widget = flask.request.get_data(as_text=True)
    db.reference("/widgets").push(new_widget)
    return flask.Response(status=201, response="Added widget")


# Expose Flask app as a single Cloud Function:


@https_fn.on_request()
def httpsflaskexample(req: https_fn.Request) -> https_fn.Response:
    with app.request_context(req.environ):
        return app.full_dispatch_request()

Appeler une fonction HTTP

Une fois que vous avez déployé une fonction HTTP, vous pouvez l'appeler via son URL unique. Utilisez l'URL exacte fournie dans la sortie de la CLI après le déploiement.

Par exemple, l'URL permettant d'appeler date() se présente comme suit:

https://us-central1-<project-id>.cloudfunctions.net/date

Avec le routage d'application Express et Flask, le nom de la fonction est ajouté en tant que préfixe aux chemins d'URL dans l'application que vous définissez.

Lire les valeurs de la requête

Dans l'exemple de fonction date(), la fonction teste à la fois le paramètre d'URL et le corps pour une valeur format afin de définir le format de date/heure à utiliser:

Node.js

let format = req.query.format;
format = req.body.format;

Python

format = req.args["format"] if "format" in req.args else None

Arrêter des fonctions HTTP

Après avoir récupéré et mis en forme l'heure du serveur, la fonction date() se termine en envoyant le résultat dans la réponse HTTP:

Node.js

Terminez toujours une fonction HTTP par send(), redirect() ou end(). Sinon, votre fonction risque de continuer à s'exécuter et d'être arrêtée de force par le système. Consultez également la section Sync, Async et Promises.

const formattedDate = moment().format(`${format}`);
logger.log("Sending formatted date:", formattedDate);
res.status(200).send(formattedDate);

Python

formatted_date = datetime.now().strftime(format)
print(f"Sending Formatted date: {formatted_date}")
return https_fn.Response(formatted_date)

Intégrer à Firebase Hosting

Vous pouvez connecter une fonction HTTP à Firebase Hosting. Les requêtes sur votre site Firebase Hosting peuvent être transmises à des fonctions HTTP spécifiques via un proxy. Cela vous permet également d'utiliser votre propre domaine personnalisé avec une fonction HTTP. Découvrez comment associer Cloud Functions à Firebase Hosting.