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

Funkcję możesz aktywować za pomocą żądania HTTP z obsługą żądań. 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 między serwerami z różnych domen)

Użyj opcji cors, aby określić, które punkty początkowe mogą uzyskiwać dostęp do Twojej funkcji. Domyślnie funkcje HTTP nie mają skonfigurowanych zasad CORS, co oznacza, że każde żądanie z innego punktu początkowego 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ż wyraźnie wyłączyć CORS, ustawiając dla funkcji opcję cors na false.

Aby zezwolić na niektóre żądania z innych punktów początkowych, ale nie na wszystkie, możesz przekazać listę konkretnych domen lub wyrażeń regularnych, które mają być dozwolone. Jeśli na przykład jesteś właścicielem domen 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 ma 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

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

Używanie obiektów żądania 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

Używanie istniejących aplikacji Express lub Flask

Używając aplikacji jako argumentu 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, który został wyświetlony w interfejsie CLI 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 zdefiniowanej aplikacji.

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

Kończenie funkcji HTTP

Po pobraniu i sformatowaniu czasu serwera funkcja date() kończy się wysłaniem wyniku 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 Firebase Hosting. Żądania w witrynie Firebase Hosting mogą być przekierowywane do określonych funkcji HTTP. Umożliwia to też używanie własnej domeny niestandardowej z funkcją HTTP. Dowiedz się więcej o łączeniu Cloud Functions z Firebase Hosting.