Firebase एक्सटेंशन को खुद बनाए गए फ़ंक्शन किट में माइग्रेट करना

अगर पब्लिशर ने npm पर डिस्ट्रिब्यूट की जाने वाली कोई आधिकारिक रिप्लेसमेंट किट नहीं बनाई है, तो इस गाइड में उनके एक्सटेंशन को फ़ोर्क करने और उसे लोकल फ़ंक्शन किट के तौर पर सेट अप करने का तरीका बताया गया है.

माइग्रेशन से जुड़ी सीमाओं के बारे में जानें

एक्सटेंशन इंस्टेंस को माइग्रेट करने से पहले, देखें कि आपके सेटअप में इनमें से कोई ऐसी सुविधा तो इस्तेमाल नहीं की जा रही है जिसके लिए कोई दूसरा तरीका अपनाना पड़े या जो फ़ंक्शन किट में अब तक काम नहीं करती:

• कस्टम Docker रिपॉज़िटरी और KMS कुंजियों के लिए, मैन्युअल तरीके से समाधान करना ज़रूरी है Cloud Functions for Firebase कस्टम Docker रिपॉज़िटरी या ग्राहक के मैनेज किए गए एन्क्रिप्शन कुंजी (केएमएस कुंजी) को कॉन्फ़िगर करने के लिए, सिस्टम के पैरामीटर बदलने की सुविधा के साथ काम नहीं करता. अगर आपका एक्सटेंशन इनमें से किसी भी पैरामीटर को कॉन्फ़िगर करता है, तो अक्सर पूछे जाने वाले सवालों में दिए गए समाधान देखें.

शुरू करने से पहले

आपको Firebase सीएलआई सेट अप करना होगा. साथ ही, Firebase प्रोजेक्ट शुरू करना होगा. सीएलआई का इस्तेमाल करते समय, पक्का करें कि firebase-tools वर्शन >= 15.32.0 का इस्तेमाल किया जा रहा हो. इसमें माइग्रेशन और फ़ंक्शन किट के नए कमांड शामिल हैं.

खाते के लिए ज़रूरी अनुमतियां और भूमिकाएं

माइग्रेशन के दौरान, Firebase CLI को क्या बनाना और कॉन्फ़िगर करना है, इसके आधार पर Firebase और Google Cloud से पुष्टि करने के लिए इस्तेमाल किए जा रहे खाते में ये भूमिकाएं होनी चाहिए:

• roles/firebaseextensions.editor
• roles/cloudbuild.builds.editor
• roles/artifactregistry.writer
• roles/run.developer
• roles/iam.serviceAccountUser
• roles/iam.serviceAccountCreator
• roles/cloudfunctions.admin (अगर आपको सार्वजनिक एंडपॉइंट के लिए setIamPermissions करना है)
• roles/secretmanager.admin (अगर सीक्रेट का इस्तेमाल किया जा रहा है)
• roles/serviceusage.serviceUsageAdmin (अगर आपको नए एपीआई चालू करने हैं)

हमारा सुझाव है कि आप उस खाते का इस्तेमाल करें जिसमें पहले से एक्सटेंशन इंस्टॉल किए गए हों और फ़ंक्शन डिप्लॉय किए गए हों. ऐसा इसलिए, क्योंकि इनमें से ज़्यादातर अनुमतियां पहले से ही दी गई होंगी. अगर माइग्रेट किए जा रहे खाते में और भूमिकाएं जोड़नी हैं, तो उन्हें जोड़ने के लिए Google Cloud IAM से जुड़े निर्देशों का पालन करें.

अपने एक्सटेंशन इंस्टेंस को नए वर्शन में अपग्रेड करना

