Funktionen verwalten


Sie können Funktionen mit Firebase-Befehlszeilenbefehlen bereitstellen, löschen und ändern oder durch Festlegen von Laufzeitoptionen im Quellcode der Funktionen.

Funktionen bereitstellen

Führen Sie zum Bereitstellen von Funktionen den folgenden Firebase-Befehlszeilenbefehl aus:

firebase deploy --only functions

Standardmäßig werden mit der Firebase CLI alle Funktionen in Ihrer Quelle gleichzeitig bereitgestellt. Wenn Ihr Projekt mehr als fünf Funktionen enthält, empfehlen wir, das Flag --only mit bestimmten Funktionsnamen zu verwenden, um nur die Funktionen bereitzustellen, die Sie bearbeitet haben. Wenn Sie bestimmte Funktionen auf diese Weise bereitstellen, wird der Bereitstellungsprozess beschleunigt und Sie vermeiden Bereitstellungskontingente. Beispiel:

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

Wenn Sie eine große Anzahl von Funktionen bereitstellen, kann das Standardkontingent überschritten werden und Sie erhalten HTTP-Fehlermeldungen 429 oder 500. Lösung Stellen Sie Funktionen in Gruppen von maximal 10 Personen bereit.

In der Referenz zur Firebase-Befehlszeile finden Sie eine vollständige Liste der verfügbaren .

Standardmäßig sucht die Firebase-Befehlszeile im Ordner functions/ nach dem Quellcode verfügbar. Wenn Sie möchten, können Sie Funktionen organisieren. in Codebasen oder mehreren Dateisätzen.

Funktionen löschen

So können Sie zuvor bereitgestellte Funktionen löschen:

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

Bei allen Löschvorgängen werden Sie aufgefordert, die Funktion aus der Produktion zu entfernen.

Das explizite Löschen von Funktionen in der Firebase-Befehlszeile unterstützt mehrere Argumente sowie Funktionen und ermöglicht es Ihnen, eine Funktion anzugeben, die in einer bestimmten Region ausgeführt wird. Sie können die Bestätigungsaufforderung auch ü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, die aus der Datei entfernt wurden, aus der Produktion.

Name, Region oder Trigger einer Funktion ändern

Wenn Sie die Regionen umbenennen oder ändern oder Trigger für Funktionen auslösen, die Produktionstraffic verarbeiten können, führen Sie die Schritte in diesem Abschnitt aus, um während der Änderung Ereignisse hinzufügen. Bevor Sie diese Schritte ausführen, prüfen Sie, ob Ihre Funktion idempotent ist, da während der Umstellung sowohl die neue als auch die alte Version Ihrer Funktion gleichzeitig ausgeführt werden.

Funktion umbenennen

Wenn Sie eine Funktion umbenennen möchten, erstellen Sie eine neue umbenannte Version der Funktion in der Quelle und führen dann zwei separate Bereitstellungsbefehle aus. Mit dem ersten Befehl wird der eine neu benannte Funktion. Der zweite Befehl entfernt die zuvor bereitgestellte Version. Wenn Sie beispielsweise eine Node.js-Funktion namens webhook in webhookNew ändern möchten, ändern Sie den Code so:

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

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

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

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

Region(en) einer Funktion ändern

Wenn Sie die angegebenen Regionen für eine die den Produktionstraffic verarbeitet, können Sie Ereignisverluste verhindern, indem Sie die folgenden Schritte in der angegebenen Reihenfolge auszuführen:

  1. Benennen Sie die Funktion um und ändern Sie die Region oder Regionen nach Bedarf.
  2. Stellen Sie die umbenannte Funktion bereit, die dazu führt, dass vorübergehend derselbe Code in beiden Gruppen von Regionen ausgeführt wird.
  3. Vorherige Funktion löschen.

Wenn Sie z. B. eine Funktion haben, namens webhook, der sich derzeit in der Standardfunktionen-Region von us-central1 und Sie möchten ihn zu folgendem Ziel migrieren: asia-northeast1, müssen Sie zuerst Ihren Quellcode ändern, um den und die Region ändern.

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

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

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

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

Führen Sie dann zur Bereitstellung den folgenden Befehl aus:

firebase deploy --only functions:webhookAsia

Jetzt werden zwei identische Funktionen ausgeführt: webhook in us-central1 und webhookAsia in asia-northeast1.

Löschen Sie dann webhook:

firebase functions:delete webhook

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

Triggertyp einer Funktion ändern

