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. Cela vous permet d'appeler une fonction à l'aide des 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 d'expiration allant jusqu'à une heure.
cors	Les fonctions HTTP peuvent spécifier des règles CORS. Vous pouvez définir cette option sur true pour autoriser toutes les origines ou sur string, regex ou array pour spécifier les origines autorisées. Si elle n'est pas définie explicitement, la valeur par défaut est "false" (aucune règle CORS).

Configurer le partage des ressources entre origines multiples (CORS)

Utilisez l'option cors pour contrôler les origines qui peuvent accéder à votre fonction. Par défaut, les fonctions HTTP ne sont pas configurées pour CORS, ce qui signifie que toute requête inter-origines adressée à votre fonction génère l'erreur suivante :

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 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 spécifiques ou d'expressions régulières à autoriser. Par exemple, si vous possédez les domaines firebase.com et flutter.com, et que firebase.com peut comporter de nombreux sous-domaines, vous pouvez définir l'option cors sur [/firebase\.com$/, 'https://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$/, "https://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 accessible publiquement, par exemple si elle diffuse 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 pour votre plate-forme (onRequest() ou on_request) afin de 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. La fonction exemple récupère l'heure actuelle du serveur, la met en forme 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 donne accès aux propriétés de la requête HTTP envoyée par le client, et l'objet de réponse vous permet de renvoyer 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."""
main.py

Important : Assurez-vous que toutes les fonctions HTTP se terminent correctement. En terminant correctement les fonctions, vous pouvez éviter des frais excessifs liés à des fonctions qui s'exécutent trop longtemps.

Utiliser des applications Express ou Flask existantes

En utilisant l'application comme argument pour le 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()
main.py

Appeler une fonction HTTP

Une fois que vous avez déployé une fonction HTTP, vous pouvez l'appeler via sa propre URL unique. Utilisez la sortie d'URL exacte 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;
index.js

Python

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

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, l'exécution risque de se poursuivre jusqu'à l'arrêt automatique par le système. Consultez également la section Synchronisation, asynchronisation et promesses.

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

Python

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

Intégrer à Firebase Hosting

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