अपने एक्सटेंशन को नए वर्शन पर अपडेट करना ज़रूरी है, ताकि आपके एक्सटेंशन इंस्टेंस और उसके रिप्लेसमेंट किट के बीच का अंतर कम किया जा सके. अगर आपका एक्सटेंशन अपग्रेड नहीं किया गया है, तो हो सकता है कि आपके एक्सटेंशन इंस्टेंस और उसके किट रिप्लेसमेंट के बीच अहम बदलाव हुए हों. ऐसा हो सकता है कि एक्सपोर्ट किया गया कॉन्फ़िगरेशन, किट की उम्मीद के मुताबिक न हो. इसकी वजह यह है कि अलग-अलग वर्शन में पैरामीटर बदल जाते हैं.

एक्सटेंशन को अपडेट करने के लिए, इनमें से कोई एक विकल्प इस्तेमाल करें. यह इस बात पर निर्भर करता है कि एक्सटेंशन कहां इंस्टॉल किया गया था:

• Firebase कंसोल से
• Firebase सीएलआई से, इनका इस्तेमाल करके:
  • firebase ext:update <extension-instance-id> --project <project-id> firebase deploy --only extensions --project <project-id>

इस चरण को छोड़ने पर, सीएलआई आपसे कॉन्फ़िगरेशन एक्सपोर्ट करते समय अपग्रेड करने के लिए कहेगा. ऐसा तब होगा, जब आपका एक्सटेंशन नए वर्शन पर नहीं होगा.

एक्सटेंशन को लोकल फ़ंक्शन किट में फ़ोर्क करना

किसी एक्सटेंशन को लोकल फ़ंक्शन किट में बदलने से पहले, पक्का करें कि एक्सटेंशन का सोर्स कोड आपके Firebase प्रोजेक्ट में मौजूद हो. इसके लिए, GitHub से एक्सटेंशन रिपॉज़िटरी का क्लोन बनाएं. इसके बाद, अपने Firebase प्रोजेक्ट रूट में एक डायरेक्ट्री बनाएं. इसके बाद, एक्सटेंशन के functions/ फ़ोल्डर और extension.yaml को इसमें कॉपी करें:

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

अपने एक्सटेंशन के सोर्स कोड को 2nd gen फ़ंक्शन पर माइग्रेट करने के लिए, पब्लिशर के लिए माइग्रेशन गाइड में दिए गए पहले से आठवें चरण तक का तरीका अपनाएं. इसके बाद, यहां दिया गया तरीका अपनाएं.

अपनी लोकल किट में, एक्सपोर्ट किए गए फ़ंक्शन के क्षेत्र और ऐडवांस पैरामीटर के लिए सहायता जोड़ें

लोकल फ़ंक्शन किट में, Firebase सीएलआई, पैकेज को सेट अप करने और माइग्रेट किए गए सिस्टम पैरामीटर का इस्तेमाल करने के लिए कॉन्फ़िगर करने के लिए, index.ts फ़ाइल जनरेट नहीं करता है. अपने एक्सटेंशन के लिए कॉन्फ़िगर किए गए फ़ंक्शन रीजन और ऐडवांस पैरामीटर इस्तेमाल करने के लिए, अपनी index.ts फ़ाइल सेट अप करें. इससे firebase ext:export --mode functions से एक्सपोर्ट किए गए फ़ॉर्मैट को एनवायरमेंट वैरिएबल फ़ाइल में पढ़ा जा सकेगा.

खास तौर पर, टॉप-लेवल की उस index.ts फ़ाइल में जो आपके फ़ंक्शन एक्सपोर्ट करती है, FUNCTION_DEFAULT_REGION के लिए एक पैरामीटर तय करें और setGlobalOptions को EXT_MIGRATED_SYSTEM_<GLOBAL_OPTION> फ़ॉर्म वाले एनवायरमेंट वैरिएबल के साथ कॉल करें. यह CLI के इस्तेमाल किए गए index-kit-migration.ts टेंप्लेट जैसा ही है:

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

माइग्रेशन से पहले, अपने किट की जांच करें

अब आपके पास एक लोकल फ़ंक्शन किट है. इसे डिप्लॉय करने पर, यह आपके एक्सटेंशन के नए इंस्टॉलेशन की तरह काम करती है. अगला चरण, प्रोडक्शन एक्सटेंशन के इंस्टेंस को माइग्रेट करने से पहले, पुष्टि करना और इस दौरान हुई किसी भी समस्या को ठीक करना है.

