Funktionen über HTTP-Anfragen aufrufen

Sie können eine Funktion über eine HTTP-Anfrage mit einem Anfrage-Handler auslösen. So können Sie eine Funktion über die folgenden unterstützten HTTP-Methoden aufrufen: GET, POST, PUT, DELETE und OPTIONS.

In diesem Leitfaden wird davon ausgegangen, dass Sie die Einrichtungsschritte ausgeführt haben, die im Startleitfaden für Node.js und Python oder im experimentellen Dart SDK beschrieben sind.

Zusätzliche HTTP-Optionen

Option Beschreibung
region HTTP-Funktionen können ein Array von Regionen sowie eine einzelne Region angeben. Wenn mehrere Regionen angegeben sind, wird für jede Region eine separate Funktionsinstanz bereitgestellt.
timeoutSeconds (timeout_sec für Python) Für HTTP-Funktionen kann ein Zeitlimit von bis zu einer Stunde angegeben werden.
cors Für HTTP-Funktionen können CORS-Richtlinien angegeben werden. Sie können diesen Wert auf true setzen, um alle Ursprünge zuzulassen, oder einen string, regex oder array angeben, um zulässige Ursprünge festzulegen. Wenn nicht explizit festgelegt, wird standardmäßig „false“/keine CORS-Richtlinien verwendet.

CORS (Cross-Origin Resource Sharing) konfigurieren

Mit der Option cors können Sie steuern, welche Ursprünge auf Ihre Funktion zugreifen können. Standardmäßig ist für HTTP-Funktionen kein CORS konfiguriert. Das bedeutet, dass jede ursprungsübergreifende Anfrage an Ihre Funktion zu diesem Fehler führt:

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

Sie können CORS auch explizit deaktivieren, indem Sie die Option cors für Ihre Funktion auf false setzen.

Wenn Sie einige, aber nicht alle ursprungsübergreifenden Anfragen zulassen möchten, können Sie eine Liste bestimmter Domains oder regulärer Ausdrücke übergeben, die zulässig sein sollen. Wenn Sie beispielsweise die Domains firebase.com und flutter.com besitzen und firebase.com viele Subdomains haben kann, können Sie die Option cors so festlegen:

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

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

Wenn Ihre Funktion öffentlich verfügbar sein soll, z. B. wenn sie eine öffentliche API oder Website bereitstellt, legen Sie die Richtlinie cors auf true fest.

Funktion mit einer HTTP-Anfrage auslösen

Verwenden Sie den Anfrage-Handler für Ihre Plattform, um eine Funktion zu erstellen, die HTTP-Ereignisse verarbeitet. Die Beispiele in diesem Abschnitt basieren auf einem „Zeitserver“-Beispiel, das ausgelöst wird, wenn Sie eine HTTP-GET-Anfrage an den Endpunkt der Funktion senden. Die Beispielfunktion ruft die aktuelle Serverzeit ab, formatiert die Zeit wie in einem URL-Suchparameter angegeben und sendet das Ergebnis in der HTTP-Antwort.

Anfrage- und Antwortobjekte verwenden

Das Anfrageobjekt ermöglicht Ihnen den Zugriff auf die Attribute der vom Client gesendeten HTTP-Anfrage. Mit dem Antwortobjekt können Sie eine Antwort an den Client zurücksenden.

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

void main() {
  runFunctions((firebase) {
    firebase.https.onRequest(name: 'date', (request) async {

Vorhandene Express- oder Flask-Anwendungen verwenden

Wenn Sie die Anwendung als Argument für den Anfrage-Handler verwenden, können Sie eine vollständige Anwendung an eine HTTP-Funktion übergeben:

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

HTTP-Funktion aufrufen

Nachdem Sie eine HTTP-Funktion bereitgestellt haben, können Sie sie über ihre eigene eindeutige URL aufrufen. Verwenden Sie die genaue URL, die nach der Bereitstellung von der Befehlszeile ausgegeben wird.

Die URL zum Aufrufen von date() sieht beispielsweise so aus:

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

Beim Express- und Flask-Anwendungsrouting wird der Funktionsname als Präfix zu den URL-Pfaden in der von Ihnen definierten Anwendung hinzugefügt.

Werte aus der Anfrage lesen

Im Beispiel für die Funktion date() werden sowohl der URL-Parameter als auch der Text auf einen format-Wert geprüft, um das zu verwendende Datums-/Uhrzeitformat festzulegen:

Node.js

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

Python

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

Dart (experimentell)

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

HTTP-Funktionen beenden

Nachdem die Serverzeit abgerufen und formatiert wurde, wird die Funktion date() abgeschlossen, indem das Ergebnis in der HTTP-Antwort gesendet wird:

Node.js

Beenden Sie eine HTTP-Funktion immer mit send(), redirect() oder end(). Andernfalls wird die Funktion möglicherweise weiter ausgeführt und vom System zwangsweise beendet. Weitere Informationen finden Sie unter Synchron, asynchron und Promises.

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

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

In Firebase Hosting einbinden

Sie können eine HTTP-Funktion mit Firebase Hosting verbinden. Anfragen auf Ihrer Firebase Hosting-Website können an bestimmte HTTP-Funktionen weitergeleitet werden. So können Sie auch Ihre eigene benutzerdefinierte Domain mit einer HTTP-Funktion verwenden. Weitere Informationen zum Verbinden von Cloud Functions mit Firebase Hosting