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.

W tym przewodniku zakładamy, że masz już za sobą czynności konfiguracyjne opisane w naszym przewodniku dla początkujących dotyczącym Node.js i Pythona, lub czynności konfiguracyjne dotyczące eksperymentalnego pakietu Dart SDK.

Dodatkowe opcje HTTP

Opcja Opis
region Funkcje HTTP mogą określać tablicę regionów, a także pojedynczy region. Gdy określonych jest kilka regionów, dla każdego z nich wdrażana jest osobna instancja funkcji.
timeoutSeconds (timeout_sec w Pythonie) Funkcje HTTP mogą określać limit czasu do 1 godziny.
cors Funkcje HTTP mogą określać zasady CORS. Możesz ustawić tę opcję na true, aby zezwolić na wszystkie punkty początkowe, lub na string, regex lub array, aby określić dozwolone punkty początkowe. Jeśli nie zostanie skonfigurowana, domyślnie ma wartość false/brak zasad CORS.

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 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ż wyraźnie wyłączyć CORS, ustawiając dla funkcji opcję cors na false.

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 jesteś właścicielem domen firebase.com i flutter.com, a domena firebase.com może mieć wiele subdomen, możesz ustawić opcję cors w ten sposób:

Node.js

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

exports.sayHello = onRequest(
  { cors: [/firebase\.com$/, "https://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!")

Dart (eksperymentalny)

import 'package:firebase_functions/firebase_functions.dart';

void main(List<String> args) {
  fireUp(args, (firebase) {
    firebase.https.onRequest(
      name: 'sayHello',
      options: const HttpsOptions(
        cors: Cors([RegExp(r'^https:\/\/firebase\.com$'), 'https://flutter.com']),
      ),
      (request) async => Response(200, body: '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ń na swojej platformie. 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 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.

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."""

Dart (eksperymentalny)

void main(List<String> args) async {
  await fireUp(args, (firebase) {
    firebase.https.onRequest(name: 'date', (request) async {

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:

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

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 zdefiniowanej przez Ciebie aplikacji.

Odczytywanie wartości z żądania

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

Node.js

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

Python

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

Dart (eksperymentalny)

var format = request.url.queryParameters['format'];
final bodyString = await request.readAsString();
try {
  if (bodyString.isNotEmpty) {
    final body = jsonDecode(bodyString) as Map<String, dynamic>;
    format = body['format'] as String?;
  }
} catch (e) {
  return Response.badRequest(body: 'invalid JSON');
}

Kończenie funkcji HTTP

Po pobraniu i sformatowaniu czasu serwera funkcja date() kończy się wysłaniem wyniku w odpowiedzi HTTP:

Node.js

Zawsze kończ funkcję HTTP za pomocą polecenia send(), redirect(), lub end(). W przeciwnym razie funkcja może nadal działać i zostać wymuszone zakończona przez system. Zobacz też Synchronizacja, asynchroniczność i obietnice.

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

Python

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

Dart (eksperymentalny)

final formattedDate = DateFormat(format).format(DateTime.now());
print('Sending formatted date: $formattedDate');
return Response.ok(formattedDate);

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. Więcej informacji o łączeniu Cloud Functions z Firebase Hosting.