सबसे पहले, अपने फ़ोर्क को लोकल किट के तौर पर जोड़ें, उसे कॉन्फ़िगर करें, और उसे टेस्ट प्रोजेक्ट में डिप्लॉय करें. लोकल फ़ंक्शन किट, आपके Firebase प्रोजेक्ट में होनी चाहिए. इसलिए, अगर क्लोन की गई एक्सटेंशन रिपॉज़िटरी आपके Firebase प्रोजेक्ट से बाहर है, तो उसे प्रोजेक्ट डायरेक्ट्री में ले जाएं. इसके बाद, इसे लोकल किट के तौर पर इंस्टॉल करने के लिए, किट इंस्टॉल करने की यह कमांड चलाएं:

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

इस कमांड की मदद से, पहले टेस्ट इंस्टेंस के लिए किट आईडी, इंस्टेंस आईडी, और कॉन्फ़िगरेशन चुना जा सकता है. इसके बाद, यह आपकी firebase.json फ़ाइल में बदलाव करके, आपकी फ़ोर्क की गई डायरेक्ट्री की ओर इशारा करने वाली लोकल किट को रजिस्टर करता है. साथ ही, हर इंस्टेंस के कॉन्फ़िगरेशन को function-kits/<kit-id>/config-<instance-id> पर मौजूद .env फ़ाइल में सेव करता है.

अपनी लोकल किट को टेस्ट प्रोजेक्ट में डिप्लॉय करें. साथ ही, उसके व्यवहार की जांच करने के लिए ज़रूरी संसाधन भी डिप्लॉय करें. अगर आपने एक्सटेंशन की जांच करने के लिए, पहले से ही कोई टेस्ट प्रोजेक्ट सेट अप किया हुआ है, तो यह निर्देश चलाएं:

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

उदाहरण: स्ट्रीम Cloud Firestore से BigQuery (firestore-bigquery-export)

Cloud Firestore से BigQuery तक सिंक होने की प्रोसेस के एंड-टू-एंड होने की पुष्टि करें:

1. Firebase कंसोल के Cloud Firestore पेज पर, वह कलेक्शन बनाएं जिसे आपने COLLECTION_PATH (users) के तौर पर सेट किया है. ऐसा तब करें, जब वह कलेक्शन पहले से मौजूद न हो.
2. bigquery-mirror-test नाम का एक दस्तावेज़ बनाएं. इसमें कोई भी फ़ील्ड और वैल्यू शामिल करें.

3. Google Cloud कंसोल के BigQuery पेज में, बदलाव के रॉ डेटा वाली टेबल के लिए क्वेरी करें. इसमें दस्तावेज़ बनाने की जानकारी देने वाली एक लाइन होनी चाहिए:

   SELECT * FROM `PROJECT_ID.analytics.users_raw_changelog`
   

4. लेटेस्ट व्यू के लिए क्वेरी करें. इससे मौजूद दस्तावेज़ (bigquery-mirror-test) के लिए, बदलाव से जुड़ा सबसे नया इवेंट दिखेगा:

   SELECT * FROM `PROJECT_ID.analytics.users_raw_latest`
   

5. Cloud Firestore में मौजूद bigquery-mirror-test दस्तावेज़ को मिटाओ. यह बदलाव, हाल ही के बदलावों की सूची से हट जाता है. साथ ही, DELETE इवेंट को बदलाव के लॉग वाली टेबल में जोड़ दिया जाता है.

   किसी एक दस्तावेज़ का पूरा इतिहास देखने के लिए, इन तरीकों का इस्तेमाल किया जा सकता है:

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

एक्सटेंशन की टेस्टिंग से जुड़े अंतर:

