Firebase Extensions zu einem selbst erstellten Funktions-Kit migrieren

Migrationspfad auswählen: Zu Funktions-Kits auf npm migrieren Zu selbst erstelltem Funktions-Kit migrieren

Wenn ein Publisher kein offizielles Ersatz-Kit erstellt hat, das über npm verteilt wird, finden Sie in dieser Anleitung die Schritte, um die Erweiterung zu forken und als lokales Funktions-Kit einzurichten.

Bekannte Einschränkungen bei der Migration prüfen

Bevor Sie mit der Migration einer Erweiterungsinstanz beginnen, prüfen Sie, ob in Ihrer Einrichtung eine der folgenden Funktionen verwendet wird, die eine Problemumgehung erfordern oder in Funktions-Kits noch nicht unterstützt werden:

  • Benutzerdefinierte Docker-Repositories und KMS-Schlüssel erfordern eine manuelle Problemumgehung Cloud Functions for Firebase unterstützt keine Ersatzsystemparameter für die Konfiguration eines benutzerdefinierten Docker-Repositorys oder eines kundenverwalteten Verschlüsselungsschlüssels (KMS-Schlüssel). Wenn in Ihrer Erweiterung einer dieser Parameter konfiguriert ist, finden Sie weitere Informationen im FAQ-Workaround.

Hinweis

Sie müssen die Firebase-Befehlszeile einrichten und ein Firebase-Projekt initialisieren. Wenn Sie die Befehlszeile verwenden, achten Sie darauf, dass Sie die firebase-tools-Version >= 15.32.0 verwenden, die die neuen Migrations- und Funktions-Kit-Befehle enthält.

Erforderliche Kontoberechtigungen und Rollen

Je nachdem, was während der Migration von der Firebase-Befehlszeile erstellt und konfiguriert werden muss, muss das Konto, das Sie zur Authentifizierung bei Firebase und Google Cloud verwenden, die folgenden Rollen haben:

  • roles/firebaseextensions.editor
  • roles/cloudbuild.builds.editor
  • roles/artifactregistry.writer
  • roles/run.developer
  • roles/iam.serviceAccountUser
  • roles/iam.serviceAccountCreator
  • roles/cloudfunctions.admin (wenn Sie setIamPermissions für öffentliche Endpunkte ausführen müssen)
  • roles/secretmanager.admin (falls Secrets verwendet werden)
  • roles/serviceusage.serviceUsageAdmin (wenn Sie neue APIs aktivieren müssen)

Wir empfehlen, ein Konto zu verwenden, mit dem bereits Erweiterungen installiert und Funktionen bereitgestellt wurden, da die meisten dieser Berechtigungen dann bereits gewährt wurden. Wenn Ihr Migrationskonto weitere Rollen benötigt, folgen Sie der IAM-Anleitung für Google Cloud, um sie hinzuzufügen.

Upgrade der Erweiterungsinstanz auf die aktuelle Version

Sie müssen Ihre Erweiterung auf die aktuelle Version aktualisieren, um den Unterschied zwischen Ihrer Erweiterungsinstanz und dem Ersatz-Kit zu minimieren. Wenn Sie Ihre Erweiterung nicht aktualisieren, kann es zu erheblichen, funktionsgefährdenden Änderungen zwischen Ihrer Erweiterungsinstanz und dem Ersatz-Kit kommen. Die exportierte Konfiguration entspricht aufgrund von Parameteränderungen zwischen den Versionen möglicherweise nicht den Erwartungen des Kits.

Verwenden Sie eine der folgenden Optionen, um Ihre Erweiterung zu aktualisieren, je nachdem, wo sie installiert wurde:

  • Über die Firebase-Konsole
  • Über die Firebase-Befehlszeile mit:
    • firebase ext:update <extension-instance-id> --project <project-id> firebase deploy --only extensions --project <project-id>

Wenn Sie diesen Schritt überspringen, werden Sie von der Befehlszeile beim Exportieren der Konfiguration aufgefordert, ein Upgrade durchzuführen, wenn Ihre Erweiterung nicht die aktuelle Version hat.

Erweiterung in ein lokales Funktions-Kit forken

