了解 2023 年 Google I/O 大会上介绍的 Firebase 亮点。了解详情

इस पेज का अनुवाद Cloud Translation API से किया गया है.

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

अपने प्रोजेक्ट में 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 सीएलआई v10.7.1 और इसके बाद के वर्शन में काम करती है.

डेटा स्टोर करने की कई जगहों को मैनेज करना

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

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

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

$ (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 सीएलआई अब आपको डेटा स्टोर करने की आपकी मौजूदा जगह के बाहर तय किए गए फ़ंक्शन को मिटाने का प्रॉम्प्ट नहीं भेजता है:

$ (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 प्रॉपर्टी की मदद से, एक ही रिपॉज़िटरी में कई सोर्स पैकेज आसानी से मैनेज किए जा सकते हैं. आइए ऐसे मामले की जांच करें जहां आपके पास कई सब-पैकेज में फैली फ़ंक्शन डेफ़िनिशन के साथ Firebase प्रोजेक्ट डायरेक्ट्री है:

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

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

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

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

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

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

$ 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');
exports.foo = functions.https.onRequest((request, response) => {
  // ...
});
exports.bar = functions.https.onRequest((request, response) => {
  // ...
});

मुख्य.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');
exports.foo = functions.https.onRequest((request, response) => {
  // ...
});

bar.js

const functions = require('firebase-functions');
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: ज़रूरी है, लेकिन इसे खाली भी छोड़ा जा सकता है

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

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

metric.js


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

अगले चरण

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