Wenn Sie Ihr Cloud Functions for Firebase-Deployment im Laufe der Zeit entwickeln, den Triggertyp einer Funktion aus verschiedenen Gründen ändern müssen. Beispiel: können Sie von einer Art von Firebase Realtime Database oder Ereignis vom Typ Cloud Firestore in einen anderen Typ übertragen.

Es ist nicht möglich, den Ereignistyp einer Funktion nur durch Ändern des und firebase deploy ausführen. Um Fehler zu vermeiden, den Triggertyp einer Funktion folgendermaßen ändern:

  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 vorübergehend sowohl die alte als auch die neue Funktion ausgeführt werden.
  3. Löschen Sie die alte Funktion mithilfe der Firebase-Befehlszeile explizit aus der Produktion.

Wenn Sie beispielsweise eine Node.js-Funktion namens objectChanged mit dem alten onChange-Ereignistyp und Sie möchten ihn in onFinalize ändern. Benennen Sie zuerst den Ereignistyp um. und bearbeiten Sie sie so, dass sie den Ereignistyp onFinalize erhält.

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

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

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

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 wie die Node.js-Laufzeitversion und das Zeitlimit pro Funktion, die Speicherzuweisung und die Mindest-/Maximalzahl der Funktionsinstanzen auswählen.

Als Best Practice sollten diese Optionen (außer der Node.js-Version) für ein Konfigurationsobjekt im Funktionscode. Dieses RuntimeOptions ist die "Source of Truth" für die Laufzeitoptionen Ihrer Funktion. Überschreibungsoptionen, die mit einer anderen Methode (z. B. über die Google Cloud Console) festgelegt wurden oder gcloud CLI).

Wenn Ihr Entwicklungs-Workflow das manuelle Festlegen von Laufzeitoptionen über Google Cloud Console oder gcloud CLI verwenden und nicht möchten, dass diese Werte setzen Sie die Option preserveExternalChanges auf true. Wenn diese Option auf true festgelegt ist, führt Firebase die Laufzeitoptionen zusammen, die in Ihrem mit den Einstellungen der aktuell bereitgestellten Version Ihrer Funktion folgende Priorität:

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

Die Verwendung der Option preserveExternalChanges: true wird nicht empfohlen. für die meisten Szenarien, da Ihre ist nicht mehr die vollständige Quelle der Wahrheit für Laufzeitoptionen für Ihr Funktionen. Sehen Sie in diesem Fall in der Google Cloud Console nach oder verwenden Sie die gcloud Befehlszeile zum Anzeigen der vollständigen Konfiguration einer Funktion.

Node.js-Version festlegen

Das Firebase SDK für Cloud Functions ermöglicht eine Auswahl der Node.js-Laufzeit. Sie können festlegen, dass alle Funktionen in einem Projekt ausschließlich in der Laufzeitumgebung ausgeführt werden, die einer der folgenden unterstützten Node.js-Versionen entspricht:

  • Node.js 20 (Vorabversion)
  • Node.js 18
  • Node.js 16
  • Node.js 14

So legen Sie die Node.js-Version fest:

Sie können die Version im Feld engines der Datei package.json festlegen. -Datei, die während der Initialisierung im Verzeichnis functions/ erstellt wurde. Wenn Sie beispielsweise nur Version 18 verwenden möchten, bearbeiten Sie diese Zeile in package.json:

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

Wenn Sie den Yarn-Paketmanager verwenden oder Im Feld engines können Sie die Laufzeit für das Firebase SDK für Cloud Functions festlegen in firebase.json:

  {
    "functions": {
      "runtime": "nodejs18" // or nodejs14, nodejs16 or nodejs20
    }
  }

Die Befehlszeile verwendet den in firebase.json festgelegten Wert vor einem beliebigen Wert oder Bereich, den Sie in package.json separat festlegen.

Upgrade der Node.js-Laufzeit durchführen

So aktualisieren Sie die Node.js-Laufzeit:

  1. Ihr Projekt muss sich im Blaze-Preismodell befinden.
  2. Achten Sie darauf, dass Sie die Firebase CLI v11.18.0 oder höher verwenden.
  3. Ändern Sie den Wert engines in der Datei package.json, die während der Initialisierung im Verzeichnis functions/ erstellt wurde. Wenn Sie beispielsweise ein Upgrade von Version 16 auf Version 18 durchführen, wird der Eintrag sollte so aussehen: "engines": {"node": "18"}
  4. Testen Sie Ihre Änderungen optional 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, möglicherweise auf null herunterskalieren in Zeiten geringerem Traffic auftreten. Wenn Ihre App jedoch reduzierte und die Anzahl der Kaltstarts begrenzen möchten, können Sie Standardverhalten, indem eine Mindestanzahl von Containerinstanzen angegeben wird, und für Anfragen bereit sind.