Bevor Sie mit der Konvertierung einer Erweiterung in ein lokales Funktions-Kit beginnen, müssen Sie dafür sorgen, dass sich der Quellcode der Erweiterung in Ihrem Firebase-Projekt befindet. Klonen Sie dazu das Erweiterungs-Repository von GitHub, erstellen Sie ein Verzeichnis im Stammverzeichnis Ihres Firebase-Projekts und kopieren Sie den Ordner functions/ und die Datei extension.yaml der Erweiterung dorthin:

mkdir -p path/to/kit
cp -r /path/to/extension-source/functions/* path/to/kit/
cp /path/to/extension-source/extension.yaml path/to/kit/.

Folgen Sie den Schritten 1 bis 8 in der Migrationsanleitung für Publisher, um den Quellcode Ihrer Erweiterung zu einer Funktion der 2. Generation zu migrieren. Fahren Sie dann mit den folgenden Schritten fort.

Lokales Kit so anpassen, dass es die Region der exportierten Funktion und erweiterte Parameter unterstützt

In einem lokalen Funktions-Kit generiert die Firebase-Befehlszeile keine index.ts-Datei, um das Paket einzurichten und für die Verwendung migrierter Systemparameter zu konfigurieren. Wenn Sie die Funktionsregion und die erweiterten Parameter verwenden möchten, die für Ihre Erweiterung konfiguriert wurden, richten Sie Ihre index.ts-Datei so ein, dass das von firebase ext:export --mode functions exportierte Format in eine Umgebungsvariablendatei eingelesen wird.

Definieren Sie in der index.ts-Datei auf oberster Ebene, die Ihre Funktionen exportiert, einen Parameter für FUNCTION_DEFAULT_REGION und rufen Sie setGlobalOptions mit Umgebungsvariablen im Format EXT_MIGRATED_SYSTEM_<GLOBAL_OPTION> auf, ähnlich der Vorlage index-kit-migration.ts, die von der Befehlszeile verwendet wird:

import { setGlobalOptions } from "firebase-functions";
import { MemoryOption, VpcEgressSetting, IngressSetting } from "firebase-functions/v2/options";
import { defineString } from "firebase-functions/params";

export const regionParam = defineString("FUNCTION_DEFAULT_REGION", {
  input: { text: { nonEmpty: true } },
  description: "Global default region where functions should be deployed. Can be overridden per-function.",
});

setGlobalOptions({
  region: regionParam,
  memory: (process.env.EXT_MIGRATED_SYSTEM_MEMORY as MemoryOption) ?? undefined,
  timeoutSeconds: process.env.EXT_MIGRATED_SYSTEM_TIMEOUTSECONDS
    ? Number(process.env.EXT_MIGRATED_SYSTEM_TIMEOUTSECONDS)
    : undefined,
  vpcConnectorEgressSettings:
    process.env.EXT_MIGRATED_SYSTEM_VPCCONNECTOREGRESSSETTINGS &&
    process.env.EXT_MIGRATED_SYSTEM_VPCCONNECTOREGRESSSETTINGS !== "VPC_CONNECTOR_EGRESS_SETTINGS_UNSPECIFIED"
      ? (process.env.EXT_MIGRATED_SYSTEM_VPCCONNECTOREGRESSSETTINGS as VpcEgressSetting)
      : undefined,
  vpcConnector: process.env.EXT_MIGRATED_SYSTEM_VPCCONNECTOR ?? undefined,
  maxInstances: process.env.EXT_MIGRATED_SYSTEM_MAXINSTANCES
    ? Number(process.env.EXT_MIGRATED_SYSTEM_MAXINSTANCES)
    : undefined,
  minInstances: process.env.EXT_MIGRATED_SYSTEM_MININSTANCES
    ? Number(process.env.EXT_MIGRATED_SYSTEM_MININSTANCES)
    : undefined,
  ingressSettings: (process.env.EXT_MIGRATED_SYSTEM_INGRESSSETTINGS as IngressSetting) ?? undefined,
  // Parses a comma-separated string of key:value pairs into a key-value object
  // (for example, "key1:value1,key2:value2" -> { key1: "value1", key2: "value2" }).
  labels: process.env.EXT_MIGRATED_SYSTEM_LABELS
    ? process.env.EXT_MIGRATED_SYSTEM_LABELS.split(",").reduce<Record<string, string> | undefined>(
        (acc, curr) => {
          const [key, value] = curr.split(":");
          const trimmedKey = key?.trim();
          const trimmedValue = value?.trim();
          if (!trimmedKey || !trimmedValue) {
            return acc;
          }
          acc = acc ?? {};
          acc[trimmedKey] = trimmedValue;
          return acc;
        },
        undefined,
      )
    : undefined,
});

// Re-export all functions so the Firebase CLI can deploy them
export * from "./your-functions";

Kit vor der Migration testen

Sie haben jetzt ein lokales Funktions-Kit, das sich nach der Bereitstellung genauso verhält wie eine neue Installation Ihrer Erweiterung. Im nächsten Schritt müssen Sie alle Probleme, die versehentlich aufgetreten sind, überprüfen und beheben, bevor Sie Ihre Produktionserweiterungsinstanzen dorthin migrieren.

Fügen Sie zuerst Ihren Fork als lokales Kit hinzu, konfigurieren Sie ihn und stellen Sie ihn in einem Testprojekt bereit. Lokale Funktions-Kits müssen sich in Ihrem Firebase-Projekt befinden. Wenn sich das geklonte Erweiterungs-Repository außerhalb Ihres Firebase-Projekts befindet, verschieben Sie es in das Projektverzeichnis. Führen Sie dann den folgenden Befehl zur Kit-Installation aus, um es als lokales Kit zu installieren:

firebase functions:kits:install --directory <path-to-your-fork> --project <test-project-id>

Dieser Befehl führt Sie durch die Auswahl einer Kit-ID, einer Instanz-ID und einer Konfiguration für Ihre erste Testinstanz. Anschließend wird die Datei firebase.json geändert, um ein lokales Kit zu registrieren, das auf Ihr geforktes Verzeichnis verweist. Die Konfigurationen für jede Instanz werden in einer .env-Datei unter function-kits/<kit-id>/config-<instance-id> gespeichert.

Stellen Sie Ihr lokales Kit in einem Testprojekt mit den entsprechenden Ressourcen bereit, um das Verhalten zu testen. Wenn Sie bereits ein Testprojekt zum Testen Ihrer Erweiterung eingerichtet haben, führen Sie den folgenden Befehl aus:

firebase deploy --only functions:<kit-instance-id> --project <test-project-id>

Beispiel: Cloud Firestore in BigQuery streamen (firestore-bigquery-export)

Prüfen Sie die Synchronisierung von Cloud Firestore mit BigQuery:

  1. Erstellen Sie auf der Seite Cloud Firestore der Firebase Console die Sammlung, die Sie als COLLECTION_PATH (users) festgelegt haben, falls sie noch nicht vorhanden ist.
  2. Erstellen Sie ein Dokument mit dem Namen bigquery-mirror-test, das beliebige Felder mit beliebigen Werten enthält.

  3. Fragen Sie auf der Seite BigQuery der Google Cloud Console die Tabelle mit dem Roh-Änderungsprotokoll ab. Es sollte eine einzelne Zeile enthalten, in der die Erstellung des Dokuments protokolliert wird:

    SELECT * FROM `PROJECT_ID.analytics.users_raw_changelog`

  4. Fragen Sie die neueste Ansicht ab, die das neueste Änderungsereignis für das einzige vorhandene Dokument (bigquery-mirror-test) zurückgeben sollte:

    SELECT * FROM `PROJECT_ID.analytics.users_raw_latest`

  5. Löschen Sie das Dokument bigquery-mirror-test in Cloud Firestore. Sie verschwindet aus der neuesten Ansicht und ein DELETE-Ereignis wird an die Tabelle mit dem Rohänderungsprotokoll angehängt.

    Sie können den vollständigen Verlauf eines einzelnen Dokuments mit folgendem Befehl prüfen:

    SELECT *
   FROM `PROJECT_ID.analytics.users_raw_changelog`
   WHERE document_name = "bigquery-mirror-test"
   ORDER BY timestamp ASC

Unterschiede beim Testen der Erweiterung:

  • Der Trigger wird als kit-<kit-instance-id>-fsexportbigquery und nicht als ext-<instanceId>-fsexportbigquery bereitgestellt. Suchen Sie im Dashboard und in den Logs von Cloud Functions nach diesem Namen.
  • Ihr Code wird in Firebase Local Emulator Suite als Standardfunktionen ausgeführt. Sie können Parameterwerte für die Verwendung im Emulator mit .env.local festlegen. Sie können Ihren Code auch mit dem firebase-functions-test SDK testen, wie unter Unittests für Cloud Functions beschrieben.
  • Die Bereitstellung wird nicht mehr von der Erweiterungslaufzeit gesteuert. Wenn die Änderungsprotokolltabelle nach der Bereitstellung fehlt, führen Sie die Einrichtungsaufgabe manuell noch einmal aus: firebase functions:lifecycle:run afterFirstDeploy <kit-instance-id>. Die Aufgabe ist idempotent. Wenn Sie sie noch einmal ausführen, werden das Dataset, die Tabelle und die Ansichten abgeglichen.
  • Die Parameterwerte stammen aus .env und nicht aus dem Installationsformular. Daher sind Wiederholungen von firebase deploy nicht interaktiv, sobald .env abgeschlossen ist.

(Optional) Testdaten bereinigen

Wenn Sie diese Testinstanz nach dem Testen entfernen möchten, deinstallieren Sie sie:

firebase functions:kits:uninstall --instance <kit-instance-id> --project <test-project-id>

Dadurch werden alle Cloud-Ressourcen gelöscht, die durch die Bereitstellung des Kits erstellt wurden, und die Instanzkonfiguration wird entfernt. Wenn Sie nur eine Instanz des Kits haben, wird der Kit-Eintrag auch aus firebase.json entfernt. Das lokale Quellcodeverzeichnis wird nicht gelöscht. Wenn Sie das Kit für die Produktionsmigration installieren, können Sie wieder eine Kit-ID auswählen.

Von Erweiterungen zu Ihrem lokalen Kit migrieren

Nachdem Sie Ihr lokales Kit getestet haben, können Sie Ihre live bereitgestellte Erweiterungsinstanz migrieren.

1. Ersatzinstanz des Funktions-Kits installieren

Installieren Sie Ihr lokales Funktions-Kit und übergeben Sie --no-configure, um die manuelle Konfiguration zu überspringen, damit im nächsten Schritt Ihre vorhandene Erweiterungskonfiguration direkt in diese Kit-Instanz exportiert werden kann:

firebase functions:kits:install --no-configure --directory <path-to-your-fork> --project <project-id>

2. Konfigurieren Sie die Funktions-Kit-Instanz identisch mit der Erweiterung.

Sie müssen diese Kit-Instanz mit einer Konfiguration anpassen, die mit der zu ersetzenden Erweiterung identisch ist. Sie können die Konfiguration Ihrer Erweiterungsinstanz in eine .env-Datei exportieren, in der Parameter, Umgebungsvariablen und Secret-Referenzkonfigurationsdaten für alle Cloud Functions, einschließlich Kits, gespeichert werden. Führen Sie den folgenden Befehl aus, um sie direkt in die Konfigurationsdatei Ihres Kits zu exportieren:

firebase ext:export --mode functions --instance <extension-instance-id> --kit-instance <kit-instance-id> --project <project-id>

Am Ende dieses Schritts werden die Konfigurationsinformationen für diese Instanz in einer projektspezifischen .env-Datei im Konfigurationsverzeichnis Ihrer Instanz gespeichert, z. B.: function-kits/<kit-name>/config-<instance-id>/.env.<project-id>

3. Kit-Ersatz bereitstellen und prüfen

Nachdem das Kit installiert und als eine Reihe von Funktionen verfügbar ist, können Sie den Kit-Ersatz bereitstellen. Funktions-Kits funktionieren wie Standardfunktionen, wobei jede Kit-Instanz als separate Codebasis zum Organisieren Ihrer Funktionen dient. Sie können alle Funktionen oder nur eine bestimmte Kit-Instanz bereitstellen. Wenn Sie eine einzelne Erweiterungsinstanz migrieren, stellen Sie nur diese Kit-Instanz bereit.

Wenn Ihr Kit neue Parameter verwendet, die in der Erweiterungsinstanz, von der Sie migriert sind, nicht vorhanden waren, werden Sie von der Firebase-Befehlszeile zu Beginn des Bereitstellungsprozesses dazu aufgefordert, diese anzugeben. Das ist in diesem Beispiel einer aktuellen firestore-bigquery-export-Erweiterung nicht zu erwarten, aber bei vielen Kits wird für jede vom Kit verwendete Ereignistriggerquelle ein neuer Parameter abgefragt. Im Rahmen dieser Migration werden in aktualisierten Kits Funktionen der 2. Generation verwendet, während in Erweiterungen zuvor Funktionen der 1. Generation verwendet wurden. In der 2. Generation befinden sich Funktionen in der Nähe ihrer Ereignisquellen und werden als zusätzlicher Parameter hinzugefügt. Wenn in zukünftigen Updates neue Parameter hinzugefügt werden, werden Sie von der Befehlszeile bei der nächsten Bereitstellung dazu aufgefordert.

Beispiel:

firebase deploy --only functions:firestore-bigquery-export --project my-project

Ausgabe:

=== Deploying to 'my-project'...
i  deploying functions
i  functions: Loaded environment variables from function-kits/firestore-bigquery-export/config-firestore-bigquery-export/.env.my-project
i  functions: ensuring required API bigquery.googleapis.com is enabled...
i  functions: ensuring required API cloudtasks.googleapis.com is enabled...
✔  functions: required APIs are enabled
i  functions: granting declarative IAM roles to managed service account:
   - BigQuery Data Editor
   - BigQuery User
   - Cloud Datastore User
   - Eventarc Event Receiver
   - roles/run.invoker
✔  functions: successfully granted IAM roles
i  functions: creating Node.js 22 (2nd Gen) function kit-firestore-bigquery-export-fsexportbigquery(us-central1)...
i  functions: creating Node.js 22 (2nd Gen) function kit-firestore-bigquery-export-initBigQuerySync(us-central1)...
i  functions: creating Node.js 22 (2nd Gen) function kit-firestore-bigquery-export-setupBigQuerySync(us-central1)...
✔  functions[kit-firestore-bigquery-export-fsexportbigquery(us-central1)] Successful create operation.
✔  functions[kit-firestore-bigquery-export-initBigQuerySync(us-central1)] Successful create operation.
✔  functions[kit-firestore-bigquery-export-setupBigQuerySync(us-central1)] Successful create operation.
i  functions: Executing afterFirstDeploy lifecycle hook targeting: kit-firestore-bigquery-export-initBigQuerySync...
✔  functions: Successfully queued task for lifecycle hook kit-firestore-bigquery-export-initBigQuerySync in queue projects/my-project/locations/us-central1/queues/kit-firestore-bigquery-export-initBigQuerySync.
✔  Deploy complete!

Prüfen Sie in den Bereitstellungslogs, ob Lebenszyklus-Hooks ausgelöst wurden, um festzustellen, ob die firebase deploy des Kits fehlerfrei war. Beliebte Erweiterungen wie „Stream Cloud Firestore to BigQuery“ verwenden Lebenszyklus-Hooks. Das folgende Beispiel zeigt, wie ein Lebenszyklus-Hook aussieht, wenn er ausgelöst wird:

i  functions: Executing afterFirstDeploy lifecycle hook targeting: kit-firestore-bigquery-export-initBigQuerySync...
✔  functions: Successfully queued task for lifecycle hook kit-firestore-bigquery-export-initBigQuerySync in queue projects/my-project/locations/europe-west1/queues/kit-firestore-bigquery-export-initBigQuerySync.
i  functions: View logs for afterFirstDeploy at: https://console.cloud.google.com/logs/query;query=resource.type%3D%22cloud_run_revision%22%0Aresource.labels.service_name%3D%22kit-firestore-bigquery-export--initbigquerysync%22%0Aresource.labels.location%3D%22europe-west1%22;project=my-project

Diese Logeinträge bestätigen Folgendes:

  • Ein Lebenszyklus-Hook wurde gefunden und ausgeführt.
  • Eine Aufgabe wurde in die mit dem Lebenszyklus-Hook verknüpfte Aufgabenwarteschlange eingereiht.
  • Es wurde ein Link zu Cloud Logging bereitgestellt, damit Sie prüfen können, ob die Aufgabe ohne Fehler abgeschlossen wurde.

Folgen Sie dem Link zu den Logs in der Google Cloud-Konsole, um zu prüfen, ob die Logs keine Fehler enthalten und das Ereignis der Aufgabenwarteschlange erfolgreich verarbeitet wurde. Wenn das Lifecycle-Event nicht erfolgreich ausgeführt wurde, können Sie es mit folgendem Befehl noch einmal auslösen:

firebase functions:lifecycle:run <hook-name> <codebase>

Wenn Sie zum ersten Mal eine Funktions-Kit-Instanz bereitstellen, führen Sie Folgendes aus:

firebase functions:lifecycle:run afterFirstDeploy <kit-instance-id>

Wenn Sie die Migration während der Validierung beenden oder rückgängig machen möchten, können Sie das Kit deinstallieren. Folgen Sie dazu der Anleitung unter Erweiterung deinstallieren.

Nachdem Sie überprüft haben, dass die erste Bereitstellung Ihres Funktions-Kits erfolgreich abgeschlossen wurde, müssen Sie prüfen, ob die Funktionen des Kits wie erwartet funktionieren. Da die Erweiterung selbst noch ausgeführt wird, müssen Sie darauf achten, dass Sie nicht nur prüfen, ob eine der beiden funktioniert hat, da die Erweiterung funktioniert hat und weiterhin funktionieren wird.

Wenn die Verarbeitung nicht geändert wird und Sie keine doppelten Ergebnisse von der Erweiterung und dem Kit sehen, ist es am besten, die Logs für das Kit direkt zu prüfen, nachdem Sie die Funktionalität des Kits ausgelöst haben.

Beispiel: Cloud Firestore zu BigQuery streamen

Bei der Erweiterung „Stream Cloud Firestore to BigQuery“ werden Schreibvorgänge sowohl in die Tabelle mit dem Rohänderungsprotokoll (*_raw_changelog) als auch in die Tabelle mit der neuesten Ansicht (*_raw_latest) dedupliziert, wenn dasselbe Ereignis an das Kit und die Erweiterung gesendet wird. Sie können also nicht anhand des Vorhandenseins von Zeilen oder doppelten Zeilen in BigQuery prüfen, ob das Kit funktioniert.

Sie können die Funktionslogs kurz nach dem Schreiben in Ihre Firestore-Sammlung mit firebase functions:logs aufrufen und nach einem Logeintrag suchen, der angibt, dass ein Schreibvorgang erfolgreich verarbeitet wurde. Für dieses Kit mit der Standardinstanz-ID firestore-bigquery-export würde das so aussehen:

2026-09-25T19:52:46.328612Z I kit-firestore-bigquery-export-fsexportbigquery: Started execution of extension
2026-09-25T19:52:46.328644Z I kit-firestore-bigquery-export-fsexportbigquery: {"message":"Firestore event received by onDocumentWritten trigger","document_name":"projects/extensions-eventarc-testing/databases/(default)/documents/exported-messages/cmGP6XLyksqGdw2OgTOq","operation":0,"event_id":"9f59a2a4-1a5e-4c41-a32d-561e3c734502"}
2026-09-25T19:52:46.616064Z I kit-firestore-bigquery-export-fsexportbigquery: Completed execution of extension
2026-09-2

Wenn Sie viele Logs haben, können Sie mit dem folgenden Befehl nach einer bestimmten Kit-Funktion filtern:

firebase functions:log --only <function name>

Mit dem folgenden Befehl können Sie die spezifischen Funktionsnamen für eine Kit-Instanz ermitteln:

firebase functions:list | grep kit-<kit instance id>

In diesem Beispiel:

firebase functions:list | grep kit-firestore-bigquery-export
│ kit-firestore-bigquery-export-fsexportbigquery  │ v2      │ google.cloud.firestore.document.v1.written                    │
│ kit-firestore-bigquery-export-initBigQuerySync  │ v2      │ taskQueue                                                     │
│ kit-firestore-bigquery-export-setupBigQuerySync │ v2      │ taskQueue                                                     │
│ kit-firestore-bigquery-export-syncBigQuery      │ v2      │ taskQueue                                                     │

4. Erweiterung deinstallieren

Nachdem Sie das bereitgestellte Funktions-Kit überprüft haben, können Sie die Erweiterung deinstallieren, damit das Verhalten nicht einmal für das Kit und einmal für die Erweiterung dupliziert wird. Sie können alle Erweiterungen über die Firebase-Befehlszeile deinstallieren, unabhängig davon, wie Sie sie installiert haben, wenn Sie das Flag --immediate übergeben:

firebase ext:uninstall <extension-instance-id> --project <project-id> --immediate

Beispiel:

firebase ext:uninstall firestore-bigquery-export --project my-project --immediate

Ausgabe:

i  extensions: uninstalling firestore-bigquery-export...
i  extensions: deleting extension instance resources in project my-project...
✔  extensions: successfully uninstalled firestore-bigquery-export

Erweiterte Migrationen

Sie können Erweiterungen in mehreren Firebase-Projekten haben, die Sie mit einer einzigen Codebasis verwalten möchten. Wenn Sie beispielsweise dieselbe Infrastruktur in einer testing-Umgebung und einer production-Umgebung bereitstellen, die jeweils eine documents-Cloud Firestore-Instanz haben, die Sie nach BigQuery exportieren, haben Sie möglicherweise zwei Instanzen der firestore-bigquery-export-Erweiterung installiert:

  • export-documents-testing
  • export-documents-production

Wenn Sie diese beiden Erweiterungsinstanzen in einer einzigen Codebasis zu zwei Function Kit-Instanzen migriert haben, während Sie mit der Firebase-Befehlszeile gearbeitet haben, und die Bereitstellung mit firebase deploy --project testing und firebase deploy --project production erfolgt ist, würde jede Bereitstellung zwei Instanzen in den Umgebungen testing und production erstellen.

Ersetzen Sie stattdessen die beiden Erweiterungsinstanzen durch eine Funktions-Kit-Instanz von firestore-bigquery-export, die in mehreren Projekten bereitgestellt wird, wobei jedes Projekt eine eigene Konfiguration hat. Das Konfigurationsverzeichnis für die Instanz sollte so aussehen:

  • config-export-documents/
    • .env.testing
    • .env.production

Bei jeder Bereitstellung in testing und production wird eine Instanz Ihres Kits mit der entsprechenden Konfiguration erstellt. Die vorhandenen CLI-Befehle erstellen diese Einrichtung, solange Sie das Flag --project bei jedem Aufruf von ext:migrate oder functions:kits:install übergeben.

Beispiel:

firebase functions:kits:install --package @firebase-function-kits/firestore-bigquery-export --project testing --no-configure --template migration

✔ What would you like to name this kit? firestore-bigquery-export
✔ What would you like to name this instance? export-documents
✔  Wrote function-kits/firestore-bigquery-export/source/package.json
✔  Wrote function-kits/firestore-bigquery-export/source/tsconfig.json
✔  Wrote function-kits/firestore-bigquery-export/source/.gitignore
✔  Wrote function-kits/firestore-bigquery-export/source/src/index.ts
i  functions: Running npm install
✔  Wrote configuration info to firebase.json
✔  functions: Function kit firestore-bigquery-export successfully installed.

# This creates the export-documents instance with an empty .env.testing file
# for the testing project. Now populate it via export:
firebase ext:export --mode functions --instance export-documents-testing \
  --kit-instance export-documents --project testing

# Repeat the export for production into the same kit instance to create
# .env.production from the export-documents-prod instance:
firebase ext:export --mode functions --instance export-documents-prod \
  --kit-instance export-documents --project production

Sie haben jetzt eine einzelne Kit-Instanz konfiguriert, die in Ihren Projekten testing und production mit den jeweiligen Konfigurationen bereitgestellt werden kann. Wenn Sie eine Instanz im Projekt testing erstellen und den Befehl functions:kits:install für dasselbe Paket im Projekt production ausführen, werden Sie gefragt, ob Sie die für testing konfigurierte Instanz wiederverwenden oder eine zweite Instanz installieren möchten.