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


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

इन तीन विकल्पों में से कोई एक चुना जा सकता है:

  • पैरामीटर वाला कॉन्फ़िगरेशन (ज़्यादातर मामलों के लिए इसका सुझाव दिया जाता है). इससे ऐसे पैरामीटर के साथ एनवायरमेंट कॉन्फ़िगरेशन मिलता है जिनकी पुष्टि मज़बूत तरीके से टाइप की जाती है. इनमें ऐसे पैरामीटर शामिल होते हैं जिनकी पुष्टि डिप्लॉयमेंट के समय होती है. इससे गड़बड़ियां रुक जाती हैं और यह डीबग करने की प्रोसेस को आसान बनाता है.
  • एनवायरमेंट वैरिएबल का फ़ाइल-आधारित कॉन्फ़िगरेशन. इस तरीके से, एनवायरमेंट वैरिएबल लोड करने के लिए, मैन्युअल तौर पर dotenv फ़ाइल बनाई जाती है.
  • Firebase सीएलआई और functions.config (सिर्फ़ Cloud Functions (1st gen) के साथ) के साथ रनटाइम एनवायरमेंट कॉन्फ़िगरेशन.

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

पैरामीटर वाला कॉन्फ़िगरेशन

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

अपने कोड में पैरामीटर तय करने के लिए, यह मॉडल अपनाएं:

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

पैरामीटर वाले कॉन्फ़िगरेशन वैरिएबल वाले फ़ंक्शन को डिप्लॉय करते समय, Firebase सीएलआई सबसे पहले स्थानीय .env फ़ाइलों से अपनी वैल्यू लोड करने की कोशिश करता है. अगर सीएलआई उन फ़ाइलों में मौजूद नहीं है और default सेट नहीं है, तो सीएलआई डिप्लॉयमेंट के दौरान वैल्यू के लिए अनुरोध करेगा. इसके बाद, इन वैल्यू को आपकी functions/ डायरेक्ट्री में मौजूद .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 ऑब्जेक्ट के साथ कॉन्फ़िगर किया जा सकता है जो यह कंट्रोल करता है कि सीएलआई, वैल्यू को कैसे प्रॉम्प्ट करेगा. नीचे दिए गए उदाहरण में फ़ोन नंबर के फ़ॉर्मैट की पुष्टि करने, आसानी से चुनने का विकल्प देने, और Firebase प्रोजेक्ट से चुनने के विकल्प अपने-आप भरने के लिए विकल्प सेट किए गए हैं:

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"})

पैरामीटर के टाइप

पैरामीटर वाले कॉन्फ़िगरेशन की मदद से, पैरामीटर वैल्यू को बेहतर तरीके से टाइप किया जा सकता है. साथ ही, Cloud Secret Manager में सीक्रेट भी काम करते हैं. इस तरह की फ़ाइलें इस्तेमाल की जा सकती हैं:

  • गोपनीय
  • स्ट्रिंग
  • बूलियन
  • पूरी संख्या
  • Float

पैरामीटर वैल्यू और एक्सप्रेशन

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

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

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

पहले से मौजूद पैरामीटर

Cloud Functions SDK टूल में पहले से तय किए गए तीन पैरामीटर हैं, जो firebase-functions/params सबपैकेज से उपलब्ध हैं:

  • projectID — वह क्लाउड प्रोजेक्ट जिसमें फ़ंक्शन चल रहा है.
  • databaseURL — फ़ंक्शन से जुड़े रीयल टाइम डेटाबेस इंस्टेंस का यूआरएल (अगर Firebase प्रोजेक्ट में चालू है).
  • storageBucket — फ़ंक्शन से जुड़ी Cloud Storage बकेट (अगर Firebase प्रोजेक्ट के लिए चालू है).

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

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

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

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

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();
    //…

फ़ंक्शन के चलने तक सीक्रेट की वैल्यू छिपी रहती हैं. इसलिए, फ़ंक्शन को कॉन्फ़िगर करते समय उनका इस्तेमाल नहीं किया जा सकता.

एनवायरमेंट वैरिएबल

