Catch up on highlights from Firebase at Google I/O 2023. Learn more

Funktionen verwalten


Sie können Funktionen mithilfe von Firebase-CLI-Befehlen oder durch Festlegen von Laufzeitoptionen in Ihrem Funktionsquellcode bereitstellen, löschen und ändern.

Funktionen bereitstellen

Führen Sie zum Bereitstellen von Funktionen diesen Firebase-CLI-Befehl aus:

firebase deploy --only functions

Standardmäßig stellt die Firebase-CLI alle Funktionen in Ihrer Quelle gleichzeitig bereit. Wenn Ihr Projekt mehr als 5 Funktionen enthält, empfehlen wir Ihnen, das Flag --only mit bestimmten Funktionsnamen zu verwenden, um nur die von Ihnen bearbeiteten Funktionen bereitzustellen. Das Bereitstellen bestimmter Funktionen auf diese Weise beschleunigt den Bereitstellungsprozess und hilft Ihnen, das Erreichen von Bereitstellungskontingenten zu vermeiden. Zum Beispiel:

firebase deploy --only functions:addMessage,functions:makeUppercase

Wenn Sie eine große Anzahl von Funktionen bereitstellen, überschreiten Sie möglicherweise das Standardkontingent und erhalten HTTP-Fehlermeldungen vom Typ 429 oder 500. Um dieses Problem zu lösen, stellen Sie Funktionen in Gruppen von 10 oder weniger bereit.

Die vollständige Liste der verfügbaren Befehle finden Sie in der Firebase-CLI-Referenz .

Standardmäßig sucht die Firebase CLI im Ordner functions/ nach dem Quellcode. Wenn Sie möchten, können Sie Funktionen in Codebasen oder mehreren Sätzen von Dateien organisieren .

Funktionen löschen

Sie können zuvor bereitgestellte Funktionen auf folgende Weise löschen:

  • explizit in der Firebase CLI mit functions:delete
  • explizit in der Google Cloud Console .
  • implizit durch Entfernen der Funktion aus der Quelle vor der Bereitstellung.

Alle Löschvorgänge fordern Sie zur Bestätigung auf, bevor Sie die Funktion aus der Produktion entfernen.

Das explizite Löschen von Funktionen in der Firebase CLI unterstützt mehrere Argumente sowie Funktionsgruppen und ermöglicht es Ihnen, eine Funktion anzugeben, die in einer bestimmten Region ausgeführt wird. Außerdem können Sie die Bestätigungsaufforderung überschreiben.

# Delete all functions that match the specified name in all regions.
firebase functions:delete myFunction

# Delete a specified function running in a specific region.
firebase functions:delete myFunction --region us-east-1

# Delete more than one function
firebase functions:delete myFunction myOtherFunction

# Delete a specified functions group.
firebase functions:delete groupA

# Bypass the confirmation prompt.
firebase functions:delete myFunction --force

Beim impliziten Löschen von Funktionen parst firebase deploy Ihre Quelle und entfernt alle Funktionen aus der Produktion, die aus der Datei entfernt wurden.

Ändern Sie den Namen, die Region oder den Trigger einer Funktion

Wenn Sie die Regionen umbenennen oder ändern oder für Funktionen auslösen, die den Produktionsdatenverkehr verarbeiten, befolgen Sie die Schritte in diesem Abschnitt, um zu vermeiden, dass während der Änderung Ereignisse verloren gehen. Bevor Sie diese Schritte ausführen, stellen Sie zunächst sicher, dass Ihre Funktion idempotent ist, da sowohl die neue Version als auch die alte Version Ihrer Funktion während der Änderung gleichzeitig ausgeführt werden.

Benennen Sie eine Funktion um

