Funktionen verwalten

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, überschreiten Sie möglicherweise das Standardkontingent und erhalten die HTTP-Fehlermeldungen 429 oder 500. Stellen Sie Funktionen in Gruppen von maximal 10 Funktionen bereit, um dieses Problem zu lösen.

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

Standardmäßig sucht die Firebase-Befehlszeile im Ordner functions/ nach dem Quellcode. Wenn Sie möchten, 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-Befehlszeile 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 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 HTTP-ausgelösten Webhook umbenennen möchten, ändern Sie den Code so:

// 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 Produktionstraffic verarbeitet, können Sie Datenverluste verhindern, indem Sie die folgenden Schritte nacheinander ausführen:

1. Benennen Sie die Funktion um und ändern Sie die Region oder Regionen nach Bedarf.
2. Die umbenannte Funktion wird bereitgestellt, wodurch derselbe Code vorübergehend in beiden Regionen ausgeführt wird.
3. Vorherige Funktion löschen.

Wenn Sie beispielsweise eine von Cloud Firestore ausgelöste Funktion 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
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

Führen Sie dann diesen Befehl aus, um die Bereitstellung vorzunehmen:

firebase deploy --only functions:firestoreTriggerAsia

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

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

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:

1. Ändern Sie den Quellcode so, dass er eine neue Funktion mit dem gewünschten Triggertyp enthält.
2. Binden Sie die Funktion ein. Dadurch werden vorübergehend sowohl die alte als auch die neue Funktion ausgeführt.
3. Löschen Sie die alte Funktion mit der Firebase-Befehlszeile explizit aus der Produktion.

Wenn Sie beispielsweise eine Funktion hatten, die beim Löschen eines Objekts ausgelöst wurde, dann aber die Objektversionsverwaltung aktiviert haben und stattdessen das Archivereignis abonnieren möchten, benennen Sie die Funktion zuerst um und bearbeiten Sie sie so, dass sie den neuen Triggertyp erhält.

// 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 Zeitlimit pro Funktion, die Arbeitsspeicherzuweisung und die minimalen/maximalen Funktionsinstanzen auswählen.

Als Best Practice sollten diese Optionen (außer der Node.js-Version) für ein Konfigurationsobjekt innerhalb des Funktionscodes 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 gesetzt ist, führt Firebase die im Code festgelegten Laufzeitoptionen mit den Einstellungen der aktuell bereitgestellten Version Ihrer Funktion mit der folgenden Priorität zusammen:

1. Option im Funktionscode festgelegt: Externe Änderungen überschreiben
2. Die Option ist im Funktionscode auf RESET_VALUE festgelegt: Externe Änderungen werden durch den Standardwert überschrieben.
3. 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 22 (Vorabversion)
• Node.js 20
• Node.js 18

Node.js-Versionen 14 und 16 sind veraltet und werden Anfang 2025 eingestellt. Die Bereitstellung mit diesen veralteten Versionen ist deaktiviert.

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 im Verzeichnis functions/ erstellt wurde. Wenn Sie beispielsweise nur Version 18 verwenden möchten, bearbeiten Sie diese Zeile in package.json:

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

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

1. Achten Sie darauf, dass für Ihr Projekt das Blaze-Preismodell gilt.
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 im Verzeichnis functions/ erstellt wurde. Wenn Sie beispielsweise von Version 18 auf Version 20 umstellen, sollte der Eintrag so aussehen: "engines": {"node": "20"}
4. Optional können Sie Ihre Änderungen mit Firebase Local Emulator Suite testen.
5. Stellen Sie alle Funktionen neu bereit.

Python-Version festlegen

Mit dem Firebase SDK für Cloud Functions Version 12.0.0 und höher können Sie die Python-Laufzeit auswählen. Legen Sie die Laufzeitversion in firebase.json wie unten gezeigt fest:

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

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.

Mit diesen Einstellungen und der Gleichzeitigkeit pro Instanz (neu in der 2. Generation) können Sie das Skalierungsverhalten Ihrer Funktionen steuern und optimieren. Die Art Ihrer Anwendung und Funktion bestimmt, welche Einstellungen am kostengünstigsten sind und die beste Leistung erzielen.

Für einige Anwendungen mit geringem Traffic ist eine niedrigere CPU-Option ohne Mehrfach-Nebenläufigkeit optimal. Bei anderen Anwendungen, bei denen Kaltstarts ein kritisches Problem darstellen, bedeutet eine hohe Gleichzeitigkeit und eine Mindestanzahl von Instanzen, dass eine Reihe von Instanzen immer warm gehalten wird, um große Trafficspitzen zu bewältigen.