Analog können Sie eine maximale Anzahl festlegen, um die Skalierung von Instanzen auf eingehende Anfragen antworten. Diese Einstellung zur Kostenkontrolle verwenden oder die Anzahl der Verbindungen zu einem Sicherungsdienst zu beschränken, Datenbank.

Anzahl der Kaltstarts reduzieren

Um die Mindestanzahl von Instanzen für eine Funktion im Quellcode festzulegen, verwenden Sie die Methode runWith . Diese Methode akzeptiert ein JSON-Objekt, das dem RuntimeOptions Schnittstelle, die den Wert für minInstances definiert. Beispiel: Diese Funktion legt mindestens 5 Instanzen zum Warmhalten fest:

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

Beachten Sie beim Festlegen eines Werts für minInstances Folgendes:

  • Wenn Cloud Functions for Firebase deine App über die minInstances-Einstellung hinaus skaliert, kommt es bei jeder Instanz über diesem Grenzwert zu einem Kaltstart.
  • Kaltstarts haben die schwerwiegendsten Auswirkungen bei Apps mit starkem Traffic. Wenn Ihr stark schwankende Zugriffszahlen aufweist und der minInstances-Wert hoch genug ist, werden mit jedem Anstieg der Zugriffszahlen deutlich weniger Kaltstarts verzeichnet, reduzierte Latenz. Bei Apps mit konstantem Datenverkehr sind Kaltstarts nicht die die Leistung erheblich beeinträchtigen.

  • Für Produktionsumgebungen kann es sinnvoll sein, Mindestinstanzen festzulegen. sollte in Testumgebungen normalerweise vermieden werden. Um in Ihrem Netzwerk auf null zu skalieren, aber dennoch Kaltstarts im Produktionsprojekt reduzieren, kann 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

Maximale Anzahl von Instanzen für eine Funktion begrenzen

Um die maximale Anzahl von Instanzen im Funktionsquellcode festzulegen, verwenden Sie die runWith . Diese Methode akzeptiert ein JSON-Objekt, das dem RuntimeOptions Schnittstelle, die definiert, Werte für maxInstances. Diese Funktion setzt z. B. ein Limit von 100 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 bis zum Limit maxInstances skaliert wird, werden neue Anfragen für 30 Sekunden in die Warteschlange gestellt und dann mit dem Antwortcode 429 Too Many Requests, wenn bis dahin keine Instanz verfügbar ist.

Weitere Informationen zu Best Practices für die Verwendung der Einstellungen für die maximale Anzahl von Instanzen finden Sie unter diese Best Practices für die Verwendung von maxInstances

Zeitlimit und Arbeitsspeicherzuweisung festlegen

In einigen Fällen können für Funktionen besondere Anforderungen für ein langes Zeitlimit gelten oder eine große Speicherzuweisung. Sie können diese Werte entweder im Google Cloud Console oder im Quellcode der Funktion (nur Firebase)

Um die Arbeitsspeicherzuweisung und das Zeitlimit im Quellcode von Funktionen festzulegen, verwenden Sie die Methode runWith im Firebase SDK für Cloud Functions 2.0.0 eingeführt. Diese Laufzeitoption akzeptiert ein JSON-Objekt, das den RuntimeOptions , die Werte für timeoutSeconds und memory definiert. Diese Speicherfunktion benötigt beispielsweise 1 GB Arbeitsspeicher, 300 Sekunden:

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 zugewiesene Speichermenge entspricht der zugewiesenen CPU für die Funktion, wie in dieser Liste gültiger Werte für memory beschrieben:

  • 128MB bis 200 MHz
  • 256MB bis 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 Arbeitsspeicherzuweisung und das Zeitlimit in der Google Cloud-Konsole fest:

  1. Wählen Sie in der Google Google Cloud Console Cloud Functions aus der Menü auf der linken Seite.
  2. Wählen Sie eine Funktion aus, indem Sie in der Funktionsliste auf ihren Namen klicken.
  3. Klicken Sie im Menü oben auf das Symbol Bearbeiten.
  4. Wählen Sie im Drop-down-Menü Zugewiesener Speicher eine Speicherzuweisung aus.
  5. Klicken Sie auf das Dreipunkt-Menü, um die erweiterten Optionen aufzurufen, und geben Sie in das Textfeld Zeitüberschreitung eine Zeit in Sekunden ein.
  6. Klicken Sie auf Speichern, um die Funktion zu aktualisieren.