Funktionen verwalten

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

Funktionen bereitstellen

Führen Sie den folgenden Firebase-CLI-Befehl aus, um Funktionen bereitzustellen:

firebase deploy --only functions

Standardmäßig werden mit der Firebase-Befehlszeile 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. Bestimmte Funktionen auf diese Weise bereitzustellen, beschleunigt den Bereitstellungsprozess und hilft Ihnen, Bereitstellungskontingente zu vermeiden. 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 beheben, stellen Sie Funktionen in Gruppen von maximal 10 Funktionen bereit.

Eine vollständige Liste der verfügbaren Befehle finden Sie in der Firebase-Befehlszeilenreferenz.

Standardmäßig sucht die Firebase-Befehlszeile im Ordner functions/ nach dem Quellcode. Alternativ können Sie Funktionen in Codebases oder mehreren Dateisätzen organisieren.

Bereitstellungsartefakte bereinigen

Im Rahmen der Bereitstellung von Funktionen werden Container-Images generiert und in Artifact Registry gespeichert. Diese Bilder sind nicht erforderlich, damit Ihre bereitgestellten Funktionen ausgeführt werden können. Cloud Functions ruft beim ersten Bereitstellen eine Kopie des Bildes ab und behält sie bei. Die gespeicherten Artefakte sind jedoch nicht erforderlich, damit die Funktion zur Laufzeit funktioniert.

Diese Container-Images sind zwar oft klein, können sich aber im Laufe der Zeit ansammeln und zu Ihren Speicherkosten beitragen. Möglicherweise möchten Sie sie für einen bestimmten Zeitraum beibehalten, wenn Sie die erstellten Artefakte prüfen oder Container-Schwachstellenscans ausführen möchten.

Um die Speicherkosten zu senken, können Sie mit der Firebase-Befehlszeile 14.0.0 und höher eine Artifact Registry-Bereinigungsrichtlinie für Repositories konfigurieren, in denen nach jeder Funktionsbereitstellung Bereitstellungsartefakte gespeichert werden.

Sie können eine Bereinigungsrichtlinie manuell mit dem Befehl functions:artifacts:setpolicy einrichten oder bearbeiten:

firebase functions:artifacts:setpolicy

Standardmäßig konfiguriert dieser Befehl Artifact Registry so, dass Container-Images, die älter als ein Tag sind, automatisch gelöscht werden. So wird ein angemessenes Gleichgewicht zwischen der Minimierung der Speicherkosten und der Möglichkeit, aktuelle Builds zu prüfen, erreicht.

Sie können den Aufbewahrungszeitraum mit der Option --days anpassen:

firebase functions:artifacts:setpolicy --days 7  # Delete images older than 7 days

Wenn Sie Funktionen in mehreren Regionen bereitstellen, können Sie mit der Option --location eine Bereinigungsrichtlinie für einen bestimmten Standort einrichten:

$ firebase functions:artifacts:setpolicy --location europe-west1

Bereinigung von Artefakten deaktivieren

Wenn Sie die Bereinigung von Bildern lieber manuell verwalten oder keine Bilder löschen lassen möchten, können Sie die Bereinigungsrichtlinien vollständig deaktivieren:

$ firebase functions:artifacts:setpolicy --none

Mit diesem Befehl wird jede vorhandene Bereinigungsrichtlinie entfernt, die von der Firebase CLI eingerichtet wurde. Außerdem wird verhindert, dass Firebase nach der Bereitstellung von Funktionen eine Bereinigungsrichtlinie einrichtet.

Funktionen löschen

Sie können zuvor bereitgestellte Funktionen auf folgende Arten 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 Entfernung der Funktion aus der Produktion zu bestätigen.

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. Sie können die Bestätigungsaufforderung auch überspringen.

# 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 wird Ihre Quelle von firebase deploy geparst und alle Funktionen, die aus der Datei entfernt wurden, werden aus der Produktion entfernt.

Name, Region oder Trigger einer Funktion ändern

Wenn Sie Funktionen, die Produktions-Traffic verarbeiten, umbenennen oder die Region oder den Trigger für diese Funktionen ändern, folgen Sie der Anleitung in diesem Abschnitt, um zu vermeiden, dass Ereignisse während der Änderung verloren gehen. Bevor Sie diese Schritte ausführen, sollten Sie prüfen, 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 Ihrer Quelle 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 einen durch HTTP ausgelösten Webhook umbenennen möchten, müssen Sie den Code so ändern:

// before
const {onRequest}  = require('firebase-functions/v2/https');

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

