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 einen HTTP-ausgelösten Webhook haben, den Sie umbenennen möchten, überarbeiten Sie den Code wie folgt:

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

Ä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 über eine durch Cloud Firestore ausgelöste Funktion verfügen, die sich derzeit in der Standardfunktionsregion von 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 zu überarbeiten die Region.

// 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 es dann bereit, indem Sie Folgendes ausführen:

firebase deploy --only functions:firestoreTriggerAsia

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

Dann löschen Sie firestoreTrigger :

firebase functions:delete firestoreTrigger

Jetzt gibt es nur noch eine Funktion – firestoreTriggerAsia , 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 Funktion hatten, die beim Löschen eines Objekts ausgelöst wurde, Sie dann aber die Objektversionierung aktiviert haben und stattdessen das Archivereignis abonnieren möchten, benennen Sie zunächst die Funktion um und bearbeiten Sie sie so, dass sie den neuen Auslösertyp 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 zunächst 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

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.

Legen Sie die Python-Version fest

Firebase SDK für Cloud Functions-Versionen 12.0.0 und höher ermöglichen die Auswahl der Python-Laufzeit. Legen Sie die Laufzeitversion in firebase.json wie gezeigt 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 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.

Wenn Sie diese Einstellungen zusammen mit der instanzspezifischen Parallelitätseinstellung (neu in der 2. Generation) verwenden, können Sie das Skalierungsverhalten für Ihre 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 Apps mit geringem Datenverkehr ist eine niedrigere CPU-Option ohne Multi-Parallelität optimal. Für andere, bei denen Kaltstarts ein kritisches Problem darstellen, bedeutet die Festlegung einer hohen Parallelität und minimaler Instanzen, dass eine Reihe von Instanzen immer warm gehalten werden, um große Datenverkehrsspitzen zu bewältigen.

Bei kleineren Apps, die sehr wenig Datenverkehr empfangen, bedeutet das Festlegen niedriger maximaler Instanzen mit hoher Parallelität, dass die App Datenverkehrsspitzen verarbeiten kann, ohne dass übermäßige Kosten entstehen. Beachten Sie jedoch, dass bei einer zu niedrigen Anzahl an Instanzen die Anforderungen möglicherweise verworfen werden, wenn die Obergrenze erreicht ist.

Gleichzeitige Anfragen zulassen

In Cloud Functions für Firebase (1. Generation) konnte jede Instanz jeweils eine Anfrage verarbeiten, daher wurde das Skalierungsverhalten nur mit minimalen und maximalen Instanzeinstellungen festgelegt. Zusätzlich zur Steuerung der Anzahl der Instanzen können Sie in Cloud Functions für Firebase (2. Generation) mit der concurrency die Anzahl der Anfragen steuern, die jede Instanz gleichzeitig bedienen kann. Der Standardwert für Parallelität ist 80, Sie können ihn jedoch auf eine beliebige Ganzzahl zwischen 1 und 1000 festlegen.

Funktionen mit höheren Parallelitätseinstellungen können Datenverkehrsspitzen ohne Kaltstart absorbieren, da wahrscheinlich jede Instanz über einen gewissen Spielraum verfügt. Wenn eine Instanz für die Verarbeitung von bis zu 50 gleichzeitigen Anforderungen konfiguriert ist, derzeit aber nur 25 verarbeitet, kann sie eine Spitze von 25 zusätzlichen Anforderungen verarbeiten, ohne dass ein Kaltstart einer neuen Instanz erforderlich ist. Im Gegensatz dazu könnte dieser Anstieg der Anfragen bei einer Parallelitätseinstellung von nur 1 zu 25 Kaltstarts führen.

Dieses vereinfachte Szenario zeigt die potenziellen Effizienzgewinne der Parallelität. In Wirklichkeit ist die Skalierung des Verhaltens zur Optimierung der Effizienz und zur Reduzierung von Kaltstarts durch Parallelität komplexer. Die Parallelität in Cloud Functions für Firebase der 2. Generation wird von Cloud Run unterstützt und folgt den Cloud Run-Regeln für die automatische Skalierung von Containerinstanzen .

Beachten Sie beim Experimentieren mit höheren Parallelitätseinstellungen in Cloud Functions für Firebase (2. Generation) Folgendes:

• Höhere Parallelitätseinstellungen erfordern möglicherweise eine höhere CPU- und RAM-Leistung für eine optimale Leistung, bis eine praktische Grenze erreicht ist. Einer Funktion, die beispielsweise umfangreiche Bild- oder Videoverarbeitung durchführt, fehlen möglicherweise die Ressourcen, um 1000 gleichzeitige Anforderungen zu verarbeiten, selbst wenn ihre CPU- und RAM-Einstellungen maximiert sind.
• Da Cloud Functions für Firebase (2. Generation) auf Cloud Run basiert, können Sie zur Optimierung der Parallelität auch auf die Google Cloud-Anleitung zurückgreifen.
• Stellen Sie sicher, dass Sie die Multi-Parallelität gründlich in einer Testumgebung testen, bevor Sie in der Produktion auf Multi-Parallelität umsteigen.

Halten Sie eine Mindestanzahl an Exemplaren warm

Sie können die Mindestanzahl von Instanzen für eine Funktion im Quellcode festlegen. Diese Funktion legt beispielsweise mindestens 5 Instanzen zum Warmhalten fest:

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:

Beim Festlegen eines Mindestinstanzwerts sind folgende Dinge zu beachten:

• Wenn Cloud Functions for Firebase Ihre App über Ihre 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 einen spitzen Datenverkehr aufweist und Sie einen Wert festlegen, der hoch genug ist, dass Kaltstarts bei jedem Verkehrsanstieg 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 in Ihrer parametrisierten Konfiguration einen Mindestinstanzwert festlegen:

  Node.js

  const functions = require('firebase-functions');
  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.")
  

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

Sie können einen Wert für die maximale Anzahl an Instanzen im Funktionsquellcode festlegen. Diese Funktion legt beispielsweise ein Limit von 100 Instanzen fest, 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 hochskaliert 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 Instanzenzahl finden Sie in den folgenden Best Practices für die Festlegung der maximalen Instanzenzahl .

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 Timeout im Funktionsquellcode festzulegen, verwenden Sie die globalen Optionen für Speicher und Timeout-Sekunden, um die virtuelle Maschine anzupassen, auf der Ihre Funktionen ausgeführt werden. Diese Cloud-Speicherfunktion verwendet beispielsweise 1 GB Speicher und läuft nach 300 Sekunden ab:

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 Timeout-Sekunden beträgt 540 bzw. 9 Minuten.

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

CPU-Standardwerte überschreiben

Bis zu 2 GB zugewiesener Speicher, jede Funktion in Cloud Functions für Firebase (2. Generation) nutzt standardmäßig eine CPU und erhöht sich dann auf 2 CPUs für 4 und 8 GB. Beachten Sie, dass sich dies erheblich vom Standardverhalten der 1. Generation unterscheidet und zu etwas höheren Kosten für Funktionen mit geringem Arbeitsspeicher führen kann, wie in der folgenden Tabelle dargestellt:

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")

Für CPU-intensive Funktionen bietet die 2. Generation die Flexibilität, zusätzliche CPU zu konfigurieren. Sie können die CPU wie gezeigt pro Funktion steigern:

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