'Firebase के लिए Cloud Functions' आपके ऐप्लिकेशन के रनटाइम में dotenv फ़ाइल फ़ॉर्मैट के साथ काम करता है, जो .env फ़ाइल में दिए गए एनवायरमेंट वैरिएबल के लिए मौजूद है. लागू होने के बाद, एनवायरमेंट वैरिएबल को 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}`);
});

एनवायरमेंट वैरिएबल के कई सेट को डिप्लॉय करना

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

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

.env .env.dev .env.prod
PLANET=पृथ्वी

दर्शक=इंसान

दर्शक=डेव इंसान दर्शक=प्रॉडक्टिव इंसान

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

$ 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
  • ENTRY_POINT
  • GCP_PROJECT
  • GCLOUD_PROJECT
  • GOOGLE_CLOUD_PROJECT
  • FUNCTION_TRIGGER_TYPE
  • FUNCTION_NAME
  • FUNCTION_MEMORY_MB
  • FUNCTION_TIMEOUT_SEC
  • FUNCTION_IDENTITY
  • FUNCTION_REGION
  • FUNCTION_TARGET
  • FUNCTION_SIGNATURE_TYPE
  • K_SERVICE
  • K_REVISION
  • PORT
  • K_CONFIGURATION

कॉन्फ़िगरेशन की संवेदनशील जानकारी को स्टोर और ऐक्सेस करें

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

कॉन्फ़िगरेशन की संवेदनशील जानकारी को सेव करने में आपकी मदद करने के लिए, 'Firebase के लिए Cloud Functions' को Google Cloud सीक्रेट मैनेजर के साथ इंटिग्रेट किया गया है. एन्क्रिप्ट (सुरक्षित) की गई यह सेवा, कॉन्फ़िगरेशन की वैल्यू को सुरक्षित तरीके से सेव करती है. साथ ही, ज़रूरत पड़ने पर आपके फ़ंक्शन से आसानी से ऐक्सेस कर सकती है.

सीक्रेट बनाएं और उसका इस्तेमाल करें

सीक्रेट बनाने के लिए, Firebase सीएलआई का इस्तेमाल करें.

सीक्रेट बनाने और उसका इस्तेमाल करने के लिए:

  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 पैरामीटर में सीक्रेट शामिल होता है उन्हें एनवायरमेंट वैरिएबल के तौर पर उस सीक्रेट का ऐक्सेस मिलेगा. इससे यह पक्का करने में मदद मिलती है कि सीक्रेट वैल्यू सिर्फ़ तब उपलब्ध हों, जब उनकी ज़रूरत हो. इससे गलती से सीक्रेट लीक होने का खतरा कम हो जाता है.

सीक्रेट मैनेज करना

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

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

यहां सीक्रेट मैनेजमेंट के लिए Firebase सीएलआई कमांड की खास जानकारी दी गई है:

# 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 को पास करें.

सीक्रेट टोकन की बिलिंग कैसे की जाती है

सीक्रेट मैनेजर के ज़रिए, बिना किसी शुल्क के छह ऐक्टिव सीक्रेट versions किए जा सकते हैं. इसका मतलब है कि किसी Firebase प्रोजेक्ट में, हर महीने छह सीक्रेट रखे जा सकते हैं. इसके लिए आपको कोई शुल्क नहीं देना होगा.

डिफ़ॉल्ट रूप से, Firebase सीएलआई, इस्तेमाल न किए गए सीक्रेट वर्शन को अपने-आप खत्म करने की कोशिश करता है. उदाहरण के लिए, जब सीक्रेट के नए वर्शन वाले फ़ंक्शन डिप्लॉय किए जाते हैं. इसके अलावा, functions:secrets:destroy और functions:secrets:prune का इस्तेमाल करके, इस्तेमाल न किए गए सीक्रेट मिटाए जा सकते हैं.

सीक्रेट मैनेजर, सीक्रेट पर हर महीने 10,000 बिना शुल्क वाले ऐक्सेस ऑपरेशन की अनुमति देता है. जब भी फ़ंक्शन इंस्टेंस हर बार कोल्ड स्टार्ट होता है, तो फ़ंक्शन इंस्टेंस सिर्फ़ उनके runWith पैरामीटर में दिए गए सीक्रेट ही पढ़ते हैं. अगर आपके पास फ़ंक्शन के बहुत सारे इंस्टेंस हैं जो कई सीक्रेट बातें पढ़ना चाहते हैं, तो आपके प्रोजेक्ट के लिए तय सीमा से ज़्यादा काम हो सकता है. इस स्थिति में, आपसे हर 10,000 ऐक्सेस ऑपरेशन के लिए 0.03 डॉलर का शुल्क लिया जाएगा.

ज़्यादा जानकारी के लिए, सीक्रेट मैनेजर की कीमत देखें.

एम्युलेटर की सहायता

dotenv के साथ एनवायरमेंट कॉन्फ़िगरेशन को लोकल Cloud Functions एम्युलेटर के साथ इंटिग्रेट करने के लिए डिज़ाइन किया गया है.

लोकल Cloud Functions एम्युलेटर का इस्तेमाल करते समय, .env.local फ़ाइल सेट अप करके, अपने प्रोजेक्ट के लिए एनवायरमेंट वैरिएबल को बदला जा सकता है. .env.local के कॉन्टेंट को .env और प्रोजेक्ट के हिसाब से बनी .env फ़ाइल के मुकाबले ज़्यादा प्राथमिकता दी जाती है.

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

.env .env.dev .env.local
PLANET=पृथ्वी

दर्शक=इंसान

दर्शक=डेव इंसान AUDIENCE=स्थानीय लोग

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

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

Cloud Functions एम्युलेटर में मौजूद सीक्रेट और क्रेडेंशियल

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

एनवायरमेंट वैरिएबल के लिए, Cloud Functions एम्युलेटर की सुविधा की तरह ही, .secret.local फ़ाइल सेट अप करके सीक्रेट वैल्यू को बदला जा सकता है. इससे आपके लिए स्थानीय तौर पर अपने फ़ंक्शन की जांच करना आसान हो जाता है, खास तौर पर तब, जब आपके पास सीक्रेट वैल्यू का ऐक्सेस न हो.

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

अगर functions.config के साथ एनवायरमेंट कॉन्फ़िगरेशन का इस्तेमाल किया जा रहा है, तो अपने मौजूदा कॉन्फ़िगरेशन को एनवायरमेंट वैरिएबल (dotenv फ़ॉर्मैट में) के तौर पर माइग्रेट किया जा सकता है. Firebase सीएलआई, एक्सपोर्ट करने का निर्देश देता है जो आपकी डायरेक्ट्री की .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 का इस्तेमाल करना होगा, जैसा कि 2nd gen पर अपग्रेड करें में दिखाया गया है.

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

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

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

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

उदाहरण के लिए, "कुछ सेवा" के लिए Client-ID और एपीआई पासकोड सेव करने के लिए, इसे चलाया जा सकता है:

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 Cloud रनटाइम कॉन्फ़िगरेशन एपीआई पर आधारित होती है.

किसी फ़ंक्शन में एनवायरमेंट कॉन्फ़िगरेशन को ऐक्सेस करने के लिए, 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}
  });
});

मॉड्यूल शुरू करने के लिए एनवायरमेंट कॉन्फ़िगरेशन का इस्तेमाल करना

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

उदाहरण के लिए, Slack Node SDK मॉड्यूल इस्तेमाल करने के लिए, यह लिखा जा सकता है:

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 Cloud से अपने-आप जानकारी भरने वाले कैंपेन के साथ-साथ, Firebase के लिए खास तौर पर बनाया गया एनवायरमेंट वैरिएबल शामिल होता है:

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

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

बिना किसी आर्ग्युमेंट के Firebase एडमिन SDK टूल शुरू करने पर, यह कॉन्फ़िगरेशन अपने-आप लागू हो जाता है. अगर JavaScript में फ़ंक्शन लिखे जा रहे हैं, तो इस तरह से शुरू करें:

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

अगर आप TypeScript में फ़ंक्शन लिख रहे हैं, तो इस तरह शुरू करें:

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

अगर आपको सेवा खाते के क्रेडेंशियल का इस्तेमाल करके, Admin SDK टूल को डिफ़ॉल्ट प्रोजेक्ट कॉन्फ़िगरेशन के साथ शुरू करना है, तो किसी फ़ाइल से क्रेडेंशियल लोड करके, उन्हें इस तरह से FIREBASE_CONFIG में जोड़ा जा सकता है:

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

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