• ट्रिगर को kit-<kit-instance-id>-fsexportbigquery के तौर पर डिप्लॉय किया जाता है, न कि ext-<instanceId>-fsexportbigquery के तौर पर. Cloud Functionsडैशबोर्ड और लॉग में उस नाम को ढूंढें.
• आपका कोड, Firebase Local Emulator Suite में स्टैंडर्ड फ़ंक्शन के तौर पर काम करता है. .env.local की मदद से, एम्युलेटर में इस्तेमाल करने के लिए पैरामीटर वैल्यू सेट की जा सकती हैं. firebase-functions-testएसडीके का इस्तेमाल करके, अपने कोड की यूनिट टेस्टिंग भी की जा सकती है. इसके बारे में Cloud Functions की यूनिट टेस्टिंग में बताया गया है.
• अब एक्सटेंशन रनटाइम के ज़रिए डिवाइस सेट अप नहीं किया जाता. अगर डिप्लॉय करने के बाद, बदलाव के बारे में जानकारी देने वाली टेबल मौजूद नहीं है, तो सेटअप टास्क को मैन्युअल तरीके से फिर से चलाएं: firebase functions:lifecycle:run afterFirstDeploy <kit-instance-id>. यह टास्क आइडेमपोटेंट है. इसलिए, इसे फिर से चलाने पर डेटासेट, टेबल, और व्यू को फिर से मिलाया जाता है.
• पैरामीटर की वैल्यू, इंस्टॉलेशन फ़ॉर्म के बजाय .env से मिलती हैं. इसलिए, .env पूरा होने के बाद, firebase deploy को फिर से चलाने पर कोई इंटरैक्शन नहीं होता.

(ज़रूरी नहीं) टेस्टिंग के दौरान बनाए गए डेटा को मिटाना

अगर आपको टेस्टिंग के बाद इस टेस्ट इंस्टेंस को हटाना है, तो इसे अनइंस्टॉल करें:

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

इससे किट को डिप्लॉय करके बनाए गए सभी क्लाउड संसाधन मिट जाते हैं. साथ ही, इसके इंस्टेंस का कॉन्फ़िगरेशन भी हट जाता है. अगर आपके पास किट का सिर्फ़ एक इंस्टेंस है, तो इससे firebase.json से किट की एंट्री भी हट जाती है. इससे आपकी लोकल सोर्स कोड डायरेक्ट्री नहीं मिटती. प्रोडक्शन माइग्रेशन के लिए किट इंस्टॉल करते समय, किट आईडी को फिर से चुना जा सकता है.

एक्सटेंशन से लोकल किट पर माइग्रेट करना

लोकल किट की जांच हो जाने के बाद, लाइव डिप्लॉय किए गए एक्सटेंशन इंस्टेंस को माइग्रेट किया जा सकता है.

1. बदले गए फ़ंक्शन किट इंस्टेंस को इंस्टॉल करना

अपनी लोकल फ़ंक्शन किट इंस्टॉल करें. इसके लिए, --no-configure पास करें, ताकि मैन्युअल कॉन्फ़िगरेशन को स्किप किया जा सके. इससे अगला चरण, आपके मौजूदा एक्सटेंशन कॉन्फ़िगरेशन को सीधे इस किट इंस्टेंस में एक्सपोर्ट कर सकता है:

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

2. फ़ंक्शन किट के इंस्टेंस को एक्सटेंशन की तरह कॉन्फ़िगर करें

आपको इस किट इंस्टेंस को उस एक्सटेंशन के कॉन्फ़िगरेशन के हिसाब से पसंद के मुताबिक बनाना होगा जिसे यह बदल रहा है. एक्सटेंशन इंस्टेंस के कॉन्फ़िगरेशन को .env फ़ाइल में एक्सपोर्ट किया जा सकता है. इस फ़ाइल में, सभी Cloud Functions के लिए पैरामीटर, एनवायरमेंट वैरिएबल, और सीक्रेट रेफ़रंस कॉन्फ़िगरेशन डेटा सेव होता है. इसमें किट भी शामिल हैं. इसे सीधे अपने किट की कॉन्फ़िगरेशन फ़ाइल में एक्सपोर्ट करने के लिए, यह कमांड चलाएं:

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

