Funktionen über HTTP-Anfragen aufrufen

2. Generation 1. Generation

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

Zusätzliche HTTP-Optionen

Option	Beschreibung
region	Für HTTP-Funktionen können mehrere Regionen oder eine einzelne Region angegeben werden. Wenn mehrere Regionen angegeben werden, 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 auf string, regex oder array, um zulässige Ursprünge anzugeben. Wenn das Attribut nicht explizit festgelegt wird, 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. Für HTTP-Funktionen ist standardmäßig keine CORS-Konfiguration festgelegt. Das bedeutet, dass jede Cross-Origin-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 plattformü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 auf [/firebase\.com$/, 'flutter.com'] für Node.js oder [r'firebase\.com$', r'https://flutter\.com'] für Python festlegen:

Node.js

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

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

Wenn Ihre Funktion öffentlich verfügbar sein soll, z. B. wenn sie für eine öffentliche API oder Website verwendet wird, legen Sie für die cors-Richtlinie den Wert true fest.

Funktion mit einer HTTP-Anfrage auslösen

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

Anfrage- und Antwortobjekte verwenden

Über das Anfrageobjekt haben Sie Zugriff auf die Eigenschaften 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."""
main.py

Wichtig :Achten Sie darauf, dass alle HTTP-Funktionen ordnungsgemäß beendet werden. Wenn Sie Funktionen richtig beenden, können Sie übermäßige Ladevorgänge durch Funktionen vermeiden, die zu lange laufen.

Vorhandene Express- oder Flask-Apps verwenden

Wenn Sie die App als Argument für den Anfrage-Handler 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 eine eigene eindeutige URL aufrufen. Verwenden Sie nach der Bereitstellung die genaue URL-Ausgabe aus der Befehlszeile.

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

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

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

Werte aus der Anfrage lesen

Im Beispiel für die date()-Funktion wird sowohl der URL-Parameter als auch der Textkörper auf einen format-Wert geprüft, um das zu verwendende Datums-/Uhrzeitformat 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

HTTP-Funktionen beenden

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

Node.js

Eine HTTP-Funktion muss immer mit send(), redirect() oder end() enden. Andernfalls wird die Funktion möglicherweise weiter ausgeführt und vom System zwangsweise beendet. Siehe auch Synchronisieren, asynchron und verspricht.

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

Firebase Hosting einbinden

Sie können eine HTTP-Funktion mit Firebase Hosting verknüpfen. Anfragen auf Ihrer Firebase Hosting-Website können über einen Proxy 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