Erste Schritte: Erste Funktionen schreiben, testen und bereitstellen


Arbeiten Sie diese Anleitung durch, um mit Cloud Functions loszulegen. die mit den erforderlichen Einrichtungsaufgaben beginnt und zwei verwandte Funktionen bereitstellen:

  • „Nachricht hinzufügen“ -Funktion, die eine URL anzeigt, die einen Textwert akzeptiert und schreibt an Cloud Firestore.
  • „Großschreibung verwenden“ Funktion, die bei einem Cloud Firestore-Schreibvorgang ausgelöst und transformiert wird den Text in Großbuchstaben.

Hier ist der vollständige Beispielcode mit den Funktionen:

Node.js

// The Cloud Functions for Firebase SDK to create Cloud Functions and triggers.
const {logger} = require("firebase-functions");
const {onRequest} = require("firebase-functions/v2/https");
const {onDocumentCreated} = require("firebase-functions/v2/firestore");

// The Firebase Admin SDK to access Firestore.
const {initializeApp} = require("firebase-admin/app");
const {getFirestore} = require("firebase-admin/firestore");

initializeApp();

// Take the text parameter passed to this HTTP endpoint and insert it into
// Firestore under the path /messages/:documentId/original
exports.addmessage = onRequest(async (req, res) => {
  // Grab the text parameter.
  const original = req.query.text;
  // Push the new message into Firestore using the Firebase Admin SDK.
  const writeResult = await getFirestore()
      .collection("messages")
      .add({original: original});
  // Send back a message that we've successfully written the message
  res.json({result: `Message with ID: ${writeResult.id} added.`});
});

// Listens for new messages added to /messages/:documentId/original
// and saves an uppercased version of the message
// to /messages/:documentId/uppercase
exports.makeuppercase = onDocumentCreated("/messages/{documentId}", (event) => {
  // Grab the current value of what was written to Firestore.
  const original = event.data.data().original;

  // Access the parameter `{documentId}` with `event.params`
  logger.log("Uppercasing", event.params.documentId, original);

  const uppercase = original.toUpperCase();

  // You must return a Promise when performing
  // asynchronous tasks inside a function
  // such as writing to Firestore.
  // Setting an 'uppercase' field in Firestore document returns a Promise.
  return event.data.ref.set({uppercase}, {merge: true});
});
index.js

Python

# The Cloud Functions for Firebase SDK to create Cloud Functions and set up triggers.
from firebase_functions import firestore_fn, https_fn

# The Firebase Admin SDK to access Cloud Firestore.
from firebase_admin import initialize_app, firestore
import google.cloud.firestore

app = initialize_app()


@https_fn.on_request()
def addmessage(req: https_fn.Request) -> https_fn.Response:
    """Take the text parameter passed to this HTTP endpoint and insert it into
    a new document in the messages collection."""
    # Grab the text parameter.
    original = req.args.get("text")
    if original is None:
        return https_fn.Response("No text parameter provided", status=400)

    firestore_client: google.cloud.firestore.Client = firestore.client()

    # Push the new message into Cloud Firestore using the Firebase Admin SDK.
    _, doc_ref = firestore_client.collection("messages").add({"original": original})

    # Send back a message that we've successfully written the message
    return https_fn.Response(f"Message with ID {doc_ref.id} added.")


@firestore_fn.on_document_created(document="messages/{pushId}")
def makeuppercase(event: firestore_fn.Event[firestore_fn.DocumentSnapshot | None]) -> None:
    """Listens for new documents to be added to /messages. If the document has
    an "original" field, creates an "uppercase" field containg the contents of
    "original" in upper case."""

    # Get the value of "original" if it exists.
    if event.data is None:
        return
    try:
        original = event.data.get("original")
    except KeyError:
        # No "original" field, so do nothing.
        return

    # Set the "uppercase" field.
    print(f"Uppercasing {event.params['pushId']}: {original}")
    upper = original.upper()
    event.data.reference.update({"uppercase": upper})
main.py

Informationen zu dieser Anleitung

Wir haben Cloud Firestore und durch HTTP ausgelöste Funktionen dafür ausgewählt weil diese Hintergrund-Trigger ausführlich getestet werden können, über die Firebase Local Emulator Suite. Dieses Toolset unterstützt auch Realtime Database, Cloud Storage, Pub/Sub-, Auth- und HTTP-aufrufbare Trigger. Andere Arten von Hintergrundtriggern wie Remote Config- und TestLab-Trigger können mithilfe von Tools, die auf dieser Seite nicht beschrieben werden, interaktiv getestet werden.