इस चरण के आखिर में, इस इंस्टेंस के लिए कॉन्फ़िगरेशन की जानकारी, आपके इंस्टेंस कॉन्फ़िगरेशन डायरेक्ट्री में मौजूद प्रोजेक्ट के हिसाब से .env फ़ाइल में सेव हो जाती है. जैसे: function-kits/<kit-name>/config-<instance-id>/.env.<project-id>

3. किट को बदलें और उसकी पुष्टि करें

किट इंस्टॉल हो जाने और फ़ंक्शन के सेट के तौर पर उपलब्ध होने के बाद, किट को बदला जा सकता है. फ़ंक्शन किट, स्टैंडर्ड फ़ंक्शन की तरह काम करती हैं. इनमें हर किट इंस्टेंस, आपके फ़ंक्शन को व्यवस्थित करने के लिए एक अलग कोडबेस के तौर पर काम करता है. आपके पास अपने सभी फ़ंक्शन या सिर्फ़ किसी खास किट इंस्टेंस को डिप्लॉय करने का विकल्प होता है. किसी एक्सटेंशन के एक इंस्टेंस को माइग्रेट करते समय, सिर्फ़ उस किट इंस्टेंस को डिप्लॉय करें.

अगर आपकी किट में ऐसे नए पैरामीटर इस्तेमाल किए जाते हैं जो माइग्रेट किए गए एक्सटेंशन इंस्टेंस में मौजूद नहीं थे, तो Firebase CLI, डिप्लॉयमेंट प्रोसेस की शुरुआत में आपसे उनके बारे में पूछता है. अप-टू-डेट firestore-bigquery-export एक्सटेंशन के इस उदाहरण में, ऐसा नहीं होना चाहिए. हालांकि, कई किट, किट के इस्तेमाल किए गए किसी भी इवेंट ट्रिगर सोर्स के लिए, नए पैरामीटर का अनुरोध करती हैं. इस माइग्रेशन के तहत, अपडेट की गई किट, 2nd gen फ़ंक्शन का इस्तेमाल करती हैं. इससे पहले, एक्सटेंशन 1st gen फ़ंक्शन का इस्तेमाल करते थे. दूसरी जनरेशन में, फ़ंक्शन को इवेंट सोर्स के पास रखा जाता है और उन्हें अतिरिक्त पैरामीटर के तौर पर जोड़ा जाता है. अगर आने वाले समय में नए पैरामीटर जोड़े जाते हैं, तो सीएलआई अगले डिप्लॉयमेंट पर आपको इसकी सूचना देगा.

काम करने का उदाहरण:

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

आउटपुट:

=== 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!

इस बात की पुष्टि करने के लिए कि किट के firebase deploy में कोई गड़बड़ी नहीं हुई है, डिप्लॉयमेंट लॉग देखें. इससे पता चलेगा कि कोई लाइफ़साइकल हुक ट्रिगर हुआ है या नहीं. Stream Cloud Firestore to BigQuery जैसे लोकप्रिय एक्सटेंशन, लाइफ़साइकल हुक का इस्तेमाल करते हैं. यहां दिए गए उदाहरण में बताया गया है कि ट्रिगर होने पर लाइफ़साइकल हुक कैसा दिखता है:

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

इन लॉग मैसेज से, यहां दी गई बातों की पुष्टि होती है:

• लाइफ़साइकल हुक मिला और उसे लागू किया गया.
• लाइफ़साइकल हुक से जुड़ी टास्क की कतार में कोई टास्क जोड़ा गया है.
• Cloud Logging का लिंक दिया गया है, ताकि यह पुष्टि की जा सके कि टास्क बिना किसी गड़बड़ी के पूरा हो गया है.

Google Cloud कंसोल में लॉग के लिंक पर जाकर, यह पुष्टि करें कि लॉग में कोई गड़बड़ी नहीं है और आपकी टास्क क्यू इवेंट को प्रोसेस कर लिया गया है. अगर लाइफ़साइकल इवेंट सही तरीके से ट्रिगर नहीं हुआ है, तो इसे फिर से ट्रिगर किया जा सकता है. इसके लिए, यह कमांड चलाएं:

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