Um eine Funktion umzubenennen, erstellen Sie eine neue umbenannte Version der Funktion in Ihrer Quelle und führen Sie dann zwei separate Bereitstellungsbefehle aus. Der erste Befehl stellt die neu benannte Funktion bereit, und der zweite Befehl entfernt die zuvor bereitgestellte Version. Wenn Sie beispielsweise eine Node.js-Funktion namens webhook haben, die Sie in webhookNew ändern möchten, überarbeiten Sie den Code wie folgt:

// before
const functions = require('firebase-functions');

exports.webhook = functions.https.onRequest((req, res) => {
    res.send("Hello");
});

// after
const functions = require('firebase-functions');

exports.webhookNew = functions.https.onRequest((req, res) => {
    res.send("Hello");
});

Führen Sie dann die folgenden Befehle aus, um die neue Funktion bereitzustellen:

# Deploy new function called webhookNew
firebase deploy --only functions:webhookNew

# Wait until deployment is done; now both webhookNew and webhook are running

# Delete webhook
firebase functions:delete webhook

Ändern Sie die Region oder Regionen einer Funktion

Wenn Sie die angegebenen Regionen für eine Funktion ändern, die den Produktionsdatenverkehr verarbeitet, können Sie den Verlust von Ereignissen verhindern, indem Sie die folgenden Schritte der Reihe nach ausführen:

  1. Benennen Sie die Funktion um und ändern Sie ihre Region oder Regionen wie gewünscht.
  2. Stellen Sie die umbenannte Funktion bereit, was dazu führt, dass vorübergehend derselbe Code in beiden Gruppen von Regionen ausgeführt wird.
  3. Löschen Sie die vorherige Funktion.

Wenn Sie beispielsweise eine Funktion namens webhook haben, die sich derzeit in der Standardfunktionsregion us-central1 befindet, und Sie sie nach asia-northeast1 migrieren möchten, müssen Sie zuerst Ihren Quellcode ändern, um die Funktion umzubenennen und die Region zu überarbeiten .

// before
const functions = require('firebase-functions');

exports.webhook = functions
    .https.onRequest((req, res) => {
            res.send("Hello");
    });

// after
const functions = require('firebase-functions');

exports.webhookAsia = functions
    .region('asia-northeast1')
    .https.onRequest((req, res) => {
            res.send("Hello");
    });

Stellen Sie dann bereit, indem Sie Folgendes ausführen:

firebase deploy --only functions:webhookAsia

Jetzt laufen zwei identische Funktionen: webhook läuft in us-central1 und webhookAsia läuft in asia-northeast1 .

Löschen Sie dann webhook :

firebase functions:delete webhook

Jetzt gibt es nur noch eine Funktion - webhookAsia , die in asia-northeast1 ausgeführt wird.

Triggertyp einer Funktion ändern

Bei der Entwicklung Ihrer Cloud Functions for Firebase-Bereitstellung im Laufe der Zeit müssen Sie möglicherweise den Auslösertyp einer Funktion aus verschiedenen Gründen ändern. Beispielsweise möchten Sie möglicherweise von einem Firebase Realtime Database- oder Cloud Firestore-Ereignistyp zu einem anderen Typ wechseln.

Es ist nicht möglich, den Ereignistyp einer Funktion zu ändern, indem Sie einfach den Quellcode ändern und firebase deploy ausführen. Um Fehler zu vermeiden, ändern Sie den Triggertyp einer Funktion wie folgt:

  1. Ändern Sie den Quellcode so, dass er eine neue Funktion mit dem gewünschten Triggertyp enthält.
  2. Stellen Sie die Funktion bereit, was dazu führt, dass sowohl die alte als auch die neue Funktion vorübergehend ausgeführt werden.
  3. Löschen Sie die alte Funktion explizit aus der Produktion mithilfe der Firebase-CLI.

Wenn Sie beispielsweise eine Node.js-Funktion mit dem Namen objectChanged hatten, die den alten Ereignistyp onChange hat, und Sie sie in onFinalize ändern möchten, benennen Sie die Funktion zuerst um und bearbeiten Sie sie so, dass sie den Ereignistyp onFinalize enthält.