In den folgenden Abschnitten dieser Anleitung werden die Schritte beschrieben, die zum Erstellen, das Beispiel testen und bereitstellen.

Firebase-Projekt erstellen

  1. Klicken Sie in der Firebase-Konsole auf Projekt hinzufügen.

    • Wenn Sie einem vorhandenen Google Cloud-Projekt Firebase-Ressourcen hinzufügen möchten, geben Sie dessen Projektnamen ein oder wählen Sie es aus dem Drop-down-Menü aus.

    • Geben Sie den gewünschten Projektnamen ein, um ein neues Projekt zu erstellen. Optional können Sie auch die Projekt-ID bearbeiten, die unter dem Projektnamen angezeigt wird.

  2. Lesen und akzeptieren Sie die Nutzungsbedingungen von Firebase, wenn Sie dazu aufgefordert werden.

  3. Klicken Sie auf Weiter.

  4. (Optional) Richten Sie Google Analytics für Ihr Projekt ein, damit Sie für eine optimale Nutzung der folgenden Firebase-Produkte:

    Wählen Sie entweder ein vorhandenes Google Analytics-Konto oder ein neues Konto zu erstellen.

    Wenn Sie ein neues Konto erstellen, wählen Sie Ihr Analytics Berichtsstandort, dann akzeptieren die Datenfreigabeeinstellungen und Google Analytics-Bedingungen für Ihr Projekt.

  5. Klicken Sie auf Projekt erstellen (oder auf Firebase hinzufügen, wenn Sie ein vorhandenes Google Cloud-Projekt verwenden).

Firebase stellt automatisch Ressourcen für Ihr Firebase-Projekt bereit. Wann? wird die Übersichtsseite für Ihre Firebase-App in der Firebase-Konsole.

Umgebung und Firebase CLI einrichten

Node.js

Zum Schreiben von Funktionen benötigen Sie eine Node.js-Umgebung. und Sie benötigen die Firebase-Befehlszeile, um Funktionen in Cloud Functions-Laufzeit. Für die Installation von Node.js und npm wird der Node Version Manager empfohlen.

Wenn Node.js und npm installiert sind, Installieren Sie die Firebase-Befehlszeile mit Ihrer bevorzugten Methode. Verwenden Sie Folgendes, um die Befehlszeile über npm zu installieren:

npm install -g firebase-tools

Dadurch wird der global verfügbare Firebase-Befehl installiert. Wenn wenn der Befehl fehlschlägt, npm-Berechtigungen ändern. Führen Sie denselben Befehl noch einmal aus, um auf die neueste Version von firebase-tools zu aktualisieren.

Python

Sie benötigen eine Python-Umgebung. um Funktionen zu schreiben, und Sie benötigen die Firebase-Befehlszeile, um Funktionen in Cloud Functions-Laufzeit. Wir empfehlen die Verwendung von venv für Abhängigkeiten zu isolieren. Die Python-Versionen 3.10 und 3.11 unterstützt.

Wenn Sie Python installiert haben, Installieren Sie die Firebase-Befehlszeile mit Ihrer bevorzugten Methode.

Projekt initialisieren

Wenn Sie das Firebase SDK für Cloud Functions initialisieren, erstellen Sie ein leeres Projekt mit Abhängigkeiten und etwas Minimalbeispielcode. Wenn Sie Node.js verwenden, können Sie zum Erstellen von Funktionen entweder TypeScript oder JavaScript auswählen. Für die Zwecke dieser müssen Sie auch Cloud Firestore initialisieren.

So initialisieren Sie Ihr Projekt:

  1. Führen Sie firebase login aus, um sich über den Browser anzumelden und die Firebase-Befehlszeile.
  2. Rufen Sie das Firebase-Projektverzeichnis auf.
  3. Führen Sie firebase init firestore aus. Für diese Anleitung können Sie den Standardwert übernehmen wenn Sie nach Firestore-Regeln und -Indexdateien gefragt werden. Wenn Sie noch nicht Cloud Firestore in diesem Projekt nutzen, werden Sie auch müssen Sie einen Startmodus und einen Standort für Firestore auswählen, wie in Erste Schritte mit Cloud Firestore.
  4. Führen Sie firebase init functions aus. Sie werden von der Befehlszeile aufgefordert, ein vorhandenes Codebasis eingeben oder initialisieren und eine neue benennen. Wenn Sie gerade erst anfangen, reicht eine einzelne Codebasis am Standardspeicherort aus. Wenn Sie Ihre Implementierung später erweitern, können Sie Funktionen in Codebases organisieren.

  5. Die Befehlszeile bietet die folgenden Optionen für die Sprachunterstützung:

    • JavaScript
    • TypeScript
    • Python

    Wählen Sie für diese Anleitung JavaScript oder Python aus. Zum Authoring in TypeScript finden Sie unter Funktionen mit TypeScript schreiben.

  6. Die Befehlszeile bietet Ihnen die Möglichkeit, Abhängigkeiten zu installieren. Das ist sicher wenn Sie Abhängigkeiten auf andere Weise verwalten möchten.