// after
const {onRequest}  = require('firebase-functions/v2/https');

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

# before
from firebase_functions import https_fn

@https_fn.on_request()
def webhook(req: https_fn.Request) -> https_fn.Response:
    return https_fn.Response("Hello world!")

# after
from firebase_functions import https_fn

@https_fn.on_request()
def webhook_new(req: https_fn.Request) -> https_fn.Response:
    return https_fn.Response("Hello world!")

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

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

# Wait until deployment is done; now both functions 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 Produktions-Traffic verarbeitet, können Sie Datenverlust verhindern, indem Sie die folgenden Schritte in der angegebenen Reihenfolge ausführen:

1. Benennen Sie die Funktion um und ändern Sie die Region oder Regionen nach Bedarf.
2. Stellen Sie die umbenannte Funktion bereit. Dadurch wird derselbe Code vorübergehend in beiden Regionen ausgeführt.
3. Löschen Sie die vorherige Funktion.

Wenn Sie beispielsweise eine durch Cloud Firestore ausgelöste Funktion haben, die sich derzeit in der Standardregion für Funktionen us-central1 befindet, und Sie sie zu asia-northeast1 migrieren möchten, müssen Sie zuerst den Quellcode ändern, um die Funktion umzubenennen und die Region zu überarbeiten.

// before
exports.firestoreTrigger = onDocumentCreated(
  "my-collection/{docId}",
  (event) => {},
);

// after
exports.firestoreTriggerAsia = onDocumentCreated(
  {
    document: "my-collection/{docId}",
    region: "asia-northeast1",
  },
  (event) => {},
);

# Before
@firestore_fn.on_document_created("my-collection/{docId}")
def firestore_trigger(event):
    pass

# After
@firestore_fn.on_document_created("my-collection/{docId}",
                                  region="asia-northeast1")
def firestore_trigger_asia(event):
    pass

Stellen Sie die Funktion dann mit dem folgenden Befehl bereit:

firebase deploy --only functions:firestoreTriggerAsia

Jetzt werden zwei identische Funktionen ausgeführt: firestoreTrigger wird in us-central1 und firestoreTriggerAsia in asia-northeast1 ausgeführt.

Löschen Sie dann firestoreTrigger:

firebase functions:delete firestoreTrigger

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

Triggertyp einer Funktion ändern

Im Laufe der Zeit kann es aus verschiedenen Gründen erforderlich sein, den Triggertyp einer Funktion zu ändern.Cloud Functions for Firebase Sie möchten beispielsweise von einem Firebase Realtime Database- oder Cloud Firestore-Ereignistyp zu einem anderen wechseln.

Der Ereignistyp einer Funktion kann nicht geändert werden, indem Sie nur den Quellcode ändern und firebase deploy ausführen. So ändern Sie den Auslösertyp einer Funktion, um Fehler zu vermeiden:

1. Ändern Sie den Quellcode, um eine neue Funktion mit dem gewünschten Triggertyp einzufügen.
2. Stellen Sie die Funktion bereit. Dadurch werden sowohl die alte als auch die neue Funktion vorübergehend ausgeführt.
3. Löschen Sie die alte Funktion explizit aus der Produktion mit der Firebase-CLI.

Wenn Sie beispielsweise eine Funktion hatten, die ausgelöst wurde, wenn ein Objekt gelöscht wurde, Sie dann die Objektversionsverwaltung aktiviert haben und stattdessen das Archivierungsereignis abonnieren möchten, benennen Sie die Funktion zuerst um und bearbeiten Sie sie so, dass sie den neuen Triggertyp hat.

// before
const {onObjectDeleted} = require("firebase-functions/v2/storage");

exports.objectDeleted = onObjectDeleted((event) => {
    // ...
});

// after
const {onObjectArchived} = require("firebase-functions/v2/storage");

exports.objectArchived = onObjectArchived((event) => {
    // ...
});

# before
from firebase_functions import storage_fn

@storage_fn.on_object_deleted()
def object_deleted(event):
  # ...

# after 
from firebase_functions import storage_fn

@storage_fn.on_object_archived()
def object_archived(event):
  # ...

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 objectArchived
firebase deploy --only functions:objectArchived

# Wait until deployment is done; now both objectDeleted and objectArchived are running

# Delete objectDeleted
firebase functions:delete objectDeleted

Laufzeitoptionen festlegen

