Llama a funciones mediante solicitudes HTTP

2ª gen. 1ª gen.

Puedes activar una función a través de una solicitud HTTP con un controlador de solicitudes. Esto te permite invocar una función mediante los siguientes métodos HTTP admitidos: GET, POST, PUT, DELETE y OPTIONS.

Opciones de HTTP adicionales

Opción	Descripción
region	Las funciones de HTTP pueden especificar un array de regiones o una sola región. Cuando se especifican múltiples regiones, se implementa una instancia de función independiente para cada región.
timeoutSeconds (timeout_sec para Python)	Las funciones de HTTP pueden especificar un tiempo de espera de hasta una hora.
cors	Las funciones de HTTP pueden especificar políticas de CORS. Puedes configurar esto como true para permitir todos los orígenes, o como string, regex o array si deseas especificar los orígenes permitidos. Si la política no se configura explícitamente, se establece de forma predeterminada como falsa o sin política de CORS.

Configura el CORS (uso compartido de recursos entre dominios)

Usa la opción cors para controlar qué orígenes pueden acceder a tu función. Según la configuración predeterminada, las funciones de HTTP no tienen CORS configurado, lo que significa que cualquier solicitud de origen cruzado a la función generará el siguiente error:

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

También puedes inhabilitar CORS explícitamente si estableces la opción cors en false para tu función.

Para permitir algunas solicitudes de origen cruzado, pero no todas, puedes pasar una lista de dominios específicos o expresiones regulares que deberían permitirse. Por ejemplo, si tienes propiedad de los dominios firebase.com y flutter.com, y firebase.com puede tener muchos subdominios, es posible establecer la opción cors como [/firebase\.com$/, 'flutter.com'] para Node.js o [r'firebase\.com$', r'https://flutter\.com'] para 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 tu función debe estar disponible de forma abierta, por ejemplo, si entrega una API o un sitio web públicos, establece la política cors como true.

Activa una función con una solicitud HTTP

Usa el controlador de solicitudes de tu plataforma (onRequest() o on_request) para crear una función que controle eventos HTTP. Los ejemplos de esta sección se basan en una muestra del “servidor de tiempo” que se activa cuando envías una solicitud HTTP GET al extremo de las funciones. La función de muestra recupera la hora actual del servidor, formatea el tiempo según se especifica en un parámetro de consulta de URL y envía el resultado en la respuesta HTTP.

Usa objetos Request y Response

El objeto Request te da acceso a las propiedades de la solicitud HTTP que envió el cliente y el objeto Response te proporciona una forma de enviar una respuesta al cliente.

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: Asegúrate de finalizar correctamente todas las funciones de HTTP. Cuando finalizas las funciones de forma correcta, puedes evitar cargos excesivos debido a funciones que se ejecutan durante mucho tiempo.

Usa apps Express o Flask existentes

Si usas la app como argumento del controlador de solicitudes, puedes pasar una app completa a una función de 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

Invoca una función HTTP

Después de implementar una función de HTTP, puedes invocarla mediante su propia URL única. Debes usar la salida de URL exacta de la CLI luego de la implementación.

Por ejemplo, la URL para invocar date() tiene el siguiente aspecto:

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

Con el enrutamiento de apps de Express y Flask, el nombre de la función se agrega como prefijo a las rutas de URL en la app que definas.

Lee los valores de la solicitud

En el ejemplo de la función date(), se prueban tanto el parámetro de URL como el cuerpo para verificar el valor de format para configurar el formato de fecha y hora que se usará:

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

Finaliza funciones de HTTP

Después de recuperar la hora del servidor y darle formato, la función date() concluye con el envío del resultado en la respuesta HTTP:

Node.js

Siempre termina una función de HTTP con send(), redirect() o end(). De lo contrario, tu función podría seguir ejecutándose, y el sistema podría forzar su finalización. Consulta también Síncrono, asíncrono y promesas.

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

Realiza la integración en Firebase Hosting

Puedes conectar una función de HTTP a Firebase Hosting. Las solicitudes en tu sitio de Firebase Hosting se pueden dirigir a funciones de HTTP específicas. Esto también te permite usar tu propio dominio personalizado con una función HTTP. Obtén más información para conectar Cloud Functions a Firebase Hosting.