Funktionen verwalten


Sie können Funktionen mithilfe von Firebase-CLI-Befehlen oder durch Festlegen von Laufzeitoptionen im Quellcode Ihrer Funktionen bereitstellen, löschen und ändern.

Funktionen bereitstellen

Um Funktionen bereitzustellen, führen Sie 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. Die Bereitstellung bestimmter Funktionen auf diese Weise beschleunigt den Bereitstellungsprozess und hilft Ihnen, zu vermeiden, dass Sie auf Bereitstellungskontingente stoßen. 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 429- oder 500-Fehlermeldungen. Um dieses Problem zu lösen, stellen Sie Funktionen in Gruppen von maximal 10 Personen 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 Dateisätzen 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.

Bei allen Löschvorgängen werden Sie zur Bestätigung aufgefordert, 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 Ihnen die Angabe einer Funktion, 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 analysiert 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 Auslöser einer Funktion

Wenn Sie die Regionen umbenennen oder ändern oder Funktionen auslösen, die den Produktionsverkehr verarbeiten, befolgen Sie die Schritte in diesem Abschnitt, um zu vermeiden, dass Ereignisse während der Änderung verloren gehen. Bevor Sie diese Schritte ausführen, stellen Sie zunächst sicher, dass Ihre Funktion idempotent ist, da während der Änderung sowohl die neue als auch die alte Version Ihrer Funktion 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 Ereignisverluste verhindern, indem Sie die folgenden Schritte in der folgenden Reihenfolge ausführen:

  1. Benennen Sie die Funktion um und ändern Sie ihre Region bzw. Regionen wie gewünscht.
  2. Stellen Sie die umbenannte Funktion bereit, was dazu führt, dass in beiden Regionensätzen vorübergehend derselbe Code 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 diese nach asia-northeast1 migrieren möchten, müssen Sie zunächst 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 es dann bereit, indem Sie Folgendes ausführen:

firebase deploy --only functions:webhookAsia

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

Dann löschen Sie webhook :

firebase functions:delete webhook

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

Ändern Sie den Triggertyp einer Funktion

Während Sie Ihre Cloud Functions for Firebase-Bereitstellung im Laufe der Zeit weiterentwickeln, müssen Sie möglicherweise aus verschiedenen Gründen den Triggertyp einer Funktion ändern. Beispielsweise möchten Sie möglicherweise von einem Typ eines Firebase Realtime Database- oder Cloud Firestore-Ereignisses zu einem anderen Typ wechseln.

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

  1. Ändern Sie den Quellcode, um eine neue Funktion mit dem gewünschten Triggertyp einzuschließen.
  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 mithilfe der Firebase-CLI explizit aus der Produktion.

Wenn Sie beispielsweise eine Node.js-Funktion mit dem Namen „ objectChanged hatten, die über den alten Ereignistyp „ onChange verfügt, und Sie diese in onFinalize ändern möchten, benennen Sie die Funktion zunächst um und bearbeiten Sie sie so, dass sie den Ereignistyp onFinalize erhä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 zunächst 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

Legen Sie Laufzeitoptionen fest

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

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 über jede andere Methode festgelegt wurden (z. B. über die Google Cloud Console oder die gcloud-CLI).

Wenn Ihr Entwicklungsworkflow das manuelle Festlegen von Laufzeitoptionen über die Google Cloud-Konsole oder die gcloud-CLI umfasst und Sie nicht möchten, dass diese Werte bei jeder Bereitstellung überschrieben werden, legen Sie die Option 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. Option ist 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, sondern in der aktuell bereitgestellten Funktion festgelegt: Verwenden Sie die in der bereitgestellten Funktion angegebene Option.

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

Legen Sie die Node.js-Version fest

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

  • Node.js 20 (Vorschau)
  • 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 “ in der Datei package.json festlegen, 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"}

Wenn Sie den Yarn-Paketmanager verwenden oder andere spezifische Anforderungen an das engines Feld haben, können Sie stattdessen die Laufzeit für das Firebase SDK für Cloud Functions in firebase.json festlegen:

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