Nachdem diese Befehle erfolgreich ausgeführt wurden, sieht Ihre Projektstruktur so aus: dies:

Node.js

myproject
+- .firebaserc    # Hidden file that helps you quickly switch between
|                 # projects with `firebase use`
|
+- firebase.json  # Describes properties for your project
|
+- functions/     # Directory containing all your functions code
      |
      +- .eslintrc.json  # Optional file containing rules for JavaScript linting.
      |
      +- package.json  # npm package file describing your Cloud Functions code
      |
      +- index.js      # Main source file for your Cloud Functions code
      |
      +- node_modules/ # Directory where your dependencies (declared in
                        # package.json) are installed

Bei Node.js enthält die bei der Initialisierung erstellte Datei package.json einen wichtigen Schlüssel: "engines": {"node": "18"}. Gibt Ihre Node.js-Version für Funktionen schreiben und bereitstellen. Sie können Wählen Sie andere unterstützte Versionen aus.

Python

myproject
+- .firebaserc    # Hidden file that helps you quickly switch between
|                 # projects with `firebase use`
|
+- firebase.json  # Describes properties for your project
|
+- functions/     # Directory containing all your functions code
      |
      +- main.py      # Main source file for your Cloud Functions code
      |
      +- requirements.txt  #  List of the project's modules and packages 
      |
      +- venv/ # Directory where your dependencies are installed

Erforderliche Module importieren und App initialisieren

Nachdem Sie die Einrichtung abgeschlossen haben, können Sie öffnen Sie das Quellverzeichnis und fügen Sie Code wie in der folgenden Abschnitten. Für dieses Beispiel muss Ihr Projekt den Cloud Functions und Admin SDK-Module. Linien hinzufügen wie folgt in Ihre Quelldatei einfügen:

Node.js

// The Cloud Functions for Firebase SDK to create Cloud Functions and triggers.
const {logger} = require("firebase-functions");
const {onRequest} = require("firebase-functions/v2/https");
const {onDocumentCreated} = require("firebase-functions/v2/firestore");

// The Firebase Admin SDK to access Firestore.
const {initializeApp} = require("firebase-admin/app");
const {getFirestore} = require("firebase-admin/firestore");

initializeApp();
index.js

Python

# The Cloud Functions for Firebase SDK to create Cloud Functions and set up triggers.
from firebase_functions import firestore_fn, https_fn

# The Firebase Admin SDK to access Cloud Firestore.
from firebase_admin import initialize_app, firestore
import google.cloud.firestore

app = initialize_app()
main.py

Diese Zeilen laden die erforderlichen Module und Initialisieren einer admin-Anwendungsinstanz, von der aus Cloud Firestore-Änderungen vorgenommen werden können. Überall dort, wo das Admin SDK unterstützt wird, z. B. für FCM, Authentication und Firebase Realtime Database, ist es eine leistungsstarke Möglichkeit, Firebase mit Cloud Functions zu integrieren.

Die Firebase-Befehlszeile wird automatisch Bei der Initialisierung werden das Firebase Admin SDK und das Firebase SDK für Cloud Functions-Module installiert für Ihr Projekt. Weitere Informationen zum Hinzufügen von Drittanbieterbibliotheken zu Ihrem Projekt hinzugefügt haben, Abhängigkeiten verarbeiten.

Fügen Sie das Feld „Nachricht hinzufügen“ hinzu, Funktion

Für das Feld „Nachricht hinzufügen“ fügen Sie der Quelldatei diese Zeilen hinzu:

Node.js

// Take the text parameter passed to this HTTP endpoint and insert it into
// Firestore under the path /messages/:documentId/original
exports.addmessage = onRequest(async (req, res) => {
  // Grab the text parameter.
  const original = req.query.text;
  // Push the new message into Firestore using the Firebase Admin SDK.
  const writeResult = await getFirestore()
      .collection("messages")
      .add({original: original});
  // Send back a message that we've successfully written the message
  res.json({result: `Message with ID: ${writeResult.id} added.`});
});
index.js

Python

