Verwalten von Funktionsbereitstellungs- und Laufzeitoptionen

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

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 innerhalb index.js zugleich. Wenn Ihr Projekt mehr als 5 Funktionen enthält, empfehlen wir , dass Sie die Verwendung --only Flagge mit spezifischen Funktionsnamen nur die Funktionen zu implementieren , die Sie bearbeitet haben. Bereitstellen von spezifischen Funktionen beschleunigt auf diese Weise den Bereitstellungsprozess und hilft Ihnen in Bereitstellung Quoten vermeiden läuft. 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 10 oder weniger bereit.

Siehe die Firebase CLI Referenz für die vollständige Liste der verfügbaren Befehle.

Standardmäßig sucht die Firebase CLI in den functions/ Ordnern für den Quellcode. Sie können durch Hinzufügen der folgenden Zeilen in einen anderen Ordner angeben firebase.json :

"functions": {
  "source": "another-folder"
}

Funktionen löschen

Sie können zuvor bereitgestellte Funktionen wie folgt löschen:

  • explizit in der Firebase CLI mit functions:delete
  • explizit über das Kontextmenü in der Funktionsliste in der Konsole Firebase
  • implizit durch die Funktion von Entfernung index.js vor der Entfaltung.

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

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 auch 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

Mit impliziter Funktion Löscht, firebase deploy parst index.js und entfernt von der Produktion aller Funktionen , die aus der Datei entfernt wurden.

Namen, Region oder Trigger einer Funktion ändern

Wenn Sie die Regionen oder Trigger für Funktionen umbenennen oder ändern, die den Produktionsdatenverkehr verarbeiten, befolgen Sie die Schritte in diesem Abschnitt, um zu vermeiden, dass Ereignisse während der Änderung verloren gehen. Bevor Sie diese Schritte ausgeführt haben, zunächst sicherstellen , dass Ihre Funktion ist idempotent , da sowohl die neue Version und die alte Version Ihrer Funktion werden während der Änderung in der gleichen Zeit ausgeführt werden.

Benennen Sie eine Funktion um

Um eine Funktion zu benennen, erstellen Sie eine neue umbenannte Version der Funktion in index.js und führen Sie zwei separate Bereitstellungsbefehle. Der erste Befehl stellt die neu benannte Funktion bereit und der zweite Befehl entfernt die zuvor bereitgestellte Version. Zum Beispiel, wenn Sie eine Funktion namens webhook , den Sie ändern möchten webhookNew , ü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

Region oder Regionen einer Funktion ändern

Wenn Sie die angegebenen ändern Regionen für eine Funktion , die den Produktionsverkehr Bei der Verarbeitung können Sie Ereignisverlust , indem Sie diese Schritte , um zu verhindern:

  1. Benennen Sie die Funktion um und ändern Sie die Region oder die Regionen wie gewünscht.
  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. Löschen Sie die vorherige Funktion.

Zum Beispiel, wenn Sie eine Funktion namens haben webhook , die derzeit in den Standardfunktionen Region ist us-central1 , und Sie wollen es migrieren asia-northeast1 , müssen Sie zuerst den Quellcode modifizieren , um die Funktion zu benennen und zu überarbeiten , die Region .

// 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

Nun gibt es zwei identische Funktionen ausführen: webhook in läuft us-central1 und webhookAsia wird in laufenden asia-northeast1 .

Dann löschen webhook :

$ firebase functions:delete webhook

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

Triggertyp einer Funktion ändern

Wenn Sie Ihre Cloud Functions for Firebase-Bereitstellung im Laufe der Zeit entwickeln, müssen Sie möglicherweise den Triggertyp einer Funktion aus verschiedenen Gründen ändern. Sie möchten beispielsweise:

  • Wechsel von dem Legacy - Speicher onChange Ereignisse onFinalize , onDelete , onArchive und onMetadataUpdate . (Mehr dazu in der Beta v1 oder v2 Upgrade - Anleitung ).
  • Wechsel von einer Art von Firebase Realtime - Datenbank oder Cloud - Firestor Ereignisse zu einem anderen, wie das allgemeinen onWrite Ereignisse auf das körnige onCreate Ereignis.

Es ist nicht möglich , eine Funktion des Ereignistyp zu ändern , indem Sie einfach den Quellcode ändern und läuft firebase deploy . 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 alten als auch die neuen Funktionen vorübergehend ausgeführt werden.
  3. Löschen Sie die alte Funktion explizit mit der Firebase-CLI aus der Produktion.

Wenn Sie eine Funktion hatte zum Beispiel objectChanged , dass das Erbe hat onChange Ereignistyp, und Sie möchten , dass es ändern onFinalize , benennen Sie zunächst die Funktion und bearbeiten sie die haben onFinalize Ereignistyp.

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

