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

Configurer CORS (partage des ressources entre origines multiples)

Utilisez l'option cors pour contrôler les origines pouvant accéder à votre fonction. Par défaut, les fonctions HTTP n'ont pas de configuration CORS. Cela signifie que toute requête multi-origine envoyé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 le CORS en définissant l'option cors sur false pour votre fonction.

Pour autoriser certaines requêtes cross-origin, 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 :

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

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

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 à tous, par exemple si elle sert une API ou un site Web publics, 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 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.

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

@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

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 :

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);

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 l'URL exacte générée par 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 :

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

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() conclut en envoyant le résultat dans la réponse HTTP :

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

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

Intégration à Firebase Hosting

Vous pouvez connecter une fonction HTTP à Firebase Hosting. Les requêtes sur votre site Firebase Hosting 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 associer Cloud Functions à Firebase Hosting.