Chamar funções via solicitações HTTP


Use um gerenciador de solicitações para acionar uma função com uma solicitação HTTP. Isso permite que você invoque uma função usando os seguintes métodos HTTP compatíveis: GET, POST, PUT, DELETE e OPTIONS.

Outras opções de HTTP

Opção Descrição
region As funções HTTP podem especificar uma matriz de regiões, bem como uma única região. Quando várias regiões são especificadas, uma instância de função separada é implantada em cada região.
timeoutSeconds (timeout_sec para Python) As funções HTTP podem especificar um tempo limite de até uma hora.
cors As funções HTTP podem especificar políticas do CORS. Defina isso como true para permitir que todas as origens ou um string, regex ou array especifique as origens permitidas. Se não for definido explicitamente, o padrão será políticas de CORS falsas ou nenhuma.

Como configurar o compartilhamento de recursos entre origens (CORS, na sigla em inglês)

Use a opção cors para controlar quais origens podem acessar a função. Por padrão, as funções HTTP não têm o CORS configurado, o que significa que qualquer solicitação entre origens para a função resulta neste erro:

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

Também é possível desativar explicitamente o CORS definindo a opção cors como false para a função.

Para permitir algumas solicitações de origem cruzada, mas não todas, transmita uma lista de domínios específicos ou expressões regulares que precisam ser permitidas. Por exemplo, se você tem os domínios firebase.com e flutter.com, e se firebase.com pode ter muitos subdomínios, defina a opção cors como [/firebase\.com$/, 'flutter.com'] para Node.js ou [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!")

Caso sua função precise estar disponível de maneira aberta, por exemplo, se ela estiver exibindo uma API ou um site público, defina a política cors como true.

Acionar uma função com uma solicitação HTTP

Use o gerenciador de solicitações da plataforma (onRequest() ou on_request) para criar uma função que gerencie eventos HTTP. Os exemplos desta seção são baseados em uma amostra de "servidor de tempo" que é acionada quando você envia uma solicitação GET HTTP para o endpoint das funções. A função de amostra recupera a hora atual do servidor, formata a hora conforme especificado em um parâmetro de consulta de URL e envia o resultado na resposta HTTP.

Como usar objetos de solicitação e resposta

O objeto de solicitação dá acesso às propriedades da solicitação HTTP enviada pelo cliente, e o objeto de resposta permite enviar uma resposta ao 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

Como usar apps Express ou Flask

Usando o app como argumento para o gerenciador de solicitações, você pode passar um app completo para uma função 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

Invocar uma função HTTP

Depois de implantar uma função HTTP, é possível invocá-la usando o URL exclusivo dela. Use a saída exata do URL da CLI após a implantação.

Por exemplo, o URL de invocação date() terá a seguinte aparência:

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

Com o roteamento de app do Express e do Flask, o nome da função é adicionado como um prefixo aos caminhos do URL no app definido por você.

Ler os valores da solicitação

No exemplo de função date(), a função testa o parâmetro de URL e o corpo de um valor de format para definir o formato de data/hora a ser usado:

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

Encerrar funções HTTP

Depois de recuperar e formatar o horário do servidor, a função date() termina enviando o resultado na resposta HTTP:

Node.js

Sempre encerre uma função HTTP com send(), redirect() ou end(). Caso contrário, ela pode continuar a ser executada e interrompida automaticamente pelo sistema. Veja também Sincronização, dessincronização e promessas.

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

Como integrar com o Firebase Hosting

É possível conectar uma função HTTP ao Firebase Hosting. As solicitações no site do Firebase Hosting podem ser encaminhadas para funções HTTP específicas. Isso também permite que você use seu próprio domínio personalizado com uma função HTTP. Saiba mais sobre como conectar o Cloud Functions ao Firebase Hosting.