Chiamare le funzioni tramite richieste HTTP

2ª gen. 1ª gen.

Puoi attivare una funzione tramite una richiesta HTTP con un gestore delle richieste. In questo modo puoi invocare 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 e una singola regione. Quando vengono specificate più regioni, verrà eseguita 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 i criteri CORS. Puoi impostarlo su true per consentire tutte le origini o su string, regex o array per specificare le origini consentite. Se non viene impostato esplicitamente, il valore predefinito è false/nessun criterio CORS.

Configurazione di CORS (Cross-Origin Resource Sharing)

Utilizza l'opzione cors per controllare le origini che possono accedere alla tua funzione. Per impostazione predefinita, le funzioni HTTP non hanno il CORS configurato, il che significa che qualsiasi richiesta cross-origin alla 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 il CORS impostando l'opzione cors su false per la tua funzione.

Per consentire alcune richieste cross-origin, ma non tutte, puoi passare un elenco di domini o espressioni regolari specifici che devono essere consentiti. Ad esempio, se possiedi i domini firebase.com e flutter.com e firebase.com può avere molti sottodomini, ti consigliamo di impostare l'opzione cors su [/firebase\.com$/, '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$/, "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 funzione deve essere disponibile pubblicamente, ad esempio se serve un sito web o un'API pubblica, imposta il criterio cors su true.

Attivare una funzione con una richiesta HTTP

Utilizza il gestore delle richieste per la tua piattaforma (onRequest() o on_request) per creare una funzione che gestisce gli eventi HTTP. Gli esempi in questa sezione si basano su un "server di ora" di esempio che si attiva 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 dell'URL e invia il risultato nella risposta HTTP.

Utilizzo di oggetti di richiesta e risposta

L'oggetto request ti consente di accedere alle proprietà della richiesta HTTP inviata dal client, mentre l'oggetto response ti consente di 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

Importante: assicurati che tutte le funzioni HTTP terminate correttamente. Se termini correttamente le funzioni, puoi evitare costi eccessivi per le funzioni in esecuzione per troppo tempo.

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 relativo URL univoco. Utilizza l'URL esatto visualizzato dall'interfaccia a riga di comando dopo il deployment.

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

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.

Leggere i valori dalla richiesta

Nell'esempio della funzione date(), la funzione verifica sia il parametro URL sia il corpo per un valore format per impostare il formato 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

Interrompere le funzioni HTTP

Dopo aver recuperato e formattato l'ora del server, la funzione date() si conclude 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 funzionare e essere terminata forzatamente dal sistema. Vedi anche Sincronizzazione, asincronia e promesse.

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 collegare una funzione HTTP a Firebase Hosting. Le richieste sul tuo sito Firebase Hosting possono essere proxy per 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.