Mit Cloud Functions for Firebase können Sie Laufzeitoptionen wie die Node.js-Laufzeitversion und das Timeout pro Funktion, die Speicherzuweisung und die Mindest-/Höchstanzahl von 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 Quelle der Wahrheit 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 Laufzeitoptionen manuell über die Google Cloud Console oder die gcloud CLI festlegen und nicht möchten, dass diese Werte bei jeder Bereitstellung überschrieben werden, setzen Sie die Option preserveExternalChanges auf true. 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 zusammengeführt. Dabei gilt die folgende Priorität:

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

Die Verwendung der Option preserveExternalChanges: true ist für die meisten Szenarien nicht empfehlenswert, da Ihr Code nicht mehr die vollständige Quelle der Wahrheit für Laufzeitoptionen für Ihre Funktionen ist. Wenn Sie sie verwenden, sehen Sie sich die vollständige Konfiguration einer Funktion in der Google Cloud Console an oder verwenden Sie die gcloud CLI.

Node.js-Version festlegen

Das Firebase SDK für Cloud Functions ermöglicht die Auswahl einer 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 22
• Node.js 20
• Node.js 18 (verworfen)

Node.js-Versionen 14 und 16 wurden Anfang 2025 außer Betrieb genommen. Die Bereitstellung mit diesen Versionen ist deaktiviert. Wichtige Informationen zum laufenden Support für diese Node.js-Versionen finden Sie im Supportzeitplan.

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. Wenn Sie beispielsweise nur Version 20 verwenden möchten, bearbeiten Sie diese Zeile in package.json:

  "engines": {"node": "20"}

Wenn Sie den Yarn-Paketmanager verwenden oder andere spezifische Anforderungen für 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": "nodejs20" // or nodejs22
    }
  }

In der CLI wird der in firebase.json festgelegte Wert bevorzugt gegenüber allen Werten oder Bereichen verwendet, die Sie separat in package.json festlegen.

Node.js-Laufzeit aktualisieren

So aktualisieren Sie die Node.js-Laufzeit:

1. Ihr Projekt muss den Blaze-Tarif haben.
2. Sie benötigen die Firebase CLI-Version 11.18.0 oder höher.
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 18 auf Version 20 durchführen, sollte der Eintrag so aussehen: "engines": {"node": "20"}
4. Optional können Sie Ihre Änderungen mit dem Firebase Local Emulator Suite testen.
5. Stellen Sie alle Funktionen noch einmal bereit.

Python-Version festlegen

Mit dem Firebase SDK für Cloud Functions-Versionen 12.0.0 und höher kann die Python-Laufzeit ausgewählt werden. Legen Sie die Laufzeitversion in firebase.json wie folgt fest:

  {
    "functions": {
      "runtime": "python310" // or python311
    }
  }

Skalierungsverhalten steuern

Standardmäßig skaliert Cloud Functions for Firebase die Anzahl der ausgeführten Instanzen basierend auf der Anzahl der eingehenden Anfragen. Bei geringem Traffic kann die Anzahl der Instanzen auf null reduziert 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.

Sie können auch 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.

Mit diesen Einstellungen in Kombination mit der Gleichzeitigkeit pro Instanz (neu in der 2. Generation) können Sie das Skalierungsverhalten Ihrer Funktionen steuern und optimieren. Welche Einstellungen am kostengünstigsten sind und die beste Leistung erzielen, hängt von der Art Ihrer Anwendung und Funktion ab.

Bei einigen Apps mit geringem Traffic ist eine niedrigere CPU-Option ohne Multi-Concurrency optimal. Bei anderen, bei denen Kaltstarts ein kritisches Problem darstellen, bedeutet das Festlegen einer hohen Gleichzeitigkeit und Mindestanzahl an Instanzen, dass eine Reihe von Instanzen immer aktiv gehalten werden, um große Trafficspitzen zu bewältigen.

Bei kleineren Apps mit sehr wenig Traffic können Sie niedrige maximale Instanzen mit hoher Parallelität festlegen, damit die App Trafficspitzen ohne übermäßige Kosten bewältigen kann. Wenn die maximale Anzahl von Instanzen zu niedrig festgelegt ist, können Anfragen jedoch verworfen werden, wenn das Limit erreicht ist.

Gleichzeitige Anfragen zulassen

In Cloud Functions for Firebase (1. Generation) konnte jede Instanz jeweils nur eine Anfrage verarbeiten. Das Skalierungsverhalten wurde daher nur mit den Einstellungen für die Mindest- und Höchstanzahl von Instanzen festgelegt. Neben der Anzahl der Instanzen können Sie in Cloud Functions for Firebase (2. Generation) mit der Option concurrency auch die Anzahl der Anfragen steuern, die jede Instanz gleichzeitig bearbeiten kann. Der Standardwert für die Nebenläufigkeit ist 80. Sie können ihn jedoch auf eine beliebige Ganzzahl zwischen 1 und 1.000 festlegen.