// before
const functions = require('firebase-functions');

exports.objectChanged = functions.storage.object().onChange((object) => {
    return console.log('File name is: ', object.name);
});

// after
const functions = require('firebase-functions');

exports.objectFinalized = functions.storage.object().onFinalize((object) => {
    return console.log('File name is: ', object.name);
});

Führen Sie dann die folgenden Befehle aus, um zuerst die neue Funktion zu erstellen, bevor Sie die alte Funktion löschen:

# Create new function objectFinalized
firebase deploy --only functions:objectFinalized

# Wait until deployment is done; now both objectChanged and objectFinalized are running

# Delete objectChanged
firebase functions:delete objectChanged

Laufzeitoptionen festlegen

Mit Cloud Functions for Firebase können Sie Laufzeitoptionen auswählen, z. B. die Node.js-Laufzeitversion und das Zeitlimit pro Funktion, die Speicherzuweisung und minimale/maximale Funktionsinstanzen.

Als Best Practice sollten diese Optionen (mit Ausnahme der Node.js-Version) für ein Konfigurationsobjekt innerhalb des Funktionscodes festgelegt werden. Dieses RuntimeOptions Objekt ist die Quelle der Wahrheit für die Laufzeitoptionen Ihrer Funktion und überschreibt Optionen, die mit einer anderen Methode (z. B. über die Google Cloud-Konsole oder die gcloud-Befehlszeilenschnittstelle) festgelegt wurden.

Wenn Ihr Entwicklungsworkflow das manuelle Festlegen von Laufzeitoptionen über die Google Cloud-Konsole oder die gcloud-Befehlszeilenschnittstelle umfasst und Sie nicht möchten, dass diese Werte bei jeder Bereitstellung überschrieben werden, legen Sie die preserveExternalChanges auf true fest. Wenn diese Option auf true gesetzt ist, führt Firebase die in Ihrem Code festgelegten Laufzeitoptionen mit den Einstellungen der aktuell bereitgestellten Version Ihrer Funktion mit der folgenden Priorität zusammen:

  1. Die Option wird im Funktionscode festgelegt: Externe Änderungen überschreiben.
  2. Die Option ist im Funktionscode auf RESET_VALUE gesetzt: Externe Änderungen mit dem Standardwert überschreiben.
  3. Die Option ist nicht im Funktionscode festgelegt, wird jedoch in der aktuell bereitgestellten Funktion festgelegt: Verwenden Sie die in der bereitgestellten Funktion angegebene Option.

Für die meisten Szenarien wird die Verwendung der preserveExternalChanges: true nicht empfohlen , da Ihr Code dann nicht mehr die vollständige Quelle der Wahrheit für Laufzeitoptionen für Ihre Funktionen ist. Wenn Sie es verwenden, überprüfen Sie die Google Cloud-Konsole oder verwenden Sie die gcloud-Befehlszeilenschnittstelle, um die vollständige Konfiguration einer Funktion anzuzeigen.

Legen Sie die Node.js-Version fest

Firebase SDK for Cloud Functions 2.0.0 und höher ermöglicht eine Auswahl der Node.js-Laufzeit. Sie können alle Funktionen in einem Projekt ausschließlich auf der Laufzeitumgebung ausführen, die einer dieser unterstützten Node.js-Versionen entspricht:

  • Node.js 18
  • Node.js 16
  • Node.js 14

So legen Sie die Node.js-Version fest:

Legen Sie die Version im Feld engines in der Datei package.json fest, die während der Initialisierung in Ihrem Verzeichnis functions/ erstellt wurde. Um beispielsweise nur Version 18 zu verwenden, bearbeiten Sie diese Zeile in package.json :

  "engines": {"node": "18"}

Das engines Feld ist erforderlich; Sie muss eine der unterstützten Node.js-Versionen angeben, damit Sie Funktionen bereitstellen und ausführen können.

Aktualisieren Sie Ihre Node.js-Laufzeit

