Sie können Funktionen mithilfe von Firebase-Befehlen bereitstellen, löschen und ändern oder Laufzeitoptionen im Quellcode der Funktionen festlegen.
Funktionen bereitstellen
Führen Sie den folgenden Firebase-Befehl aus, um Funktionen bereitzustellen:
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. Um dieses Problem zu beheben, sollten Sie Funktionen in Gruppen von maximal zehn Funktionen bereitstellen.
Eine vollständige Liste der verfügbaren Befehle finden Sie in der Firebase-Referenz.
Standardmäßig sucht die Firebase-Befehlszeile im Ordner functions/
nach dem Quellcode. Alternativ können Sie Funktionen in Codebases oder mehreren Dateien organisieren.
Funktionen löschen
Sie haben folgende Möglichkeiten, zuvor bereitgestellte Funktionen zu löschen:
- explizit in der Firebase CLI mit
functions:delete
- explizit in der Google Cloud-Konsole.
- implizit, indem Sie die Funktion vor der Bereitstellung aus der Quelle entfernen.
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 Funktionsgruppen und ermöglicht 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
Bei der impliziten Funktionslöschung analysiert firebase deploy
Ihre Quelle und entfernt alle Funktionen aus der Produktion, die aus der Datei entfernt wurden.
Name, Region oder Trigger einer Funktion ändern
Wenn Sie die Regionen oder den Trigger für Funktionen umbenennen oder ändern, die Produktionstraffic verarbeiten, folgen Sie der Anleitung in diesem Abschnitt, um zu verhindern, dass bei der Änderung Ereignisse verloren gehen. 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 in der Quelle eine neue umbenannte Version der Funktion und führen Sie dann zwei separate Bereitstellungsbefehle aus. Mit dem ersten Befehl wird die neu benannte Funktion bereitgestellt und mit dem zweiten Befehl wird die zuvor bereitgestellte Version entfernt. 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 oder Regionen einer Funktion ändern
Wenn Sie die angegebenen Regionen für eine Funktion ändern, die Produktionstraffic verarbeitet, können Sie Datenverluste verhindern, indem Sie die folgenden Schritte nacheinander ausführen:
- Benennen Sie die Funktion um und ändern Sie die Region oder Regionen nach Bedarf.
- Die umbenannte Funktion wird bereitgestellt, wodurch derselbe Code vorübergehend in beiden Regionen ausgeführt wird.
- 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 zu 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/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 diesen Befehl aus, um die Bereitstellung vorzunehmen:
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 noch eine Funktion: webhookAsia
, die in asia-northeast1
ausgeführt wird.
Triggertyp einer Funktion ändern
Wenn Sie Ihre Cloud Functions for Firebase-Bereitstellung im Laufe der Zeit weiterentwickeln, müssen Sie den Triggertyp einer Funktion möglicherweise aus verschiedenen Gründen ändern. Beispielsweise können Sie von einem Firebase Realtime Database- oder Cloud Firestore-Ereignistyp zu einem anderen wechseln.
Der Ereignistyp einer Funktion kann nicht einfach durch Ändern des Quellcodes und Ausführen von firebase deploy
geändert werden. So ändern Sie den Triggertyp einer Funktion, um Fehler zu vermeiden:
- Ändern Sie den Quellcode so, dass er eine neue Funktion mit dem gewünschten Triggertyp enthält.
- Binden Sie die Funktion ein. Dadurch werden vorübergehend sowohl die alte als auch die neue Funktion ausgeführt.
- Löschen Sie die alte Funktion mit der Firebase-Befehlszeile explizit aus der Produktion.
Wenn Sie beispielsweise eine Node.js-Funktion namens objectChanged
mit dem Legacy-Ereignistyp onChange
haben und sie in onFinalize
ändern möchten, müssen Sie zuerst die Funktion umbenennen und den Ereignistyp onFinalize
hinzufügen.
// 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 (mit Ausnahme der Node.js-Version) in einem Konfigurationsobjekt im Funktionscode festgelegt werden. Dieses RuntimeOptions
-Objekt ist die maßgebliche Quelle für die Laufzeitoptionen Ihrer Funktion und überschreibt Optionen, die über eine andere Methode festgelegt wurden, z. B. über die Google Cloud Console oder die gcloud CLI.
Wenn Sie in Ihrem Entwicklungsablauf die Laufzeitoptionen manuell über die Google Cloud Console oder die gcloud-Befehlszeile festlegen und diese Werte nicht bei jedem Deployment überschrieben werden sollen, legen Sie die Option preserveExternalChanges
auf true
fest.
Wenn diese Option auf true
festgelegt ist, werden die in Ihrem Code festgelegten Laufzeitoptionen von Firebase mit den Einstellungen der aktuell bereitgestellten Version Ihrer Funktion mit der folgenden Priorität zusammengeführt:
- Option im Funktionscode festgelegt: Externe Änderungen überschreiben
- Die Option ist im Funktionscode auf
RESET_VALUE
festgelegt: Externe Änderungen werden durch den Standardwert überschrieben. - Die Option ist nicht im Code der Funktionen festgelegt, sondern in der aktuell bereitgestellten Funktion. 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 dann nicht mehr die vollständige Quelle der Wahrheit für die Laufzeitoptionen Ihrer Funktionen ist. Wenn Sie sie verwenden, können Sie die vollständige Konfiguration einer Funktion in der Google Cloud Console oder mit der gcloud CLI aufrufen.
Node.js-Version festlegen
Das Firebase SDK für Cloud Functions ermöglicht die Auswahl einer 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, 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 andere spezifische Anforderungen an das Feld engines
haben, können Sie die Laufzeit für das Firebase SDK für Cloud Functions stattdessen in firebase.json
festlegen:
{
"functions": {
"runtime": "nodejs18" // or nodejs14, nodejs16 or nodejs20
}
}
In der Befehlszeile wird der in firebase.json
festgelegte Wert anstelle eines Werts oder Bereichs verwendet, den Sie separat in package.json
festgelegt haben.
Node.js-Laufzeit aktualisieren
So führen Sie ein Upgrade der Node.js-Laufzeit durch:
- Ihr Projekt muss den Blaze-Tarif haben.
- Sie benötigen die Firebase CLI-Version 11.18.0 oder höher.
- Ändern Sie den Wert
engines
in der Dateipackage.json
, die während der Initialisierung im Verzeichnisfunctions/
erstellt wurde. Wenn Sie beispielsweise von Version 16 auf Version 18 upgraden, sollte der Eintrag so aussehen:"engines": {"node": "18"}
- Optional können Sie Ihre Änderungen mit Firebase Local Emulator Suite testen.
- Stellen Sie alle Funktionen neu bereit.
Skalierungsverhalten steuern
Standardmäßig skaliert Cloud Functions for Firebase die Anzahl der laufenden Instanzen basierend auf der Anzahl der eingehenden Anfragen. Bei geringem Traffic kann die Anzahl der Instanzen auf null gesenkt werden. Wenn Ihre App jedoch eine geringere Latenz erfordert und Sie die Anzahl von Kaltstarts begrenzen möchten, können Sie dieses Standardverhalten ändern. Dazu geben Sie eine Mindestanzahl von Containerinstanzen an, die einsatzbereit sind und Anfragen bedienen können.
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 zu begrenzen, z. B. zu einer Datenbank.
Anzahl der Kaltstarts reduzieren
Verwenden Sie die Methode runWith
, 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. Mit dieser Funktion werden beispielsweise mindestens 5 Instanzen warm gehalten:
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
});
Beachten Sie beim Festlegen eines Werts für minInstances
Folgendes:
- Wenn Cloud Functions for Firebase Ihre App über die Einstellung
minInstances
skaliert, kommt es bei jeder Instanz über diesem Grenzwert zu einem Kaltstart. - Kaltstarts wirken sich am stärksten auf Apps mit Spitzen bei der Zugriffszahl aus. Wenn Ihre App hohe Zugriffsspitzen aufweist und Sie einen
minInstances
-Wert festlegen, der hoch genug ist, um bei jedem Anstieg der Zugriffe die Anzahl der Kaltstarts zu reduzieren, wird die Latenz deutlich gesenkt. Bei Apps mit konstantem Traffic wirken sich Kaltstarts wahrscheinlich nicht stark auf die Leistung aus. Die Festlegung einer Mindestanzahl von Instanzen kann für Produktionsumgebungen sinnvoll sein, sollte aber in Testumgebungen in der Regel vermieden werden. Wenn Sie in Ihrem Testprojekt auf null skalieren, aber trotzdem die Kaltstarts in Ihrem Produktionsprojekt reduzieren möchten, können Sie
minInstances
basierend auf der UmgebungsvariablenFIREBASE_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 });
Maximale Anzahl von Instanzen für eine Funktion begrenzen
Verwenden Sie die Methode runWith
, um die maximale Anzahl von Instanzen im Funktionsquellcode festzulegen. Diese Methode akzeptiert ein JSON-Objekt, das der Schnittstelle RuntimeOptions
entspricht, in der Werte für maxInstances
definiert sind. Mit dieser Funktion wird beispielsweise ein Limit von 100 Instanzen festgelegt, 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
});
Wenn eine HTTP-Funktion auf das Limit von maxInstances
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.
Weitere Informationen zu Best Practices für die Verwendung von Einstellungen für die maximale Anzahl von Instanzen finden Sie in den Best Practices für die Verwendung von maxInstances
.
Zeitüberschreitung und Speicherzuweisung festlegen
In einigen Fällen haben Ihre Funktionen möglicherweise spezielle 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 festlegen (nur Firebase).
Verwenden Sie den Parameter runWith
, der im Firebase SDK für Cloud Functions 2.0.0 eingeführt wurde, um die Arbeitsspeicherzuweisung und den Zeitüberschreitungszeitraum im Quellcode von Funktionen festzulegen. Für diese Laufzeitoption wird ein JSON-Objekt gemäß der Schnittstelle RuntimeOptions
akzeptiert, das Werte für timeoutSeconds
und memory
definiert.
Diese Speicherfunktion belegt beispielsweise 1 GB Arbeitsspeicher und löst nach 300 Sekunden ein Zeitlimit aus:
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
, also 9 Minuten.
Die Größe des Arbeitsspeichers, der einer Funktion zugewiesen wird, entspricht der CPU, die der Funktion zugewiesen wird. Weitere Informationen finden Sie in dieser Liste der gültigen Werte für memory
:
128MB
– 200 MHz256MB
– 400 MHz512MB
– 800 MHz1GB
– 1,4 GHz2GB
– 2,4 GHz4GB
– 4,8 GHz8GB
– 4,8 GHz
So legen Sie die Speicherzuweisung und das Zeitlimit in der Google Cloud-Konsole fest:
- Wählen Sie in der Google Google Cloud Console im Menü auf der linken Seite Cloud Functions aus.
- Wählen Sie eine Funktion aus, indem Sie in der Funktionsliste auf ihren Namen klicken.
- Klicken Sie oben im Menü auf das Symbol Bearbeiten.
- Wählen Sie im Drop-down-Menü Zugewiesener Speicher eine Speicherzuweisung aus.
- Klicken Sie auf das Dreipunkt-Menü, um die erweiterten Optionen aufzurufen, und geben Sie in das Textfeld Zeitüberschreitung eine Zeit in Sekunden ein.
- Klicken Sie auf Speichern, um die Funktion zu aktualisieren.