एक से ज़्यादा फ़ंक्शन व्यवस्थित करें

2nd gen 1st gen

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

कोडबेस में फ़ंक्शन व्यवस्थित करना

firebase.json में फ़ंक्शन कॉन्फ़िगरेशन ऑब्जेक्ट की codebase प्रॉपर्टी का इस्तेमाल करके, एक ही रिपॉज़िटरी वाले मोनोरेपो सेटअप में, कई रिपॉज़िटरी या सब-पैकेज में फ़ंक्शन के बड़े कलेक्शन को मैनेज किया जा सकता है:

# firebase.json
"functions": {
  "codebase": "my-codebase"
  # NOTE: Codebase must be less than 63 characters and can contain only
  # lowercase letters, numeric characters, underscores, and dashes.
}

codebase प्रॉपर्टी, Firebase CLI के 10.7.1 और उसके बाद के वर्शन में काम करती है.

एक से ज़्यादा डेटा स्टोर करने की जगहें मैनेज करना

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

$  tree .
├── repoA
│   ├── firebase.json
│   └── functions
│       ├── index.js
│       └── package.json
└── repoB
    ├── firebase.json
    └── functions
        ├── index.js
        └── package.json

कोडबेस एनोटेशन के बिना, Firebase CLI आपको डिप्लॉय करने के समय, दूसरी रिपॉज़िटरी में तय किए गए फ़ंक्शन मिटाने के लिए कहा होता:

$ (cd repoA && firebase deploy --only functions)
...
i  functions: preparing functions directory for uploading...
✔  functions: functions folder uploaded successfully
The following functions are found in your project but do not exist in your local source code:
        fn1FromRepoB
        fn2FromRepoB
        ...
? Would you like to proceed with deletion? Selecting no will continue the rest of the deployments. (y/N)

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

# repoA/firebase.json
"functions": {
  "codebase": "repo-a"
}

# repoB/firebase.json
"functions": {
  "codebase": "repo-b"
}

कोडबेस एनोटेशन की मदद से, Firebase CLI अब आपके मौजूदा रिपॉज़िटरी के बाहर तय किए गए फ़ंक्शन मिटाने के लिए, आपको प्रॉम्प्ट नहीं करता:

$ (cd repoA && firebase deploy --only functions)
...
i  functions: preparing functions directory for uploading...
✔  functions: functions folder uploaded successfully
#  Gleefully ignores functions from repoB
i  functions: creating Node.js 16 function fnFromRepoA (us-central1)...
✔  Deploy Complete!

एक से ज़्यादा सोर्स पैकेज (मोनोरेपो) मैनेज करना

codebase प्रॉपर्टी की मदद से, एक ही डेटा स्टोर में कई सोर्स पैकेज को आसानी से मैनेज किया जा सकता है. आइए, एक ऐसे मामले की जांच करें जहां आपके पास फ़ायरबेस प्रोजेक्ट डायरेक्ट्री है, जिसमें फ़ंक्शन की परिभाषाएं कई सब-पैकेज में फैली हुई हैं:

$  tree .
├── firebase.json
├── teamA
│   ├── index.js
│   └── package.json
└── teamB
    ├── index.js
    └── package.json

यह सेटअप, इस्तेमाल के इन उदाहरणों के लिए सही है:

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

इस तरह के monrepo सेटअप के साथ काम करने के लिए, firebase.json में कई फ़ंक्शन कॉन्फ़िगरेशन तय करें:

"functions": [
  {
    "source": "teamA",
    "codebase": "team-a"
  },
  {
    "source": "teamB",
    "codebase": "team-b"
  },
]

इस कॉन्फ़िगरेशन की मदद से, Firebase CLI एक ही डिप्लॉय कमांड में सभी पैकेज के फ़ंक्शन डिप्लॉय करता है:

$ firebase deploy --only functions
i  deploying functions
i  functions: preparing codebase team-a for deployment
i  functions: preparing codebase team-b for deployment
i  functions: creating Node.js 16 function team-a:helloATeam(us-central1)...
i  functions: creating Node.js 16 function team-b:helloBTeam(us-central1)...
...

किसी खास कोडबेस को भी डिप्लॉय किया जा सकता है:

$ firebase deploy --only functions:team-b
i  deploying functions
i  functions: preparing codebase team-b for deployment
i  functions: updating Node.js 16 function team-b:helloBTeam(us-central1)...
...

एक से ज़्यादा फ़ाइलों में फ़ंक्शन लिखना

Cloud Functions का इस्तेमाल शुरू करते समय, अपने पहले कुछ फ़ंक्शन एक ही फ़ाइल में डाले जा सकते हैं:

index.js

const functions = require('firebase-functions/v1');
exports.foo = functions.https.onRequest((request, response) => {
  // ...
});
exports.bar = functions.https.onRequest((request, response) => {
  // ...
});

main.py

from firebase_functions import https_fn

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

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

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

Node.js

foo.js

const functions = require('firebase-functions/v1');
exports.foo = functions.https.onRequest((request, response) => {
  // ...
});

bar.js

const functions = require('firebase-functions/v1');
exports.bar = functions.https.onRequest((request, response) => {
  // ...
});

index.js

const foo = require('./foo');
const bar = require('./bar');
exports.foo = foo.foo;
exports.bar = bar.bar;

Python

foo.py

from firebase_functions import https_fn

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

bar.py

from firebase_functions import https_fn

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

main.py

from fn_impl.foo import *
from fn_impl.bar import *

इस सेटअप में, प्रोजेक्ट डायरेक्ट्री का स्ट्रक्चर इस तरह माना गया है:

my-project
├── firebase.json
└── functions
    ├── fn_impl
    │   ├── __init__.py
    │   ├── foo.py
    │   └── bar.py
    ├── main.py
    └── requirements.txt

fn_impl: इसे कोई भी नाम दिया जा सकता है

__init__.py: यह ज़रूरी है, लेकिन इसे खाली छोड़ा जा सकता है

ग्रुप फ़ंक्शन

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

metrics.js

const functions = require('firebase-functions/v1');
exports.usageStats = functions.https.onRequest((request, response) => {
  // ...
});
exports.nightlyReport = functions.https.onRequest((request, response) => {
  // ...
});

इन फ़ंक्शन को अपनी index.js फ़ाइल में एक्सपोर्ट करते समय, उन्हें किसी ग्रुप में रखा जा सकता है:

index.js

// Export both functions from metrics.js in the "metrics" group:
//  - metrics-usageStats
//  - metrics-nightlyReport
exports.metrics = require('./metrics');

डिप्लॉय होने पर, फ़ंक्शन के नाम के आगे उनके ग्रुप का नाम जोड़ दिया जाएगा. इसलिए, इस उदाहरण में फ़ंक्शन के नाम metrics-usageStats और metrics-nightlyReport होंगे.

फ़ंक्शन डिप्लॉय करते समय, कार्रवाई को सिर्फ़ एक ग्रुप तक सीमित किया जा सकता है:

firebase deploy --only functions:metrics

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

अगले चरण

Cloud Functions के बारे में ज़्यादा जानने के लिए, यह लेख पढ़ें:

• डिपेंडेंसी मैनेज करना.
• फ़ंक्शन के डिप्लॉयमेंट और रनटाइम के विकल्प मैनेज करना.