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.

Zusätzliche HTTP-Optionen

CORS (Cross-Origin Resource Sharing) konfigurieren

Mit der Option cors können Sie steuern, welche Ursprünge auf Ihre Funktion zugreifen können. Für HTTP-Funktionen ist CORS standardmäßig nicht konfiguriert. 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 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 für Node.js auf [/firebase\.com$/, 'https://flutter.com'] oder für Python auf [r'firebase\.com$', r'https://flutter\.com'] festlegen:

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

exports.sayHello = onRequest(
  { cors: [/firebase\.com$/, "https://flutter.com"] },
  (req, res) => {
    res.status(200).send("Hello world!");
  }
);

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 eine öffentliche API oder Website bereitstellt, legen Sie die cors-Richtlinie auf 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 „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 gemäß einem URL-Suchparameter und sendet das Ergebnis in der HTTP-Antwort.

Anfrage- und Antwortobjekte verwenden

Über das Anfrageobjekt haben Sie Zugriff auf die Attribute der HTTP-Anfrage, die vom Client gesendet wurde. Über das Antwortobjekt können Sie eine Antwort an den Client zurücksenden.

exports.date = onRequest(
    {timeoutSeconds: 1200, region: ["us-west1", "us-east1"]},
    (req, res) => {
// ...
});

@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

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:

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

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 CLI ausgegeben wird.

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

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

Bei der Routenplanung von Express- und Flask-Apps wird der Funktionsname als Präfix für die URL-Pfade in der von Ihnen definierten App hinzugefügt.

Werte aus der Anfrage lesen

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

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

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

HTTP-Funktionen beenden

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

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

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

Integration in Firebase Hosting

Sie können eine HTTP-Funktion mit Firebase Hosting verbinden. Anfragen an Ihre 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