एनवायरमेंट को कॉन्फ़िगर करें


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

आप तीन विकल्पों में से चुन सकते हैं:

  • पैरामीटरयुक्त कॉन्फ़िगरेशन (अधिकांश परिदृश्यों के लिए अनुशंसित)। यह उन मापदंडों के साथ दृढ़ता से टाइप किया गया पर्यावरण कॉन्फ़िगरेशन प्रदान करता है जो तैनाती के समय मान्य होते हैं, जो त्रुटियों को रोकता है और डिबगिंग को सरल बनाता है।
  • पर्यावरण चर का फ़ाइल-आधारित कॉन्फ़िगरेशन। इस दृष्टिकोण के साथ, आप पर्यावरण चर लोड करने के लिए मैन्युअल रूप से एक dotenv फ़ाइल बनाते हैं।
  • फायरबेस सीएलआई और functions.config (केवल क्लाउड फ़ंक्शंस (पहली पीढ़ी)) के साथ रनटाइम पर्यावरण कॉन्फ़िगरेशन

अधिकांश उपयोग के मामलों के लिए, पैरामीटरयुक्त कॉन्फ़िगरेशन की अनुशंसा की जाती है। यह दृष्टिकोण कॉन्फ़िगरेशन मानों को रनटाइम और परिनियोजन समय दोनों पर उपलब्ध कराता है, और परिनियोजन तब तक अवरुद्ध रहता है जब तक कि सभी मापदंडों का वैध मान न हो। इसके विपरीत, तैनाती के समय पर्यावरण चर के साथ कॉन्फ़िगरेशन उपलब्ध नहीं है।

पैरामीटरयुक्त विन्यास

फायरबेस के लिए क्लाउड फ़ंक्शंस आपके कोडबेस के अंदर घोषणात्मक रूप से कॉन्फ़िगरेशन पैरामीटर को परिभाषित करने के लिए एक इंटरफ़ेस प्रदान करता है। इन मापदंडों का मान फ़ंक्शन परिनियोजन के दौरान, परिनियोजन और रनटाइम विकल्प सेट करते समय और निष्पादन के दौरान उपलब्ध होता है। इसका मतलब यह है कि सीएलआई तब तक तैनाती को अवरुद्ध कर देगा जब तक कि सभी मापदंडों का वैध मान न हो।

