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

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

अक्सर आपको अपने फ़ंक्शन के लिए अतिरिक्त कॉन्फ़िगरेशन की ज़रूरत पड़ेगी, जैसे कि तीसरे पक्ष की एपीआई कुंजियां या ट्यून करने लायक सेटिंग. Cloud Functions के लिए 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> फ़ाइल को वर्शन कंट्रोल में जोड़ना मददगार साबित हो सकता है.

ग्लोबल स्कोप में पैरामीटर इस्तेमाल करना

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

  const { GoogleGenerativeAI } = require('@google/generative-ai');
  const { defineSecret } = require('firebase-functions/params');
  const { onInit } = require('firebase-functions/v1');

  const apiKey = defineSecret('GOOGLE_API_KEY');

  let genAI;
  onInit(() => {
    genAI = new GoogleGenerativeAI(apiKey.value());
  })

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

पैरामीटर को ऐसे 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 से जुड़ी जानकारी भी हासिल की जा सकती है. काम करने वाले टाइप के उदाहरण:

गोपनीय
स्ट्रिंग
बूलियन
पूर्णांक
फ़्लोट

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

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 प्रोजेक्ट पर चालू है).

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

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

Secret टाइप के पैरामीटर को defineSecret() का इस्तेमाल करके तय किया जाता है. ये पैरामीटर स्ट्रिंग दिखाते हैं ऐसे पैरामीटर जिनकी वैल्यू 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, डॉटएनव एनवायरमेंट वैरिएबल लोड करने के लिए, इस फ़ाइल फ़ॉर्मैट की .env फ़ाइल में बताया गया है ऐप्लिकेशन रनटाइम. डिप्लॉय किए जाने के बाद, एनवायरमेंट वैरिएबल को process.env इंटरफ़ेस पर कॉपी करने की सुविधा मिलती है.

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

अपनी functions/ डायरेक्ट्री में .env फ़ाइल बनाएं:

# Directory layout:
#   my-project/
#     firebase.json
#     functions/
#       .env
#       package.json
#       index.js

बदलाव करने के लिए .env फ़ाइल खोलें और मनचाही कुंजियां जोड़ें. उदाहरण के लिए:
```
PLANET=Earth
AUDIENCE=Humans
```
फ़ंक्शन डिप्लॉय करें और पुष्टि करें कि एनवायरमेंट वैरिएबल लोड हो गए हैं:
```
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_ से शुरू होने वाली सभी कुंजियां
नीचे दी गई सूची में से कोई भी कुंजी:
क्लाउड_RUNTIME_CONFIG
ENTRY_POINT
GCP_प्रोजेक्ट
जीक्लाउड_प्रोजेक्ट
Google_क्लाउड_प्रोजेक्ट
फ़ंक्शन ट्रिगर करने वाला टाइप
फ़ंक्शन का नाम
Function_MEMORY_MB
फीचर समय
Function_ Identity
फ़ंक्शन_क्षेत्र
फ़ंक्शन टारगेट
फ़ंक्शन_SIGNATURE_TYPE
के_सेवा
के_रिविज़न
पोर्ट
के_कॉन्फ़िगरेशन

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

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

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

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

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

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

अपनी लोकल प्रोजेक्ट डायरेक्ट्री के रूट से, यह कमांड चलाएं:
```
firebase functions:secrets:set SECRET_NAME
```
SECRET_NAME के लिए कोई वैल्यू डालें.

सीएलआई ने सफल होने का मैसेज दिखाया है और चेतावनी दी है कि आपको फ़ंक्शन डिप्लॉय करने होंगे बदलाव को लागू करने के लिए.
डिप्लॉय करने से पहले, पक्का करें कि आपका फ़ंक्शन कोड, 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
  });
```
Cloud फ़ंक्शन डिप्लॉय करें:
```
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 को आदेश के साथ पास करें सीएलआई सहायता देखें.

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

सीक्रेट मैनेजर, छह ऐक्टिव सीक्रेट की अनुमति देता है वर्शन वह भी बिना किसी शुल्क के. इसका मतलब है कि 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=पृथ्वी ऑडियंस=इंसान	ऑडियंस=डेवलपर ह्यूमन्स	ऑडियंस=स्थानीय इंसान

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

  $ 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 functions:config:set का इस्तेमाल किया जा सकता है आदेश Firebase CLI में देगा. ग्रुप से जुड़े पीरियड का इस्तेमाल करके, हर कुंजी को नेमस्पेस किया जा सकता है एक साथ कॉन्फ़िगर करते हैं. ध्यान रखें कि सिर्फ़ अंग्रेज़ी के छोटे अक्षरों में पासकोड के तौर पर स्वीकार किया जाता है; अंग्रेज़ी के बड़े अक्षरों की अनुमति नहीं है.

उदाहरण के लिए, किसी दस्तावेज़ में Client-ID और API पासकोड "कुछ सेवा", तो आप चला सकते हैं:

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

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

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

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