Chiamare le funzioni tramite richieste HTTP

Puoi attivare una funzione tramite una richiesta HTTP con un gestore di richieste. In questo modo puoi richiamare una funzione tramite i seguenti metodi HTTP supportati: GET, POST, PUT, DELETE e OPTIONS.

Opzioni HTTP aggiuntive

Opzione Descrizione
region Le funzioni HTTP possono specificare un array di regioni, nonché una singola regione. Quando vengono specificate più regioni, viene eseguito il deployment di un'istanza di funzione separata per ogni regione.
timeoutSeconds (timeout_sec per Python) Le funzioni HTTP possono specificare un timeout massimo di un'ora.
cors Le funzioni HTTP possono specificare criteri CORS. Puoi impostare questo valore su true per consentire tutte le origini o su string, regex o array per specificare le origini consentite. Se non impostato esplicitamente, il valore predefinito è false/nessun criterio CORS.

Configurazione di CORS (Cross-Origin Resource Sharing)

Utilizza l'opzione cors per controllare quali origini possono accedere alla tua funzione. Per impostazione predefinita, le funzioni HTTP non hanno CORS configurato, il che significa che qualsiasi richiesta tra origini diverse alla tua funzione genera questo errore:

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

Puoi anche disattivare esplicitamente CORS impostando l'opzione cors su false per la tua funzione.

Per consentire alcune richieste multiorigine, ma non tutte, puoi trasmettere un elenco di domini specifici o espressioni regolari che devono essere consentiti. Ad esempio, se possiedi i domini firebase.com e flutter.com e firebase.com può avere molti sottodomini, potresti impostare l'opzione cors su [/firebase\.com$/, 'https://flutter.com'] per Node.js o [r'firebase\.com$', r'https://flutter\.com'] per 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!")

Se la tua funzione deve essere disponibile pubblicamente, ad esempio se serve un'API o un sito web pubblici, imposta il criterio cors su true.

Attiva una funzione con una richiesta HTTP

Utilizza il gestore delle richieste per la tua piattaforma (onRequest() o on_request) per creare una funzione che gestisca gli eventi HTTP. Gli esempi in questa sezione si basano su un esempio di "time server" che viene attivato quando invii una richiesta HTTP GET all'endpoint delle funzioni. La funzione di esempio recupera l'ora corrente del server, la formatta come specificato in un parametro di query URL e invia il risultato nella risposta HTTP.

Utilizzo di oggetti di richiesta e risposta

L'oggetto richiesta ti consente di accedere alle proprietà della richiesta HTTP inviata dal client, mentre l'oggetto risposta ti offre un modo per inviare una risposta al 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

Utilizzo di app Express o Flask esistenti

Utilizzando l'app come argomento per il gestore delle richieste, puoi passare un'app completa a una funzione 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

Richiamare una funzione HTTP

Dopo aver eseguito il deployment di una funzione HTTP, puoi richiamarla tramite il suo URL univoco. Utilizza l'URL esatto restituito dalla CLI dopo il deployment.

Ad esempio, l'URL per richiamare date() ha il seguente aspetto:

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

Con il routing delle app Express e Flask, il nome della funzione viene aggiunto come prefisso ai percorsi URL nell'app che definisci.

Leggi i valori dalla richiesta

Nell'esempio di funzione date(), la funzione verifica sia il parametro URL sia il corpo per un valore format per impostare il formato di data/ora da utilizzare:

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

Termina le funzioni HTTP

Dopo aver recuperato e formattato l'ora del server, la funzione date() termina inviando il risultato nella risposta HTTP:

Node.js

Termina sempre una funzione HTTP con send(), redirect() o end(). In caso contrario, la funzione potrebbe continuare a essere eseguita e terminare forzatamente dal sistema. Vedi anche Sync, Async and Promises.

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

Integrazione con Firebase Hosting

Puoi connettere una funzione HTTP a Firebase Hosting. Le richieste sul tuo sito Firebase Hosting possono essere inviate tramite proxy a funzioni HTTP specifiche. In questo modo puoi anche utilizzare il tuo dominio personalizzato con una funzione HTTP. Scopri di più su come collegare Cloud Functions a Firebase Hosting.