Bei kleineren Apps, die nur sehr wenig Traffic erhalten, können Sie eine niedrige maximale Anzahl von Instanzen mit hoher Parallelität festlegen, damit die App Verkehrsspitzen bewältigen kann, ohne dass unnötige Kosten anfallen. Wenn Sie die maximale Anzahl von Instanzen jedoch zu niedrig festlegen, werden Anfragen möglicherweise abgelehnt, wenn die Obergrenze 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 die Maximalzahl von Instanzen festgelegt. In Cloud Functions for Firebase (2. Generation) können Sie nicht nur die Anzahl der Instanzen steuern, sondern auch mit der Option concurrency die Anzahl der Anfragen, die jede Instanz gleichzeitig bedienen kann. Der Standardwert für die Nebenläufigkeit ist 80. Sie können ihn jedoch auf eine beliebige ganze Zahl zwischen 1 und 1.000 festlegen.

Funktionen mit höheren Einstellungen für die Parallelität können Verkehrsspitzen ohne Kaltstart absorbieren, da jede Instanz wahrscheinlich einen gewissen Spielraum hat. Wenn eine Instanz so konfiguriert ist, dass sie bis zu 50 gleichzeitige Anfragen verarbeiten kann, derzeit aber nur 25 bearbeitet, kann sie einen Anstieg von 25 zusätzlichen Anfragen verarbeiten, ohne dass eine neue Instanz mit Kaltstart erforderlich ist. Bei einer Parallelitätseinstellung von nur 1 könnte dieser Anstieg der Anfragen zu 25 Kaltstarts führen.

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

Beim Experimentieren mit höheren Gleichzeitigkeitseinstellungen in Cloud Functions for Firebase (2. Generation) ist Folgendes zu beachten:

• Höhere Gleichzeitigkeitseinstellungen erfordern möglicherweise mehr CPU und RAM für eine optimale Leistung, bis ein praktischer Grenzwert erreicht ist. Eine Funktion, die eine intensive Bild- oder Videoverarbeitung erfordert, hat möglicherweise nicht genügend Ressourcen, um 1.000 gleichzeitige Anfragen zu verarbeiten, auch wenn die CPU- und RAM-Einstellungen maximiert sind.
• Da Cloud Functions for Firebase (2. Generation) auf Cloud Run basiert, können Sie sich auch an die Google Cloud-Anleitung zur Optimierung der Parallelität halten.
• Testen Sie die Mehrfach-Gleichzeitigkeit gründlich in einer Testumgebung, bevor Sie in der Produktion auf Multi-Parallelität umstellen.

Mindestanzahl von Instanzen in Bereitschaft halten

Sie können die Mindestanzahl von Instanzen für eine Funktion im Quellcode festlegen. Mit dieser Funktion wird beispielsweise ein Minimum von 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:

Beachten Sie beim Festlegen eines Mindestwerts für Instanzen Folgendes:

• Wenn Cloud Functions for Firebase Ihre Anwendung über Ihre Einstellung hinaus skaliert, kommt es für jede 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 Wert festlegen, der hoch genug ist, um bei jeder Zugriffssteigerung 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 Kaltstarts in Ihrem Produktionsprojekt reduzieren möchten, können Sie in Ihrer parametrisierten Konfiguration einen Mindestwert für 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 im Funktions-Quellcode einen Wert für die maximale Anzahl von Instanzen 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 die maximale Anzahl von Instanzen 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 der Einstellungen für die maximale Anzahl von Instanzen finden Sie in den Best Practices zum Festlegen der maximalen Anzahl von Instanzen.

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-Konsole oder im Quellcode der Funktion festlegen (nur Firebase).

Um die Arbeitsspeicherzuweisung und das Zeitlimit im Quellcode von Funktionen festzulegen, verwenden Sie die globalen Optionen für Arbeitsspeicher und Zeitlimits in Sekunden, um die virtuelle Maschine anzupassen, die Ihre Funktionen ausführt. Diese Cloud Storage-Funktion belegt beispielsweise 1 GiB Arbeitsspeicher und löst nach 300 Sekunden einen Zeitüberschreitungsfehler aus:

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 maximale Wert für die Zeitüberschreitung in Sekunden ist 540, also 9 Minuten.

So legen Sie die Arbeitsspeicherzuweisung 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 oben im Menü 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 im Textfeld Zeitüberschreitung eine Zeit in Sekunden ein.
6. Klicken Sie auf Speichern, um die Funktion zu aktualisieren.

CPU-Standardeinstellungen überschreiben

Bei bis zu 2 GB zugewiesenem Arbeitsspeicher wird jeder Funktion in Cloud Functions for Firebase (2. Generation) standardmäßig eine CPU zugewiesen. Bei 4 und 8 GB erhöht sich die Anzahl auf zwei CPUs. Das unterscheidet sich deutlich vom Standardverhalten der 1. Generation und kann zu etwas höheren Kosten für Funktionen mit geringem Arbeitsspeicherbedarf führen, wie in der folgenden Tabelle dargestellt:

Wenn Sie das Verhalten der 1. Generation für 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 können Sie mit der 2. Generation flexibel eine zusätzliche CPU konfigurieren. Sie können die CPU für einzelne Funktionen beschleunigen, wie hier dargestellt:

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