Funktionen über HTTP-Anfragen aufrufen

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

In diesem Leitfaden wird davon ausgegangen, dass Sie die Einrichtungsaufgaben ausgeführt haben, die in unserer Anleitung Erste Schritte mit Node.js und Python, oder in der Anleitung für das experimentelle Dart SDK beschrieben sind.

Zusätzliche HTTP-Optionen

Option Beschreibung
region Für HTTP-Funktionen kann ein Array von Regionen sowie eine einzelne Region angegeben werden. 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 Timeout von bis zu einer Stunde angegeben werden.
cors Für HTTP-Funktionen können CORS-Richtlinien angegeben werden. Setzen Sie diese Option auf true, um alle Ursprünge zuzulassen, oder verwenden Sie string, regex oder array, um zulässige Ursprünge anzugeben. Wenn nicht explizit festgelegt, ist der Standardwert „false“/keine CORS-Richtlinien.

CORS (Cross-Origin Resource Sharing) konfigurieren

Mit der Option cors können Sie festlegen, welche Ursprünge auf Ihre Funktion zugreifen können. Standardmäßig ist für HTTP-Funktionen keine CORS-Konfiguration festgelegt. 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 mit bestimmten Domains oder regulären Ausdrücken ü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 wie unten gezeigt 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(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!'),
    );
  });
}

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

Funktion mit einer HTTP-Anfrage auslösen

Verwenden Sie den Anfragehandler 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 sie wie in einem URL-Abfrageparameter angegeben und sendet das Ergebnis in der HTTP-Antwort.

Anfrage- und Antwortobjekte verwenden

Das Anfrageobjekt bietet Zugriff auf die Eigenschaften der HTTP-Anfrage, die vom Client gesendet wurde. 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."""
main.py

Dart (experimentell)

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

Vorhandene Express- oder Flask-Apps verwenden

Wenn Sie die App als Argument für den Anfragehandler verwenden, können Sie eine vollständige App 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()
main.py

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 in der Befehlszeile ausgegeben wird.

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

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

Bei der App-Weiterleitung mit Express und Flask wird der Funktionsname als Präfix zu den URL-Pfaden in der von Ihnen definierten App hinzugefügt.

Werte aus der Anfrage lesen

Im Beispiel der Funktion date() werden sowohl der URL-Parameter als auch der Text auf einen format-Wert getestet, um das zu verwendende Datums-/Zeitformat festzulegen:

Node.js

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

Python

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

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

HTTP-Funktionen beenden

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

Node.js

Beenden Sie eine HTTP-Funktion immer mit send(), redirect(), oder end(). Andernfalls wird Ihre 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);
index.js

Python

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

Dart (experimentell)

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

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.