So aktualisieren Sie Ihre Node.js-Laufzeit:

  1. Stellen Sie sicher, dass Ihr Projekt im Blaze-Preisplan enthalten ist.
  2. Stellen Sie sicher, dass Sie Firebase CLI v11.18.0 oder höher verwenden.
  3. Ändern Sie den engines Wert in der Datei package.json , die während der Initialisierung in Ihrem Verzeichnis functions/ erstellt wurde. Wenn Sie beispielsweise von Version 16 auf Version 18 aktualisieren, sollte der Eintrag so aussehen: "engines": {"node": "18"}
  4. Testen Sie optional Ihre Änderungen mit der Firebase Local Emulator Suite .
  5. Stellen Sie alle Funktionen neu bereit.

Skalierungsverhalten steuern

Standardmäßig skaliert Cloud Functions for Firebase die Anzahl der ausgeführten Instanzen basierend auf der Anzahl der eingehenden Anfragen und kann in Zeiten mit reduziertem Datenverkehr möglicherweise auf null Instanzen herunterskaliert werden. Wenn Ihre App jedoch eine geringere Latenz erfordert und Sie die Anzahl der Kaltstarts begrenzen möchten, können Sie dieses Standardverhalten ändern, indem Sie eine Mindestanzahl von Containerinstanzen angeben, die warm und bereit gehalten werden sollen, Anforderungen zu erfüllen.

Ebenso können Sie eine maximale Anzahl festlegen, um die Skalierung von Instanzen als Reaktion auf eingehende Anfragen zu begrenzen. Verwenden Sie diese Einstellung, um Ihre Kosten zu kontrollieren oder die Anzahl der Verbindungen zu einem Sicherungsdienst, z. B. zu einer Datenbank, zu begrenzen.

Reduzieren Sie die Anzahl der Kaltstarts

Verwenden Sie die runWith Methode, um die Mindestanzahl von Instanzen für eine Funktion im Quellcode festzulegen. Diese Methode akzeptiert ein JSON-Objekt, das der Schnittstelle RuntimeOptions entspricht, die den Wert für minInstances definiert. Diese Funktion legt beispielsweise mindestens 5 Instanzen fest, um warm zu bleiben:

exports.getAutocompleteResponse = functions
    .runWith({
      // Keep 5 instances warm for this latency-critical function
      minInstances: 5,
    })
    .https.onCall((data, context) => {
      // Autocomplete a user's search term
    });
index.js

Hier sind einige Dinge, die Sie beim Festlegen eines Werts für minInstances beachten sollten:

  • Wenn Cloud Functions for Firebase Ihre App über Ihre minInstances Einstellung hinaus skaliert, erleben Sie einen Kaltstart für jede Instanz über diesem Schwellenwert.
  • Kaltstarts haben die schwerwiegendsten Auswirkungen auf Apps mit hohem Datenverkehr. Wenn Ihre App einen spitzen Datenverkehr aufweist und Sie einen minInstances Wert hoch genug festlegen, dass Kaltstarts bei jedem Anstieg des Datenverkehrs reduziert werden, wird die Latenz deutlich reduziert. Bei Apps mit konstantem Datenverkehr wirken sich Kaltstarts wahrscheinlich nicht stark auf die Leistung aus.

  • Das Festlegen von Mindestinstanzen kann für Produktionsumgebungen sinnvoll sein, sollte jedoch in Testumgebungen normalerweise vermieden werden. Um in Ihrem Testprojekt auf null zu skalieren, aber dennoch Kaltstarts in Ihrem Produktionsprojekt zu reduzieren, können Sie minInstances basierend auf der Umgebungsvariable FIREBASE_CONFIG festlegen:

    // Get Firebase project id from `FIREBASE_CONFIG` environment variable
const envProjectId = JSON.parse(process.env.FIREBASE_CONFIG).projectId;