Die CLI verwendet den in firebase.json festgelegten Wert vor allen Werten oder Bereichen, die Sie separat in package.json festlegen.

Aktualisieren Sie Ihre Node.js-Laufzeitumgebung

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 Wert engines in der Datei package.json “, die während der Initialisierung in Ihrem Verzeichnis functions/ erstellt wurde. Wenn Sie beispielsweise ein Upgrade von Version 16 auf Version 18 durchführen, sollte der Eintrag wie folgt aussehen: "engines": {"node": "18"}
  4. Testen Sie Ihre Änderungen optional mit der Firebase Local Emulator Suite .
  5. Stellen Sie alle Funktionen erneut 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 reduzierten Datenverkehrs möglicherweise auf null Instanzen herunterskaliert werden. Wenn Ihre App jedoch eine reduzierte 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 gehalten werden und für die Bearbeitung von Anforderungen bereit sind.

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 Unterstützungsdienst, beispielsweise zu einer Datenbank, zu begrenzen.

Reduzieren Sie die Anzahl der Kaltstarts

Um die Mindestanzahl von Instanzen für eine Funktion im Quellcode festzulegen, verwenden Sie die runWith Methode. Diese Methode akzeptiert ein JSON-Objekt, das der RuntimeOptions Schnittstelle entspricht, die den Wert für minInstances definiert. Diese Funktion legt beispielsweise 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

Beim Festlegen eines Werts für minInstances sind folgende Dinge zu beachten:

  • Wenn Cloud Functions for Firebase Ihre App über Ihre minInstances Einstellung hinaus skaliert, kommt es bei jeder Instanz über diesem Schwellenwert zu einem Kaltstart.
  • Kaltstarts wirken sich am stärksten auf Apps mit starkem Datenverkehr aus. Wenn Ihre App stark ansteigenden Datenverkehr aufweist und Sie einen Wert für minInstances festlegen, der hoch genug ist, dass Kaltstarts bei jedem Datenverkehrsanstieg reduziert werden, werden Sie eine deutlich geringere Latenz feststellen. Bei Apps mit ständigem Datenverkehr ist es unwahrscheinlich, dass Kaltstarts die Leistung erheblich beeinträchtigen.

  • Das Festlegen von Mindestinstanzen kann für Produktionsumgebungen sinnvoll sein, sollte in Testumgebungen jedoch normalerweise vermieden werden. Um in Ihrem Testprojekt auf Null zu skalieren und dennoch Kaltstarts in Ihrem Produktionsprojekt zu reduzieren, können Sie minInstances basierend auf der Umgebungsvariablen 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

Um die maximale Anzahl an Instanzen im Funktionsquellcode festzulegen, verwenden Sie die runWith Methode. 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 bis zum maxInstances -Limit skaliert wird, werden neue Anfragen 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 der Einstellungen für maximale Instanzen zu erfahren, sehen Sie sich diese Best Practices für die Verwendung maxInstances an.

Legen Sie Timeout und Speicherzuweisung fest

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

Um die Speicherzuteilung und das Zeitlimit im Funktionsquellcode festzulegen, verwenden Sie den in Firebase SDK für Cloud Functions 2.0.0 eingeführten Parameter runWith . Diese Laufzeitoption akzeptiert ein JSON-Objekt, das der RuntimeOptions Schnittstelle 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 maximale Wert für timeoutSeconds beträgt 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 beschrieben:

  • 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 Speicherzuweisung und Zeitlimit in der Google Cloud Console fest:

  1. Wählen Sie in der 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 „Speicher zugewiesen“ aus.
  5. Klicken Sie auf „Mehr“ , um die erweiterten Optionen anzuzeigen, und geben Sie im Textfeld „Timeout“ eine Anzahl von Sekunden ein.
  6. Klicken Sie auf Speichern, um die Funktion zu aktualisieren.