@https_fn.on_request()
def addmessage(req: https_fn.Request) -> https_fn.Response:
    """Take the text parameter passed to this HTTP endpoint and insert it into
    a new document in the messages collection."""
    # Grab the text parameter.
    original = req.args.get("text")
    if original is None:
        return https_fn.Response("No text parameter provided", status=400)

    firestore_client: google.cloud.firestore.Client = firestore.client()

    # Push the new message into Cloud Firestore using the Firebase Admin SDK.
    _, doc_ref = firestore_client.collection("messages").add({"original": original})

    # Send back a message that we've successfully written the message
    return https_fn.Response(f"Message with ID {doc_ref.id} added.")
main.py

Die Schaltfläche „Nachricht hinzufügen“ ist ein HTTP-Endpunkt. Jede Anfrage an den Endpunkt werden Anfrage- und Antwortobjekte an die den Anfrage-Handler für Ihre Plattform (onRequest()) oder on_request).

HTTP-Funktionen sind synchron (ähnlich aufrufbare Funktionen). Sie sollten daher eine Antwort senden. so schnell wie möglich ausführen und Arbeiten mit Cloud Firestore aufschieben. Die HTTP-Funktion „add message“ übergibt einen Textwert an den HTTP-Endpunkt und fügt ihn unter dem Pfad /messages/:documentId/original in die Datenbank ein.

Fügen Sie das Tag „Großbuchstaben machen“ hinzu. Funktion

Für das Wort „in Großbuchstaben“ fügen Sie der Quelldatei diese Zeilen hinzu:

Node.js

// Listens for new messages added to /messages/:documentId/original
// and saves an uppercased version of the message
// to /messages/:documentId/uppercase
exports.makeuppercase = onDocumentCreated("/messages/{documentId}", (event) => {
  // Grab the current value of what was written to Firestore.
  const original = event.data.data().original;

  // Access the parameter `{documentId}` with `event.params`
  logger.log("Uppercasing", event.params.documentId, original);

  const uppercase = original.toUpperCase();

  // You must return a Promise when performing
  // asynchronous tasks inside a function
  // such as writing to Firestore.
  // Setting an 'uppercase' field in Firestore document returns a Promise.
  return event.data.ref.set({uppercase}, {merge: true});
});
index.js

Python

@firestore_fn.on_document_created(document="messages/{pushId}")
def makeuppercase(event: firestore_fn.Event[firestore_fn.DocumentSnapshot | None]) -> None:
    """Listens for new documents to be added to /messages. If the document has
    an "original" field, creates an "uppercase" field containg the contents of
    "original" in upper case."""

    # Get the value of "original" if it exists.
    if event.data is None:
        return
    try:
        original = event.data.get("original")
    except KeyError:
        # No "original" field, so do nothing.
        return

    # Set the "uppercase" field.
    print(f"Uppercasing {event.params['pushId']}: {original}")
    upper = original.upper()
    event.data.reference.update({"uppercase": upper})
main.py

Das Wort „Großbuchstaben machen“ wird ausgeführt, wenn Cloud Firestore geschrieben wird, und definieren das zu überwachende Dokument. Aus Leistungsgründen sollte so spezifisch wie möglich sein.

In geschweiften Klammern, z. B. {documentId}, umschließen Sie „parameters“. Platzhalter die ihre übereinstimmenden Daten im Callback bereitstellen. Cloud Firestore löst den -Rückruf zurück, wenn neue Nachrichten hinzugefügt werden.

In Node.js sind ereignisgesteuerte Funktionen wie Cloud Firestore-Ereignisse asynchron. Die Callback-Funktion sollte entweder ein null, ein Objekt, oder ein Promise. Wenn Sie nichts zurückgeben, wird das Zeitlimit für die Funktion überschritten, ein Fehler signalisiert und und der Vorgang wird wiederholt. Weitere Informationen finden Sie unter Synchronisieren, asynchron und verspricht.

Ausführung von Funktionen emulieren

Die Firebase Local Emulator Suite ermöglicht es Ihnen, Anwendungen auf Ihrem lokalen Computer zu erstellen und zu testen, anstatt sie auf ein Firebase-Projekt. Lokale Tests während der Entwicklung werden dringend empfohlen, weil es das Risiko von Codierungsfehlern verringert, Kosten in einer Produktionsumgebung verursachen (z. B. eine Endlosschleife).

