Wywoływanie funkcji za pomocą żądań HTTP

Funkcję można aktywować za pomocą żądania HTTP z prośbą o obsługę. Umożliwia to wywoływanie funkcji za pomocą tych obsługiwanych metod HTTP: GET, POST, PUT, DELETE i OPTIONS.

Dodatkowe opcje HTTP

Konfigurowanie CORS (współdzielenia zasobów pomiędzy serwerami z różnych domen)

Użyj opcji cors, aby określić, które domeny mogą uzyskiwać dostęp do funkcji. Domyślnie funkcje HTTP nie mają skonfigurowanego CORS, co oznacza, że każde żądanie z innej domeny do Twojej funkcji powoduje ten błąd:

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

Możesz też jawnie wyłączyć CORS, ustawiając opcję cors na false w przypadku funkcji.

Aby zezwolić na niektóre żądania z innych domen, ale nie na wszystkie, możesz przekazać listę konkretnych domen lub wyrażeń regularnych, które powinny być dozwolone. Jeśli na przykład masz domeny firebase.com i flutter.com, a domena firebase.com może mieć wiele subdomen, możesz ustawić opcję cors na [/firebase\.com$/, 'https://flutter.com'] w przypadku Node.js lub [r'firebase\.com$', r'https://flutter\.com'] w przypadku Pythona:

const { onRequest } = require("firebase-functions/v2/https");

exports.sayHello = onRequest(
  { cors: [/firebase\.com$/, "https://flutter.com"] },
  (req, res) => {
    res.status(200).send("Hello world!");
  }
);

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!")

Jeśli Twoja funkcja powinna być ogólnodostępna, np. jeśli obsługuje publiczny interfejs API lub witrynę, ustaw zasadę cors na true.

Aktywowanie funkcji za pomocą żądania HTTP

Użyj modułu obsługi żądań dla swojej platformy (onRequest() lub on_request), aby utworzyć funkcję obsługującą zdarzenia HTTP. Przykłady w tej sekcji są oparte na przykładowym „serwerze czasu”, który jest aktywowany, gdy wysyłasz żądanie HTTP GET do punktu końcowego funkcji. Przykładowa funkcja pobiera bieżący czas serwera, formatuje go zgodnie z parametrem zapytania w adresie URL i wysyła wynik w odpowiedzi HTTP.

Korzystanie z obiektów żądań i odpowiedzi

Obiekt żądania umożliwia dostęp do właściwości żądania HTTP wysłanego przez klienta, a obiekt odpowiedzi umożliwia wysłanie odpowiedzi do klienta.

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

@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

Korzystanie z dotychczasowych aplikacji Express lub Flask

Używając aplikacji jako argumentu dla funkcji obsługi żądań, możesz przekazać pełną aplikację do funkcji HTTP:

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);

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

Wywoływanie funkcji HTTP

Po wdrożeniu funkcji HTTP możesz ją wywołać za pomocą jej unikalnego adresu URL. Użyj dokładnego adresu URL wygenerowanego przez interfejs wiersza poleceń po wdrożeniu.

Na przykład adres URL do wywołania funkcji date() wygląda tak:

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

W przypadku routingu aplikacji Express i Flask nazwa funkcji jest dodawana jako prefiks do ścieżek URL w aplikacji, które definiujesz.

Odczytywanie wartości z żądania

W przykładzie funkcji date() funkcja sprawdza zarówno parametr adresu URL, jak i treść pod kątem wartości format, aby ustawić format daty i godziny:

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

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

Zakończ funkcje HTTP

Po pobraniu i sformatowaniu czasu serwera funkcja date() wysyła wynik w odpowiedzi HTTP:

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

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

Integracja z Hostingiem Firebase

Możesz połączyć funkcję HTTP z usługą Firebase Hosting. Żądania w Twojej witrynieFirebase Hosting mogą być przekazywane do określonych funkcji HTTP. Umożliwia to również używanie własnej domeny niestandardowej z funkcją HTTP. Dowiedz się więcej o łączeniu Cloud Functions z Firebase Hosting.