Funktionen mit höheren Einstellungen für die Parallelität können Trafficspitzen ohne Kaltstart abfangen, da jede Instanz wahrscheinlich etwas Spielraum hat. Wenn eine Instanz für die Verarbeitung von bis zu 50 gleichzeitigen Anfragen konfiguriert ist, derzeit aber nur 25 Anfragen verarbeitet, kann sie einen Anstieg von 25 zusätzlichen Anfragen bewältigen, ohne dass eine neue Instanz kalt gestartet werden muss. Bei einer Einstellung für die Gleichzeitigkeit von nur 1 könnte dieser Anstieg der Anfragen dagegen zu 25 Kaltstarts führen.

Dieses vereinfachte Szenario zeigt die potenziellen Effizienzsteigerungen durch Parallelität. In der Realität ist das Skalierungsverhalten zur Optimierung der Effizienz und zur Reduzierung von Kaltstarts mit Gleichzeitigkeit komplexer. Die Parallelität in Cloud Functions for Firebase 2. Generation wird von Cloud Run unterstützt und folgt den Regeln von Cloud Run für das Autoscaling von Containerinstanzen.

Wenn Sie mit höheren Einstellungen für die Anzahl gleichzeitiger Streams in Cloud Functions for Firebase (2. Generation) experimentieren, sollten Sie Folgendes beachten:

• Höhere Einstellungen für die Nebenläufigkeit erfordern möglicherweise mehr CPU und RAM für eine optimale Leistung, bis ein praktisches Limit erreicht ist. Eine Funktion, die beispielsweise eine intensive Bild- oder Videoverarbeitung durchführt, hat möglicherweise nicht die Ressourcen, um 1.000 gleichzeitige Anfragen zu verarbeiten, selbst wenn die CPU- und RAM-Einstellungen maximiert sind.
• Da Cloud Functions for Firebase (2. Generation) auf Cloud Run basiert, können Sie auch die Google Cloud-Anleitung zur Optimierung der Parallelität lesen.
• Testen Sie die Funktion für mehrere Währungen gründlich in einer Testumgebung, bevor Sie sie in der Produktion verwenden.

Mindestanzahl von Instanzen einsatzbereit halten

Sie können die Mindestanzahl von Instanzen für eine Funktion im Quellcode festlegen. Mit dieser Funktion werden beispielsweise mindestens 5 Instanzen festgelegt, die warm gehalten werden sollen:

const { onCall } = require("firebase-functions/v2/https");

exports.getAutocompleteResponse = onCall(
  {
    // Keep 5 instances warm for this latency-critical function
    minInstances: 5,
  },
  (event) => {
    // Autocomplete user’s search term
  }
);

@https_fn.on_call(min_instances=5)
def get_autocomplete_response(event: https_fn.CallableRequest) -> https_fn.Response:

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

• Wenn Cloud Functions for Firebase Ihre App über Ihre Einstellung hinaus skaliert, kommt es bei jeder Instanz über diesem Grenzwert zu einem Kaltstart.
• Kaltstarts wirken sich am stärksten auf Apps mit unregelmäßigem Traffic aus. Wenn Ihre App Traffic-Spitzen aufweist und Sie einen Wert festlegen, der hoch genug ist, um Kaltstarts bei jedem Traffic-Anstieg zu reduzieren, wird die Latenz deutlich verringert. Bei Apps mit konstantem Traffic wirken sich Kaltstarts wahrscheinlich nicht negativ auf die Leistung aus.

• Das Festlegen 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 Kaltstarts in Ihrem Produktionsprojekt reduzieren möchten, können Sie in Ihrer parametrisierten Konfiguration einen Wert für die Mindestanzahl von Instanzen festlegen:

  Node.js

  const functions = require('firebase-functions/v1');
  const { defineInt, defineString } = require('firebase-functions/params');
  
  // Define some parameters
  const minInstancesConfig = defineInt('HELLO_WORLD_MININSTANCES');
  const welcomeMessage = defineString('WELCOME_MESSAGE');
  
  // To use configured parameters inside the config for a function, provide them 
  // directly. To use them at runtime, call .value() on them.
  export const helloWorld = functions.runWith({ minInstances: minInstancesConfig}).https.onRequest(
    (req, res) => {
      res.send(`${welcomeMessage.value()}! I am a function.`);
    }
  );
  

  Python

  MIN_INSTANCES = params.IntParam("HELLO_WORLD_MININSTANCES")
  WELCOME_MESSAGE = params.StringParam("WELCOME_MESSAGE")
  
  @https_fn.on_request(min_instances=MIN_INSTANCES.value())
  def get_autocomplete_response(event: https_fn.Request) -> https_fn.Response:
      return https_fn.Response(f"{WELCOME_MESSAGE.value()} I'm a function.")
  

