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

Funkcję możesz aktywować za pomocą żądania HTTP z modułem obsługi żądań. Dzięki temu możesz wywołać funkcję 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 przewodniku dla początkujących dotyczącym Node.js i Pythona lub czynności konfiguracyjne związane z eksperymentalnym pakietem SDK Dart.

Dodatkowe opcje HTTP

Opcja Opis
region Funkcje HTTP mogą określać tablicę regionów, a także pojedynczy region. Jeśli określono wiele regionów, dla każdego z nich zostanie wdrożona osobna instancja funkcji.
timeoutSeconds (timeout_sec dla Pythona) W przypadku funkcji HTTP można określić limit czasu do 1 godziny.
cors Funkcje HTTP mogą określać zasady CORS. Możesz ustawić wartość true, aby zezwolić na wszystkie źródła, lub string, regex lub array, aby określić dozwolone źródła. Jeśli nie zostanie określona, domyślnie przyjmuje wartość false (fałsz) / brak zasad CORS.

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

Użyj opcji cors, aby kontrolować, które źródła mogą uzyskiwać dostęp do funkcji. Domyślnie funkcje HTTP nie mają skonfigurowanego CORS, co oznacza, że każde żądanie współdzielenia do 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 opcję cors na false dla swojej funkcji.

Aby zezwolić na niektóre żądania współdzielenia, ale nie 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 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() {
  runFunctions((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 funkcja powinna być ogólnodostępna, na przykład 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ń na swojej platformie, 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 adresu URL i wysyła wynik w odpowiedzi HTTP.

Używanie obiektów żądań i odpowiedzi

Obiekt żądania daje 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() {
  runFunctions((firebase) {
    firebase.https.onRequest(name: 'date', (request) async {

Korzystanie z istniejących aplikacji Express lub Flask

Używając aplikacji jako argumentu modułu obsługi żądań, możesz przekazać całą 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 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 adresu 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:

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

Zakończenie funkcji HTTP

Po pobraniu i sformatowaniu czasu serwera funkcja date() kończy działanie, wysyłając wynik w odpowiedzi HTTP:

Node.js

Zawsze kończ funkcję HTTP za pomocą send(), redirect() lub end(). W przeciwnym razie funkcja może nadal działać i zostać wymuszenie zakończona przez system. Zobacz też Sync, Async and Promises (Synchronizacja, asynchronizacja 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

Funkcję HTTP możesz połączyć z usługą Firebase Hosting. Żądania w witrynie Firebase Hosting mogą być przekazywane do określonych funkcji HTTP. Umożliwia to też używanie własnej domeny z funkcją HTTP. Dowiedz się więcej o łączeniu Cloud Functions z Firebase Hosting.