exports.renderProfilePage = functions
    .runWith({
      // Keep 5 instances warm for this latency-critical function
      // in production only. Default to 0 for test projects.
      minInstances: envProjectId === "my-production-project" ? 5 : 0,
    })
    .https.onRequest((req, res) => {
      // render some html
    });
    index.js

Begrenzen Sie die maximale Anzahl von Instanzen für eine Funktion

Verwenden Sie die runWith Methode, um maximale Instanzen im Funktionsquellcode festzulegen. Diese Methode akzeptiert ein JSON-Objekt, das der RuntimeOptions -Schnittstelle entspricht, die Werte für maxInstances definiert. Diese Funktion legt beispielsweise ein Limit von 100 Instanzen fest, um eine hypothetische Legacy-Datenbank nicht zu überlasten:

exports.mirrorOrdersToLegacyDatabase = functions
    .runWith({
      // Legacy database only supports 100 simultaneous connections
      maxInstances: 100,
    })
    .firestore.document("orders/{orderId}")
    .onWrite((change, context) => {
      // Connect to legacy database
    });
index.js

Wenn eine HTTP-Funktion auf das maxInstances -Limit hochskaliert wird, werden neue Anforderungen 30 Sekunden lang in die Warteschlange gestellt und dann mit dem Antwortcode 429 Too Many Requests abgelehnt, wenn bis dahin keine Instanz verfügbar ist.

Um mehr über Best Practices für die Verwendung maximaler Instanzeinstellungen zu erfahren, sehen Sie sich diese Best Practices für die Verwendung maxInstances an.

Zeitüberschreitung und Speicherzuweisung festlegen

In einigen Fällen haben Ihre Funktionen möglicherweise besondere Anforderungen an einen langen Zeitüberschreitungswert oder eine große Speicherzuweisung. Sie können diese Werte entweder in der Google Cloud Console oder im Funktionsquellcode (nur Firebase) festlegen.

Um die Speicherzuweisung und das Zeitlimit im Funktionsquellcode festzulegen, verwenden Sie den Parameter runWith , der im Firebase SDK für Cloud Functions 2.0.0 eingeführt wurde. Diese Laufzeitoption akzeptiert ein JSON-Objekt, das der Schnittstelle RuntimeOptions entspricht, die Werte für timeoutSeconds und memory definiert. Diese Speicherfunktion verwendet beispielsweise 1 GB Speicher und läuft nach 300 Sekunden ab:

exports.convertLargeFile = functions
    .runWith({
      // Ensure the function has enough memory and time
      // to process large files
      timeoutSeconds: 300,
      memory: "1GB",
    })
    .storage.object()
    .onFinalize((object) => {
      // Do some complicated things that take a lot of memory and time
    });
index.js

Der Maximalwert für timeoutSeconds ist 540 oder 9 Minuten. Die einer Funktion gewährte Speichermenge entspricht der für die Funktion zugewiesenen CPU, wie in dieser Liste gültiger Werte für memory aufgeführt:

  • 128MB – 200 MHz
  • 256MB – 400 MHz
  • 512MB – 800 MHz
  • 1GB – 1,4 GHz
  • 2GB – 2,4 GHz
  • 4GB – 4,8 GHz
  • 8GB – 4,8 GHz

So legen Sie die Speicherzuweisung und das Zeitlimit in der Google Cloud Console fest:

  1. Wählen Sie in der Google Google Cloud Console im linken Menü Cloud Functions aus.
  2. Wählen Sie eine Funktion aus, indem Sie in der Funktionsliste auf ihren Namen klicken.
  3. Klicken Sie im oberen Menü auf das Symbol Bearbeiten .
  4. Wählen Sie eine Speicherzuweisung aus dem Dropdown-Menü mit der Bezeichnung Zugewiesener Speicher aus.
  5. Klicken Sie auf Mehr , um die erweiterten Optionen anzuzeigen, und geben Sie eine Anzahl von Sekunden in das Textfeld Timeout ein.
  6. Klicken Sie auf Speichern, um die Funktion zu aktualisieren.