Maximale Anzahl von Instanzen für eine Funktion begrenzen

Sie können einen Wert für die maximale Anzahl von Instanzen im Funktionsquellcode festlegen. Mit dieser Funktion wird beispielsweise ein Limit von 100 Instanzen festgelegt, um eine hypothetische Legacy-Datenbank nicht zu überlasten:

const { onMessagePublished } = require("firebase-functions/v2/pubsub");

exports.mirrorevents = onMessagePublished(
  { topic: "topic-name", maxInstances: 100 },
  (event) => {
    // Connect to legacy database
  }
);

@pubsub_fn.on_message_published(topic="topic-name", max_instances=100)
def mirrorevents(event: pubsub_fn.CloudEvent):
#  Connect to legacy database

Wenn eine HTTP-Funktion auf das maximale Instanzlimit 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 maximale Instanzen finden Sie in diesen Best Practices für das Festlegen maximaler Instanzen.

Zeitüberschreitung und Speicherzuweisung festlegen

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

Wenn Sie die Speicherzuweisung und das Zeitlimit im Quellcode der Funktion festlegen möchten, verwenden Sie die globalen Optionen für Arbeitsspeicher und Zeitlimit in Sekunden, um die virtuelle Maschine anzupassen, auf der Ihre Funktionen ausgeführt werden. Diese Cloud Storage-Funktion verwendet beispielsweise 1 GiB Arbeitsspeicher und es tritt nach 300 Sekunden ein Zeitüberschreitungsfehler auf:

exports.convertLargeFile = onObjectFinalized({
  timeoutSeconds: 300,
  memory: "1GiB",
}, (event) => {
  // Do some complicated things that take a lot of memory and time
});

@storage_fn.on_object_finalized(timeout_sec=300, memory=options.MemoryOption.GB_1)
def convert_large_file(event: storage_fn.CloudEvent):
# Do some complicated things that take a lot of memory and time.

Der Höchstwert für die Zeitüberschreitung in Sekunden ist 540 oder 9 Minuten.

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

1. Wählen Sie in der Google Cloud-Konsole im Menü auf der linken Seite Cloud Functions for Firebase 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 im Drop-down-Menü Zugewiesener Speicher eine Speicherzuweisung aus.
5. Klicken Sie auf Mehr, um die erweiterten Optionen aufzurufen, und geben Sie im Textfeld Zeitüberschreitung eine Anzahl von Sekunden ein.
6. Klicken Sie auf Speichern, um die Funktion zu aktualisieren.

CPU-Standardeinstellungen überschreiben

Bis zu 2 GB Arbeitsspeicher zugewiesen. Jede Funktion in Cloud Functions for Firebase (2. Generation) hat standardmäßig eine CPU und wird dann auf 2 CPUs für 4 und 8 GB erhöht. Das Standardverhalten der 1. Generation unterscheidet sich erheblich von dem der 2. Generation, was zu etwas höheren Kosten für Funktionen mit wenig Arbeitsspeicher führen kann. Das wird in der folgenden Tabelle veranschaulicht:

Wenn Sie das Verhalten der 1. Generation für Ihre Funktionen der 2. Generation bevorzugen, legen Sie die Standardeinstellungen der 1. Generation als globale Option fest:

// Turn off Firebase defaults
setGlobalOptions({ cpu: 'gcf_gen1' });

# Use 1st gen behavior
set_global_options(cpu="gcf_gen1")

Bei CPU-intensiven Funktionen bietet die 2. Generation die Flexibilität, zusätzliche CPU zu konfigurieren. Sie können die CPU-Leistung für einzelne Funktionen steigern, wie hier gezeigt:

// Boost CPU in a function:
export const analyzeImage = onObjectFinalized({ cpu: 2 }, (event) => {
  // computer vision goes here
});

# Boost CPU in a function:
@storage_fn.on_object_finalized(cpu=2)
def analyze_image(event: storage_fn.CloudEvent):
# computer vision goes here