Node.js-Version festlegen

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 14
  • Node.js 12
  • Node.js 10
  • Node.js 8 (veraltet am 8. Juni 2020) Bereitstellung von Funktionen zu dem node.js 8 Laufzeit im Firebase CLI am 15. Dezember gesperrt wurde, 2020 Ausführung von bereits eingesetzten Funktionen werden zu einem bestimmten Zeitpunkt in der Zukunft zu stoppen; wenn Sie auf die Funktionen der Node.js 8 Laufzeit bereitgestellt haben, empfehlen wir , dass Sie auf die Node.js 14 Runtime - Upgrade .

So legen Sie die Node.js-Version fest:

Stellen Sie die Version in dem engines - Feld in der package.json - Datei , die in Ihrem erstellt wurde functions/ Verzeichnis während der Initialisierung. Zum Beispiel kann nur verwenden Version 14, bearbeiten diese Zeile in package.json :

  "engines": {"node": "14"}

Die engines ist erforderlich; es muss eine der unterstützten Node.js Versionen angeben , um für Sie und Funktionen laufen zu implementieren. Derzeit firebase init functions setzt dieses Feld auf 14 .

Aktualisieren Sie Ihre Node.js-Laufzeit

So aktualisieren Sie Ihre Node.js-Laufzeit:

  1. Stellen Sie sicher , dass Ihr Projekt auf dem Blaze Preisgestaltungsplan .
  2. Stellen Sie sicher, dass Sie Firebase CLI v8.6.0 oder höher verwenden.
  3. Ändern Sie den engines Wert in der package.json - Datei , die in Ihrem erstellt wurde functions/ Verzeichnis während der Initialisierung. Zum Beispiel, wenn Sie von Version 10 auf Version 14 aktualisieren, sollte der Eintrag wie folgt aussehen: "engines": {"node": "14"}
  4. Optional testen Sie Ihre Änderungen , die mit Firebase Local Emulator Suite .
  5. Stellen Sie Funktionen mit der Firebase CLI v8.1.0 oder höher 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 mit reduziertem Traffic 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 bereit sind, Anfragen zu bedienen.

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 Backing-Dienst, z. B. zu einer Datenbank, zu begrenzen.

Reduzieren Sie die Anzahl der Kaltstarts

Um festgelegte Mindestanzahl von Instanzen für eine Funktion im Quellcode, verwenden Sie den runWith Parameter. Diese Laufzeitoption akzeptiert ein JSON Objekt an die konforme RuntimeOptions - Schnittstelle, die den Wert für definiert minInstances . 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
    });

Hier sind einige Dinge zu beachten , wenn ein Wert für die Einstellung minInstances :

  • Wenn Cloud - Funktionen für die Firebase Ihre App über Ihre Waage minInstances Einstellung, erhalten Sie einen Kaltstart für jede Instanz über dieser Schwelle erfahren.
  • Kaltstarts haben die stärksten Auswirkungen auf Apps mit hohem Datenverkehr. Wenn Ihre App stachelig Verkehr hat und Sie setzen ein minInstances hoch genug schätzen , dass Kaltstart bei jedem Anstieg des Verkehrsaufkommens reduziert werden, sehen Sie deutlich geringere Latenz. Bei Apps mit konstantem Datenverkehr werden Kaltstarts die Leistung wahrscheinlich nicht ernsthaft beeinträchtigen.
  • Das Festlegen von Mindestinstanzen kann für Produktionsumgebungen sinnvoll sein, sollte jedoch in Testumgebungen in der Regel vermieden werden. Maßstab Projekt auf Null im Test aber noch Kaltstarts in Ihrer Produktion Projekt reduzieren, die Sie einstellen können minInstances basierend auf der FIREBASE_CONFIG Umgebungsvariable:

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

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

Um eingestellten Maximal Instanzen in Funktion Quellcode, verwenden Sie den runWith Parameter. Diese Laufzeitoption akzeptiert ein JSON - Objekt an die konforme RuntimeOptions - Schnittstelle, die Werte für definiert maxInstances . Diese Funktion legt beispielsweise ein Limit von 100 Instanzen fest, um eine hypothetische Legacy-Datenbank nicht zu überfordern:

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

Wenn eine HTTP - Funktion wird auf die skaliert maxInstances Grenze, werden neue Anfragen für 30 Sekunden der Warteschlange gestellt und dann mit einem Antwortcode abgelehnt 429 Too Many Requests , wenn keine Instanz von dann zur Verfügung steht.

Weitere Informationen über Best Practices für die Verwendung von maximal Instanzen Einstellungen, sehen Sie sich diese Best Practices für die Verwendung von maxInstances .

Timeout und Speicherzuweisung einstellen

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

Um Satz Speicherzuweisung und Timeout in Funktionen Quellcode, verwenden Sie den runWith Parameter in Firebase SDK für Cloud - Funktionen eingeführt 2.0.0. Diese Laufzeitoption akzeptiert ein JSON Objekt an der konforme RuntimeOptions Schnittstelle, die Werte für definiert timeoutSeconds und memory . 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
    });

Der Maximalwert für timeoutSeconds ist 540 , oder 9 Minuten. Gültige Werte für memory sind:

  • 128MB
  • 256MB
  • 512MB
  • 1GB
  • 2GB
  • 4GB
  • 8GB

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

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