अगर पहली बार फ़ंक्शन किट इंस्टेंस डिप्लॉय किया जा रहा है, तो यह कमांड चलाएं:

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

अगर आपको पुष्टि करने के दौरान किसी भी समय इस माइग्रेशन को रोकना है या पहले जैसा करना है, तो एक्सटेंशन अनइंस्टॉल करना में दिए गए निर्देशों का इस्तेमाल करके, किट को अनइंस्टॉल किया जा सकता है.

4. एक्सटेंशन को अनइंस्टॉल करना

फ़ंक्शन किट को डिप्लॉय करने के बाद, उसकी पुष्टि करें. इसके बाद, एक्सटेंशन को अनइंस्टॉल करें, ताकि किट और एक्सटेंशन, दोनों के लिए एक ही फ़ंक्शन दो बार न चले. --immediate फ़्लैग पास करके, Firebase CLI से सभी एक्सटेंशन अनइंस्टॉल किए जा सकते हैं. भले ही, आपने उन्हें किसी भी तरीके से इंस्टॉल किया हो:

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

काम करने का उदाहरण:

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

आउटपुट:

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

ऐडवांस माइग्रेशन

आपके पास कई Firebase प्रोजेक्ट में एक्सटेंशन हो सकते हैं. इन्हें आपको एक ही कोडबेस से मैनेज करना है. उदाहरण के लिए, अगर आपने एक ही इन्फ़्रास्ट्रक्चर को testing एनवायरमेंट और production एनवायरमेंट, दोनों में डिप्लॉय किया है, तो हो सकता है कि आपके पास firestore-bigquery-export एक्सटेंशन के दो इंस्टेंस इंस्टॉल हों. ऐसा इसलिए, क्योंकि हर एनवायरमेंट में documents Cloud Firestore इंस्टेंस होता है, जिसे BigQuery में एक्सपोर्ट किया जाता है:

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

अगर आपने Firebase सीएलआई के साथ काम करते समय, इन दो एक्सटेंशन इंस्टेंस को एक ही कोड बेस में दो फ़ंक्शन किट इंस्टेंस में माइग्रेट किया है और firebase deploy --project testing और firebase deploy --project production का इस्तेमाल करके डिप्लॉय किया है, तो हर डिप्लॉयमेंट से testing और production, दोनों एनवायरमेंट में दो इंस्टेंस बन जाएंगे.

इसके बजाय, एक्सटेंशन के दो इंस्टेंस को firestore-bigquery-export के एक फ़ंक्शन किट इंस्टेंस से बदलें. इसे कई प्रोजेक्ट में डिप्लॉय किया जाता है. हर प्रोजेक्ट का अपना कॉन्फ़िगरेशन होता है. आपके इंस्टेंस के लिए कॉन्फ़िगरेशन डायरेक्ट्री, कुछ ऐसी दिखनी चाहिए:

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

testing और production में हर डिप्लॉयमेंट, आपकी किट का एक इंस्टेंस बनाता है. इसमें किट का कॉन्फ़िगरेशन भी शामिल होता है. मौजूदा सीएलआई कमांड, इस सेटअप को तब तक बनाती हैं, जब तक ext:migrate या functions:kits:install के हर इनवोकेशन में --project फ़्लैग पास किया जाता है.

काम करने का उदाहरण:

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

अब आपके पास एक किट इंस्टेंस है, जिसे testing और production प्रोजेक्ट में उनके कॉन्फ़िगरेशन के साथ डिप्लॉय करने के लिए कॉन्फ़िगर किया गया है. अगर आपने testing प्रोजेक्ट में कोई इंस्टेंस बनाया है और production प्रोजेक्ट में उसी पैकेज के लिए functions:kits:install कमांड चलाई है, तो आपको testing के लिए कॉन्फ़िगर किए गए इंस्टेंस को फिर से इस्तेमाल करने या दूसरा इंस्टेंस इंस्टॉल करने का विकल्प दिखेगा.