अपने कोड में पैरामीटर परिभाषित करने के लिए, इस मॉडल का पालन करें:

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.`);
  }
);

पैरामीटरयुक्त कॉन्फ़िगरेशन चर के साथ एक फ़ंक्शन को तैनात करते समय, फायरबेस सीएलआई पहले स्थानीय .env फ़ाइलों से उनके मान लोड करने का प्रयास करता है। यदि वे उन फ़ाइलों में मौजूद नहीं हैं और कोई default सेट नहीं है, तो सीएलआई तैनाती के दौरान मानों के लिए संकेत देगा, और फिर स्वचालित रूप से उनके मानों को आपके functions/ निर्देशिका में .env .env.<project_ID> नामक .env फ़ाइल में सहेज लेगा:

$ firebase deploy
i  functions: preparing codebase default for deployment
? Enter a string value for ENVIRONMENT: prod
i  functions: Writing new parameter values to disk: .env.projectId
…
$ firebase deploy
i  functions: Loaded environment variables from .env.projectId

आपके विकास वर्कफ़्लो के आधार पर, जेनरेट की गई .env.<project_ID> फ़ाइल को संस्करण नियंत्रण में जोड़ना उपयोगी हो सकता है।

सीएलआई व्यवहार कॉन्फ़िगर करें

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

const { defineString } = require('firebase-functions/params');

const welcomeMessage = defineString('WELCOME_MESSAGE', {default: 'Hello World',
description: 'The greeting that is returned to the caller of this function'});

const onlyPhoneNumbers = defineString('PHONE_NUMBER', {input: {text:
{validationRegex: /\d{3}-\d{3}-\d{4}/, validationErrorMessage: "Please enter
a phone number in the format XXX-YYY-ZZZZ"}}});

const selectedOption = defineString('PARITY', {input: {select: {options:
[{value: "odd"}, {value: "even"}]}}})

const storageBucket = defineString('BUCKET', {input: {resource: {type:
"storage.googleapis.com/Bucket"}}, description: "This will automatically
populate the selector field with the deploying Cloud Project’s
storage buckets"})

पैरामीटर प्रकार

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

  • गुप्त
  • डोरी
  • बूलियन
  • पूर्णांक
  • तैरना

पैरामीटर मान और अभिव्यक्तियाँ

फ़ायरबेस आपके मापदंडों का मूल्यांकन तैनाती के समय और आपके फ़ंक्शन के निष्पादित होने के दौरान करता है। इन दोहरे वातावरणों के कारण, पैरामीटर मानों की तुलना करते समय और अपने कार्यों के लिए रनटाइम विकल्प सेट करने के लिए उनका उपयोग करते समय कुछ अतिरिक्त सावधानी बरतनी चाहिए।

किसी पैरामीटर को रनटाइम विकल्प के रूप में अपने फ़ंक्शन में पास करने के लिए, इसे सीधे पास करें:

const functions = require('firebase-functions');
const { defineInt} = require('firebase-functions/params');
const minInstancesConfig = defineInt('HELLO\_WORLD\_MININSTANCES');

export const helloWorld = functions.runWith({ minInstances: minInstancesConfig}).https.onRequest(
  (req, res) => {
    //…

इसके अतिरिक्त, यदि आपको यह जानने के लिए किसी पैरामीटर के विरुद्ध तुलना करने की आवश्यकता है कि कौन सा विकल्प चुनना है, तो आपको मूल्य की जांच करने के बजाय अंतर्निहित तुलनित्र का उपयोग करने की आवश्यकता होगी:

const functions = require('firebase-functions');
const { defineBool } = require('firebase-functions/params');
const environment = params.defineString(‘ENVIRONMENT’, {default: ‘dev’});

// use built-in comparators
const minInstancesConfig =environment.equals('PRODUCTION').thenElse(10, 1);
export const helloWorld = functions.runWith({ minInstances: minInstancesConfig}).https.onRequest(
  (req, res) => {
    //…

पैरामीटर और पैरामीटर अभिव्यक्तियाँ जो केवल रनटाइम पर उपयोग की जाती हैं, उन्हें उनके value फ़ंक्शन के साथ एक्सेस किया जा सकता है:

const functions = require('firebase-functions');
const { defineString } = require('firebase-functions/params');
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.https.onRequest(
 (req, res) => {
    res.send(`${welcomeMessage.value()}! I am a function.`);
  }
);

अंतर्निहित पैरामीटर

क्लाउड फ़ंक्शंस SDK तीन पूर्व-परिभाषित पैरामीटर प्रदान करता है, जो firebase-functions/params सबपैकेज से उपलब्ध हैं:

  • projectID - क्लाउड प्रोजेक्ट जिसमें फ़ंक्शन चल रहा है।
  • databaseURL - फ़ंक्शन से जुड़े रीयलटाइम डेटाबेस इंस्टेंस का यूआरएल (यदि फायरबेस प्रोजेक्ट पर सक्षम है)।
  • storageBucket - फ़ंक्शन से जुड़ी क्लाउड स्टोरेज बकेट (यदि फायरबेस प्रोजेक्ट पर सक्षम है)।

ये सभी प्रकार से उपयोगकर्ता-परिभाषित स्ट्रिंग पैरामीटर की तरह कार्य करते हैं, सिवाय इसके कि, चूंकि उनके मान हमेशा फ़ायरबेस सीएलआई को ज्ञात होते हैं, इसलिए उनके मानों को कभी भी परिनियोजन पर संकेत नहीं दिया जाएगा और न ही .env फ़ाइलों में सहेजा जाएगा।

गुप्त पैरामीटर

defineSecret() का उपयोग करके परिभाषित Secret प्रकार के पैरामीटर, स्ट्रिंग पैरामीटर का प्रतिनिधित्व करते हैं जिनका मान क्लाउड सीक्रेट मैनेजर में संग्रहीत होता है। स्थानीय .env फ़ाइल के विरुद्ध जाँच करने और गुम होने पर फ़ाइल में एक नया मान लिखने के बजाय, गुप्त पैरामीटर क्लाउड सीक्रेट मैनेजर में अस्तित्व के विरुद्ध जाँच करते हैं, और तैनाती के दौरान एक नए रहस्य के मूल्य के लिए अंतःक्रियात्मक रूप से संकेत देते हैं।

इस तरह से परिभाषित गुप्त पैरामीटर व्यक्तिगत कार्यों से बंधे होने चाहिए जिनकी उन तक पहुंच होनी चाहिए:

const functions = require('firebase-functions');
const { defineSecret } = require('firebase-functions/params');
const discordApiKey = defineSecret('DISCORD_API_KEY');

export const postToDiscord = functions.runWith({ secrets: [discordApiKey] }).https.onRequest(
  (req, res) => {
    const apiKey = discordApiKey.value();
    //…

चूँकि फ़ंक्शन के निष्पादन तक रहस्यों के मान छिपे रहते हैं, आप अपने फ़ंक्शन को कॉन्फ़िगर करते समय उनका उपयोग नहीं कर सकते।

पर्यावरण चर

फायरबेस के लिए क्लाउड फ़ंक्शंस आपके एप्लिकेशन रनटाइम में .env फ़ाइल में निर्दिष्ट पर्यावरण चर लोड करने के लिए dotenv फ़ाइल प्रारूप का समर्थन करता है। एक बार तैनात होने के बाद, पर्यावरण चर को process.env इंटरफ़ेस के माध्यम से पढ़ा जा सकता है।

अपने वातावरण को इस तरह से कॉन्फ़िगर करने के लिए, अपने प्रोजेक्ट में एक .env फ़ाइल बनाएं, वांछित चर जोड़ें और तैनात करें:

  1. अपने functions/ निर्देशिका में एक .env फ़ाइल बनाएं:

    # Directory layout:
    #   my-project/
    #     firebase.json
    #     functions/
    #       .env
    #       package.json
    #       index.js
    
  2. संपादन के लिए .env फ़ाइल खोलें, और वांछित कुंजियाँ जोड़ें। उदाहरण के लिए:

    PLANET=Earth
    AUDIENCE=Humans
    
  3. फ़ंक्शंस तैनात करें और सत्यापित करें कि पर्यावरण चर लोड किए गए थे:

    firebase deploy --only functions
    # ...
    # i functions: Loaded environment variables from .env.
    # ...
    

एक बार जब आपके कस्टम पर्यावरण चर तैनात हो जाते हैं, तो आपका फ़ंक्शन कोड उन्हें process.env सिंटैक्स के साथ एक्सेस कर सकता है:

// Responds with "Hello Earth and Humans"
exports.hello = functions.https.onRequest((request, response) => {
  response.send(`Hello ${process.env.PLANET} and ${process.env.AUDIENCE}`);
});

पर्यावरण चर के कई सेट तैनात करना

यदि आपको अपने फायरबेस प्रोजेक्ट्स (जैसे स्टेजिंग बनाम प्रोडक्शन) के लिए पर्यावरण चर के वैकल्पिक सेट की आवश्यकता है, तो एक .env. <project or alias > फ़ाइल करें और वहां अपने प्रोजेक्ट-विशिष्ट पर्यावरण चर लिखें। .env और प्रोजेक्ट-विशिष्ट .env फ़ाइलों (यदि वे मौजूद हैं) से पर्यावरण चर सभी तैनात कार्यों में शामिल किए जाएंगे।

उदाहरण के लिए, किसी प्रोजेक्ट में विकास और उत्पादन के लिए थोड़े भिन्न मान वाली ये तीन फ़ाइलें शामिल हो सकती हैं:

.env .env.dev .env.prod
ग्रह=पृथ्वी

दर्शक=मनुष्य

दर्शक=देव मानव दर्शक=उत्पादित मनुष्य

उन अलग-अलग फ़ाइलों में मानों को देखते हुए, आपके कार्यों के साथ तैनात पर्यावरण चर का सेट आपके लक्ष्य प्रोजेक्ट के आधार पर अलग-अलग होगा:

$ firebase use dev
$ firebase deploy --only functions
i functions: Loaded environment variables from .env, .env.dev.
# Deploys functions with following user-defined environment variables:
#   PLANET=Earth
#   AUDIENCE=Dev Humans

$ firebase use prod
$ firebase deploy --only functions
i functions: Loaded environment variables from .env, .env.prod.
# Deploys functions with following user-defined environment variables:
#   PLANET=Earth
#   AUDIENCE=Prod Humans

आरक्षित पर्यावरण चर

कुछ पर्यावरण चर कुंजियाँ आंतरिक उपयोग के लिए आरक्षित हैं। अपनी .env फ़ाइलों में इनमें से किसी भी कुंजी का उपयोग न करें:

  • X_GOOGLE_ से प्रारंभ होने वाली सभी कुंजियाँ
  • EXT_ से प्रारंभ होने वाली सभी कुंजियाँ
  • FIREBASE_ से शुरू होने वाली सभी कुंजियाँ
  • निम्नलिखित सूची में से कोई भी कुंजी:
  • CLOUD_RUNTIME_CONFIG
  • प्रवेश बिंदु
  • जीसीपी_प्रोजेक्ट
  • GCLOUD_प्रोजेक्ट
  • GOOGLE_CLOUD_प्रोजेक्ट
  • FUNCTION_TRIGGER_TYPE
  • FUNCTION_NAME
  • FUNCTION_MEMORY_MB
  • FUNCTION_TIMEOUT_SEC
  • फ़ंक्शन_पहचान
  • फ़ंक्शन_क्षेत्र
  • FUNCTION_TARGET
  • FUNCTION_SIGNATURE_TYPE
  • K_सेवा
  • K_संशोधन
  • पत्तन
  • K_कॉन्फ़िगरेशन

संवेदनशील कॉन्फ़िगरेशन जानकारी संग्रहीत और एक्सेस करें

.env फ़ाइलों में संग्रहीत पर्यावरण चर का उपयोग फ़ंक्शन कॉन्फ़िगरेशन के लिए किया जा सकता है, लेकिन आपको उन्हें डेटाबेस क्रेडेंशियल या एपीआई कुंजी जैसी संवेदनशील जानकारी संग्रहीत करने का एक सुरक्षित तरीका नहीं मानना ​​चाहिए। यह विशेष रूप से महत्वपूर्ण है यदि आप अपनी .env फ़ाइलों को स्रोत नियंत्रण में जाँचते हैं।

संवेदनशील कॉन्फ़िगरेशन जानकारी संग्रहीत करने में आपकी सहायता के लिए, फायरबेस के लिए क्लाउड फ़ंक्शंस Google क्लाउड सीक्रेट मैनेजर के साथ एकीकृत होता है। यह एन्क्रिप्टेड सेवा कॉन्फ़िगरेशन मानों को सुरक्षित रूप से संग्रहीत करती है, जबकि आवश्यकता पड़ने पर आपके कार्यों तक आसान पहुंच की अनुमति भी देती है।

एक रहस्य बनाएं और उसका उपयोग करें

एक रहस्य बनाने के लिए, फायरबेस सीएलआई का उपयोग करें।

कोई रहस्य बनाने और उपयोग करने के लिए:

  1. अपनी स्थानीय प्रोजेक्ट निर्देशिका के रूट से, निम्न कमांड चलाएँ:

    firebase functions:secrets:set SECRET_NAME

  2. SECRET_NAME के ​​लिए एक मान दर्ज करें.

    सीएलआई एक सफलता संदेश प्रतिध्वनित करता है और चेतावनी देता है कि परिवर्तन को प्रभावी बनाने के लिए आपको कार्यों को तैनात करना होगा।

  3. तैनात करने से पहले, सुनिश्चित करें कि आपका फ़ंक्शन कोड फ़ंक्शन को runWith पैरामीटर का उपयोग करके रहस्य तक पहुंचने की अनुमति देता है:

    exports.processPayment = functions
      // Make the secret available to this function
      .runWith({ secrets: ["SECRET_NAME"] })
      .onCall((data, context) => {
        const myBillingService = initializeBillingService(
          // reference the secret value
          process.env.SECRET_NAME
        );
        // Process the payment
      });
  4. क्लाउड फ़ंक्शंस तैनात करें:

    firebase deploy --only functions

अब आप इसे किसी भी अन्य पर्यावरण चर की तरह एक्सेस कर पाएंगे। इसके विपरीत, यदि कोई अन्य फ़ंक्शन जो runWith में रहस्य निर्दिष्ट नहीं करता है, रहस्य तक पहुंचने का प्रयास करता है, तो उसे एक अपरिभाषित मान प्राप्त होता है:

  exports.anotherEndpoint = functions.https.onRequest((request, response) => {
    response.send(`The secret API key is ${process.env.SECRET_NAME}`);
    // responds with "The secret API key is undefined" because the `runWith` parameter is missing
  });

एक बार जब आपका फ़ंक्शन तैनात हो जाता है, तो उसे गुप्त मूल्य तक पहुंच प्राप्त होगी। केवल वे फ़ंक्शन जो विशेष रूप से अपने runWith पैरामीटर में एक रहस्य शामिल करते हैं, उन्हें पर्यावरण चर के रूप में उस रहस्य तक पहुंच प्राप्त होगी। इससे आपको यह सुनिश्चित करने में मदद मिलती है कि गुप्त मूल्य केवल वहीं उपलब्ध हैं जहां उनकी आवश्यकता है, जिससे गलती से किसी रहस्य के लीक होने का जोखिम कम हो जाता है।

रहस्यों का प्रबंध करना

अपने रहस्यों को प्रबंधित करने के लिए फायरबेस सीएलआई का उपयोग करें। इस तरह से रहस्यों को प्रबंधित करते समय, ध्यान रखें कि कुछ सीएलआई परिवर्तनों के लिए आपको संबंधित कार्यों को संशोधित करने और/या पुन: तैनात करने की आवश्यकता होती है। विशेष रूप से:

  • जब भी आप किसी रहस्य के लिए एक नया मान निर्धारित करते हैं, तो आपको नवीनतम मूल्य लेने के लिए उस रहस्य को संदर्भित करने वाले सभी कार्यों को फिर से तैनात करना होगा।
  • यदि आप कोई रहस्य हटाते हैं, तो सुनिश्चित करें कि आपका कोई भी तैनात फ़ंक्शन उस रहस्य का संदर्भ नहीं देता है। हटाए गए गुप्त मान का उपयोग करने वाले फ़ंक्शन चुपचाप विफल हो जाएंगे।

यहां गुप्त प्रबंधन के लिए फायरबेस सीएलआई कमांड का सारांश दिया गया है:

# Change the value of an existing secret
firebase functions:secrets:set SECRET_NAME

# View the value of a secret
functions:secrets:access SECRET_NAME

# Destroy a secret
functions:secrets:destroy SECRET_NAME

# View all secret versions and their state
functions:secrets:get SECRET_NAME

# Automatically clean up all secrets that aren't referenced by any of your functions
functions:secrets:prune

access और destroy कमांड के लिए, आप किसी विशेष संस्करण को प्रबंधित करने के लिए वैकल्पिक संस्करण पैरामीटर प्रदान कर सकते हैं। उदाहरण के लिए:

functions:secrets:access SECRET_NAME[@VERSION]

इन परिचालनों के बारे में अधिक जानकारी के लिए, सीएलआई सहायता देखने के लिए कमांड के साथ -h पास करें।

राज कैसे छुपाए जाते हैं

सीक्रेट मैनेजर बिना किसी कीमत के 6 सक्रिय गुप्त संस्करणों की अनुमति देता है। इसका मतलब है कि आप फायरबेस प्रोजेक्ट में प्रति माह 6 रहस्य बिना किसी लागत के रख सकते हैं।

डिफ़ॉल्ट रूप से, फायरबेस सीएलआई जहां उपयुक्त हो, अप्रयुक्त गुप्त संस्करणों को स्वचालित रूप से नष्ट करने का प्रयास करता है, जैसे कि जब आप गुप्त के नए संस्करण के साथ फ़ंक्शन तैनात करते हैं। इसके अलावा, आप functions:secrets:destroy और functions:secrets:prune उपयोग करके सक्रिय रूप से अप्रयुक्त रहस्यों को साफ़ कर सकते हैं।

सीक्रेट मैनेजर गुप्त रूप से 10,000 बिना बिल वाले मासिक एक्सेस संचालन की अनुमति देता है। फ़ंक्शन इंस्टेंस हर बार कोल्ड स्टार्ट होने पर केवल अपने runWith पैरामीटर में निर्दिष्ट रहस्यों को पढ़ते हैं। यदि आपके पास बहुत सारे फ़ंक्शन इंस्टेंस हैं जो बहुत सारे रहस्य पढ़ रहे हैं, तो आपका प्रोजेक्ट इस भत्ते से अधिक हो सकता है, जिस बिंदु पर आपसे प्रति 10,000 एक्सेस ऑपरेशन के लिए $0.03 का शुल्क लिया जाएगा।

अधिक जानकारी के लिए, सीक्रेट मैनेजर प्राइसिंग देखें।

एम्यूलेटर समर्थन

Dotenv के साथ पर्यावरण कॉन्फ़िगरेशन को स्थानीय क्लाउड फ़ंक्शंस एमुलेटर के साथ इंटरऑपरेट करने के लिए डिज़ाइन किया गया है।

स्थानीय क्लाउड फ़ंक्शंस एमुलेटर का उपयोग करते समय, आप .env.local फ़ाइल सेट करके अपने प्रोजेक्ट के लिए पर्यावरण चर को ओवरराइड कर सकते हैं। .env.local की सामग्री को .env और प्रोजेक्ट-विशिष्ट .env फ़ाइल पर प्राथमिकता दी जाती है।

उदाहरण के लिए, किसी प्रोजेक्ट में विकास और स्थानीय परीक्षण के लिए थोड़े भिन्न मान वाली ये तीन फ़ाइलें शामिल हो सकती हैं:

.env .env.dev .env.local
ग्रह=पृथ्वी

दर्शक=मनुष्य

दर्शक=देव मानव दर्शक=स्थानीय मनुष्य

जब स्थानीय संदर्भ में शुरू किया जाता है, तो एम्यूलेटर पर्यावरण चर को लोड करता है जैसा कि दिखाया गया है:

  $ firebase emulators:start
  i  emulators: Starting emulators: functions
  # Starts emulator with following environment variables:
  #  PLANET=Earth
  #  AUDIENCE=Local Humans

क्लाउड फ़ंक्शंस एमुलेटर में रहस्य और क्रेडेंशियल

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

पर्यावरण चर के लिए क्लाउड फ़ंक्शंस एमुलेटर समर्थन के समान, आप .secret.local फ़ाइल सेट करके रहस्य मानों को ओवरराइड कर सकते हैं। इससे आपके लिए स्थानीय स्तर पर अपने कार्यों का परीक्षण करना आसान हो जाता है, खासकर यदि आपके पास गुप्त मूल्य तक पहुंच नहीं है।

परिवेश कॉन्फ़िगरेशन से माइग्रेट किया जा रहा है

यदि आप functions.config के साथ पर्यावरण कॉन्फ़िगरेशन का उपयोग कर रहे हैं, तो आप अपने मौजूदा कॉन्फ़िगरेशन को पर्यावरण चर ( dotenv प्रारूप में) के रूप में स्थानांतरित कर सकते हैं। फायरबेस सीएलआई एक निर्यात कमांड प्रदान करता है जो आपकी निर्देशिका की .firebaserc फ़ाइल (नीचे दिए गए उदाहरण में, local , dev और prod ) में सूचीबद्ध प्रत्येक उपनाम या प्रोजेक्ट की कॉन्फ़िगरेशन को .env फ़ाइलों के रूप में आउटपुट करता है।

माइग्रेट करने के लिए, firebase functions:config:export कमांड:

firebase functions:config:export
i  Importing configs from projects: [project-0, project-1]
⚠  The following configs keys could not be exported as environment variables:

⚠  project-0 (dev):
    1foo.a => 1FOO\_A (Key 1FOO\_A must start with an uppercase ASCII letter or underscore, and then consist of uppercase ASCII letters, digits, and underscores.)

Enter a PREFIX to rename invalid environment variable keys: CONFIG\_
✔  Wrote functions/.env.prod
✔  Wrote functions/.env.dev
✔  Wrote functions/.env.local
✔  Wrote functions/.env

ध्यान दें कि, कुछ मामलों में, आपको निर्यातित पर्यावरण चर कुंजियों का नाम बदलने के लिए एक उपसर्ग दर्ज करने के लिए प्रेरित किया जाएगा। ऐसा इसलिए है क्योंकि सभी कॉन्फ़िगरेशन स्वचालित रूप से परिवर्तित नहीं किए जा सकते क्योंकि वे अमान्य हो सकते हैं या आरक्षित पर्यावरण चर कुंजी हो सकते हैं।

हम अनुशंसा करते हैं कि आप अपने कार्यों को तैनात करने या स्रोत नियंत्रण में .env फ़ाइलों की जांच करने से पहले जेनरेट की गई .env फ़ाइलों की सामग्री की सावधानीपूर्वक समीक्षा करें। यदि कोई मान संवेदनशील हैं और लीक नहीं होने चाहिए, तो उन्हें अपनी .env फ़ाइलों से हटा दें और इसके बजाय उन्हें गुप्त प्रबंधक में सुरक्षित रूप से संग्रहीत करें।

आपको अपना फ़ंक्शन कोड भी अपडेट करना होगा. कोई भी फ़ंक्शन जो functions.config का उपयोग करता है, उसे अब इसके बजाय process.env उपयोग करने की आवश्यकता होगी, जैसा कि अपग्रेड टू सेकेंड जेन में दिखाया गया है।

पर्यावरण विन्यास

firebase-functions v3.18.0 में पर्यावरण चर समर्थन जारी होने से पहले, पर्यावरण कॉन्फ़िगरेशन के लिए functions.config() का उपयोग अनुशंसित दृष्टिकोण था। यह दृष्टिकोण अभी भी समर्थित है, लेकिन हम अनुशंसा करते हैं कि सभी नई परियोजनाएं इसके बजाय पर्यावरण चर का उपयोग करें, क्योंकि वे उपयोग में आसान हैं और आपके कोड की पोर्टेबिलिटी में सुधार करते हैं।

सीएलआई के साथ पर्यावरण विन्यास सेट करें

पर्यावरण डेटा संग्रहीत करने के लिए, आप फ़ायरबेस सीएलआई में firebase functions:config:set कमांड का उपयोग कर सकते हैं। प्रत्येक कुंजी को संबंधित कॉन्फ़िगरेशन को एक साथ समूहित करने के लिए अवधियों का उपयोग करके नामस्थान दिया जा सकता है। ध्यान रखें कि कुंजियों में केवल छोटे अक्षर ही स्वीकार किए जाते हैं ; बड़े अक्षरों की अनुमति नहीं है.

उदाहरण के लिए, "कुछ सेवा" के लिए क्लाइंट आईडी और एपीआई कुंजी संग्रहीत करने के लिए, आप चला सकते हैं:

firebase functions:config:set someservice.key="THE API KEY" someservice.id="THE CLIENT ID"

वर्तमान परिवेश कॉन्फ़िगरेशन पुनर्प्राप्त करें

आपके प्रोजेक्ट के लिए पर्यावरण कॉन्फ़िगरेशन में वर्तमान में क्या संग्रहीत है, इसका निरीक्षण करने के लिए, आप firebase functions:config:get उपयोग कर सकते हैं। यह JSON को कुछ इस तरह आउटपुट करेगा:

{
  "someservice": {
    "key":"THE API KEY",
    "id":"THE CLIENT ID"
  }
}

यह कार्यक्षमता Google क्लाउड रनटाइम कॉन्फ़िगरेशन API पर आधारित है।

किसी फ़ंक्शन में पर्यावरण कॉन्फ़िगरेशन तक पहुंचने के लिए functions.config उपयोग करें

आरक्षित firebase नेमस्पेस के अंतर्गत कुछ कॉन्फ़िगरेशन स्वचालित रूप से प्रदान किया जाता है। पर्यावरण कॉन्फ़िगरेशन आपके चल रहे फ़ंक्शन के अंदर functions.config() के माध्यम से उपलब्ध कराया गया है। उपरोक्त कॉन्फ़िगरेशन का उपयोग करने के लिए, आपका कोड इस तरह दिख सकता है:

const functions = require('firebase-functions');
const request = require('request-promise');

exports.userCreated = functions.database.ref('/users/{id}').onWrite(event => {
  let email = event.data.child('email').val();

  return request({
    url: 'https://someservice.com/api/some/call',
    headers: {
      'X-Client-ID': functions.config().someservice.id,
      'Authorization': `Bearer ${functions.config().someservice.key}`
    },
    body: {email: email}
  });
});

किसी मॉड्यूल को आरंभ करने के लिए पर्यावरण कॉन्फ़िगरेशन का उपयोग करें

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

उदाहरण के लिए, स्लैक नोड एसडीके मॉड्यूल का उपयोग करने के लिए, आप इसे लिख सकते हैं:

const functions = require('firebase-functions');
const IncomingWebhook = require('@slack/client').IncomingWebhook;
const webhook = new IncomingWebhook(functions.config().slack.url);

परिनियोजन से पहले, slack.url पर्यावरण कॉन्फ़िगरेशन चर सेट करें:

firebase functions:config:set slack.url=https://hooks.slack.com/services/XXX

अतिरिक्त पर्यावरण आदेश

  • firebase functions:config:unset key1 key2 कॉन्फ़िगरेशन से निर्दिष्ट कुंजियाँ हटा देता है
  • firebase functions:config:clone --from <fromProject> किसी अन्य प्रोजेक्ट के वातावरण को वर्तमान में सक्रिय प्रोजेक्ट में क्लोन करता है।

स्वचालित रूप से पॉप्युलेट किए गए पर्यावरण चर

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

process.env.FIREBASE_CONFIG : निम्नलिखित फायरबेस प्रोजेक्ट कॉन्फ़िगरेशन जानकारी प्रदान करता है:

{
  databaseURL: 'https://databaseName.firebaseio.com',
  storageBucket: 'projectId.appspot.com',
  projectId: 'projectId'
}

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

const admin = require('firebase-admin');
admin.initializeApp();

यदि आप टाइपस्क्रिप्ट में फ़ंक्शन लिख रहे हैं, तो इस तरह प्रारंभ करें:

import * as functions from 'firebase-functions';
import * as admin from 'firebase-admin';
import 'firebase-functions';
admin.initializeApp();

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

serviceAccount = require('./serviceAccount.json');

const adminConfig = JSON.parse(process.env.FIREBASE_CONFIG);
adminConfig.credential = admin.credential.cert(serviceAccount);
admin.initializeApp(adminConfig);