Chamar funções por meio de solicitações HTTP


Você pode acionar uma função por meio de uma solicitação HTTP com um manipulador de solicitações. Isso permite invocar uma função por meio dos seguintes métodos HTTP suportados: GET , POST , PUT , DELETE e OPTIONS .

Opções HTTP adicionais

Opção Descrição
region As funções HTTP podem especificar uma matriz de regiões, bem como uma única região. Quando múltiplas regiões são especificadas, uma instância de função separada será implantada para 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 CORS. Você pode definir isso como true para permitir que todas as origens ou uma string , regex ou array especifique as origens permitidas. O padrão é falso/sem políticas CORS se não for definido explicitamente.

Configurando CORS (compartilhamento de recursos entre origens)

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

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

Você também pode desabilitar explicitamente o CORS definindo a opção cors como false para sua função.

Para permitir algumas solicitações de origem cruzada, mas não todas, você pode passar uma lista de domínios específicos ou expressões regulares que devem ser permitidas. Por exemplo, se você possui os domínios firebase.com e flutter.com e firebase.com pode ter muitos subdomínios, convém definir 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!");
  }
);

Pitão

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 sua função estiver disponível abertamente, por exemplo, se estiver servindo uma API ou site público, defina a política cors como true .

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

Use o manipulador de solicitações da sua plataforma ( onRequest() ou on_request ) para criar uma função que manipula eventos HTTP. Os exemplos nesta seção baseiam-se em um exemplo de "servidor de horário" que é acionado quando você envia uma solicitação HTTP GET para o ponto de extremidade de 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.

Usando objetos de solicitação e resposta

O objeto de solicitação fornece acesso às propriedades da solicitação HTTP enviada pelo cliente, e o objeto de resposta fornece uma maneira de enviar uma resposta de volta ao cliente.

Node.js

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

Pitão

@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

Usando aplicativos Express ou Flask existentes

Usando o app como argumento para o manipulador de solicitações, você pode passar um aplicativo 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);

Pitão

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 implementar uma função HTTP, você poderá invocá-la por meio de sua própria URL exclusiva. Use a saída de URL exata da CLI após a implantação.

Por exemplo, a URL para invocar date() é assim:

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

Com o roteamento de aplicativos Express e Flask, o nome da função é adicionado como um prefixo aos caminhos de URL no aplicativo que você define.

Ler valores da solicitação

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

Node.js

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

Pitão

format = req.args["format"] if "format" in req.args else None
main.py

Encerrar funções HTTP

Após recuperar e formatar a hora do servidor, a função date() finaliza enviando o resultado na resposta HTTP:

Node.js

Sempre finalize uma função HTTP com send() , redirect() ou end() . Caso contrário, sua função poderá continuar em execução e ser encerrada à força pelo sistema. Veja também Sincronização, Assíncrono e Promessas .

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

Pitão

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

Integração com Firebase Hosting

Você pode conectar uma função HTTP ao Firebase Hosting. As solicitações no seu site do Firebase Hosting podem ser proxy 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 .