So emulieren Sie die Funktionen:

  1. Führen Sie firebase emulators:start aus und prüfen Sie die Ausgabe für die URL der Emulator Suite UI. Die Standardeinstellung ist localhost:4000, wird aber möglicherweise auf einem anderen auf Ihrem Computer. Geben Sie diese URL in Ihren Browser ein, um die Emulator Suite UI

  2. Ausgabe von firebase emulators:start prüfen für die URL der HTTP-Funktion. Sie sieht in etwa so aus wie http://localhost:5001/MY_PROJECT/us-central1/addMessage, mit folgenden Unterschieden:

    1. MY_PROJECT wird durch Ihre Projekt-ID ersetzt.
    2. Der Port kann auf Ihrem lokalen Computer anders sein.

  3. Fügen Sie den Abfragestring ?text=uppercaseme am Ende der URL der Funktion hinzu. Dies sollte in etwa so aussehen: http://localhost:5001/MY_PROJECT/us-central1/addMessage?text=uppercaseme Optional können Sie die Nachricht „uppercaseme“ durch eine benutzerdefinierte Nachricht ersetzen.

  4. Öffnen Sie die URL in einem neuen Tab in Ihrem Browser, um eine neue Nachricht zu erstellen.

  5. Sehen Sie sich die Auswirkungen der Funktionen in Emulator Suite UI an:

    1. Auf dem Tab Logs sollten neue Logs angezeigt werden, die darauf hinweisen, dass Ihre HTTP-Funktionen wurden erfolgreich ausgeführt:

      i functions: Beginning execution of "addMessage"

      i functions: Beginning execution of "makeUppercase"

    2. Auf dem Tab Firestore sollten Sie ein Dokument mit dem Originaldokument sehen. sowie die Version Ihrer Nachricht in Großbuchstaben (falls es sich um eine "Großbuchstaben" angezeigt wird, wird "GROẞBUCHSTABEN" angezeigt.

Funktionen in einer Produktionsumgebung bereitstellen

Sobald Ihre Funktionen im Emulator wie gewünscht funktionieren, können Sie mit der Bereitstellung, dem Testen und dem Ausführen in der Produktionsumgebung fortfahren. Wichtige Hinweise für die Bereitstellung in der Produktion, muss das Blaze-Preismodell haben. Weitere Informationen finden Sie unter Preise für Cloud Functions.

Stellen Sie zum Abschließen der Anleitung die Funktionen bereit und führen Sie dann den folgenden Befehl aus: .

  1. Führen Sie den folgenden Befehl aus, um die Funktionen bereitzustellen:

     firebase deploy --only functions

    Nachdem Sie diesen Befehl ausgeführt haben, gibt die Firebase-Befehlszeile die URL für alle Endpunkte der HTTP-Funktion aus. Im Terminal sollte eine Zeile wie die folgende angezeigt werden:

    Function URL (addMessage): https://us-central1-MY_PROJECT.cloudfunctions.net/addMessage

    Die URL enthält Ihre Projekt-ID und eine Region für die HTTP- . Auch wenn Sie sich jetzt noch keine Gedanken darüber machen müssen, für Funktionen einen Standort angeben, die Netzwerklatenz minimieren.

    Wenn Zugriffsfehler wie „Zugriff auf Projekt kann nicht autorisiert werden“ auftreten, prüfen Sie den Alias Ihres Projekts.

  2. Fügen Sie mithilfe der von der Befehlszeile ausgegebenen URL einen Textabfrageparameter hinzu. und in einem Browser öffnen:

    https://us-central1-MY_PROJECT.cloudfunctions.net/addMessage?text=uppercasemetoo

    Die Funktion wird ausgeführt und leitet den Browser an den Firebase-Konsole am Datenbankspeicherort wo die Textzeichenfolge gespeichert wird. Dieses Schreibereignis löst das Ereignis „make Großbuchstaben“ aus die einen Großbuchstaben schreibt, Version des Strings.

Nach dem Bereitstellen und Ausführen von Funktionen können Sie Rufen Sie Logs in der Google Cloud-Konsole auf. Wenn Sie Funktionen löschen müssen in der Entwicklung oder Produktion verwenden, verwenden Sie die Firebase-Befehlszeile.

In der Produktionsumgebung möchten Sie vielleicht die Funktionsleistung und -steuerung optimieren. die Mindest- und Höchstanzahl der auszuführenden Instanzen festzulegen. Weitere Informationen finden Sie unter Skalierungsverhalten steuern finden Sie weitere Informationen zu den Laufzeitoptionen.

Nächste Schritte

In dieser Dokumentation erfahren Sie mehr darüber, wie Sie Funktionen verwalten für Cloud Functions und wie Sie zur Verarbeitung aller Ereignistypen, die von Cloud Functions unterstützt werden.

Um mehr über Cloud Functions zu erfahren, könnte auch Folgendes tun: