Google uses AI technology to translate content into your preferred language. AI translations can contain errors.

अपने एनवायरमेंट (पहली जनरेशन) को कॉन्फ़िगर करना

ध्यान दें: इस पेज पर पहली जनरेशन की जिस सुविधा के बारे में बताया गया है वह Cloud Functions (दूसरी जनरेशन) में भी उपलब्ध है. इसमें बेहतर सुविधाएं और परफ़ॉर्मेंस मिलती है. दूसरी जनरेशन के बारे में ज़्यादा जानने के लिए, वर्शन की तुलना देखें. इस सुविधा के लिए, दूसरी जनरेशन के गाइड पर सीधे जाने के लिए, अपना एनवायरमेंट कॉन्फ़िगर करना लेख देखें.

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

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

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

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

पैरामीटर के हिसाब से कॉन्फ़िगरेशन

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

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

const functions = require('firebase-functions/v1');
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 से सीक्रेट भी इस्तेमाल किए जा सकते हैं. इन टाइप की फ़ाइलें इस्तेमाल की जा सकती हैं:

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

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

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

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

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

const functions = require('firebase-functions/v1');
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/v1');
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/v1');
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 — वह Cloud प्रोजेक्ट जिसमें फ़ंक्शन चल रहा है.
databaseURL — Realtime Database के उस इंस्टेंस का यूआरएल जो फ़ंक्शन से जुड़ा है . यह तब उपलब्ध होता है, जब Firebase प्रोजेक्ट पर यह सुविधा चालू हो.
storageBucket — Cloud Storage का वह बकेट जो फ़ंक्शन से जुड़ा है . यह तब उपलब्ध होता है, जब Firebase प्रोजेक्ट पर यह सुविधा चालू हो.

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

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

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

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

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

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

Cloud Functions for Firebase dotenv फ़ाइल फ़ॉर्मैट के साथ काम करता है. इसकी मदद से, .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=Earth AUDIENCE=Humans	AUDIENCE=Dev Humans	AUDIENCE=Prod Humans

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

$ 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 फ़ाइलों को सोर्स कंट्रोल में शामिल किया जाता है.

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

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

सीक्रेट बनाने के लिए, 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 Functions डिप्लॉय करें:
```
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 पास करें.

सीक्रेट के लिए बिलिंग का तरीका

Secret Manager में, छह सीक्रेट वर्शन बिना किसी शुल्क के इस्तेमाल किए जा सकते हैं. इसका मतलब है कि Firebase प्रोजेक्ट में, हर महीने छह सीक्रेट बिना किसी शुल्क के इस्तेमाल किए जा सकते हैं.

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

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

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

एम्युलेटर की सुविधा

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

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

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

`.env`	`.env.dev`	`.env.local`
PLANET=Earth AUDIENCE=Humans	AUDIENCE=Dev Humans	AUDIENCE=Local Humans

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

  $ 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 एपीआई को बंद कर दिया गया है. इसे मार्च 2027 में पूरी तरह से बंद कर दिया जाएगा. इस तारीख के बाद, functions.config के साथ डिप्लॉयमेंट नहीं किए जा सकेंगे.

डिप्लॉयमेंट में गड़बड़ियों से बचने के लिए, Cloud Secret Manager पर अपने कॉन्फ़िगरेशन को Firebase सीएलआई का इस्तेमाल करके माइग्रेट करें. हमारा सुझाव है कि अपने कॉन्फ़िगरेशन को माइग्रेट करने के लिए, इस तरीके का इस्तेमाल करें. यह सबसे असरदार और सुरक्षित तरीका है.

सीएलआई की मदद से कॉन्फ़िगरेशन एक्सपोर्ट करनाFirebase

Cloud Secret Manager में, अपने मौजूदा एनवायरमेंट कॉन्फ़िगरेशन को नए सीक्रेट में एक्सपोर्ट करने के लिए, config export कमांड का इस्तेमाल करें:

$ firebase functions:config:export
i  This command retrieves your Runtime Config values (accessed via functions.config())
   and exports them as a Secret Manager secret.

i  Fetching your existing functions.config() from your project...  ✔
   Fetched your existing functions.config().

i  Configuration to be exported:
⚠  This may contain sensitive data. Do not share this output.

{
   ...
}

✔ What would you like to name the new secret for your configuration? RUNTIME_CONFIG

✔  Created new secret version projects/project/secrets/RUNTIME_CONFIG/versions/1```

सीक्रेट बाइंड करने के लिए, फ़ंक्शन कोड अपडेट करना

Cloud Secret Manager में सेव किए गए कॉन्फ़िगरेशन का इस्तेमाल करने के लिए, अपने फ़ंक्शन सोर्स में defineJsonSecret एपीआई का इस्तेमाल करें. साथ ही, पक्का करें कि सीक्रेट, उन सभी फ़ंक्शन से बाइंड हों जिन्हें उनकी ज़रूरत है.

इससे पहले
```
const functions = require("firebase-functions/v1");

exports.myFunction = functions.https.onRequest((req, res) => {
  const apiKey = functions.config().someapi.key;
  // ...
});
```
इसके बाद
```
const { onRequest } = require("firebase-functions/v2/https");
const { defineJsonSecret } = require("firebase-functions/params");

const config = defineJsonSecret("RUNTIME_CONFIG");

exports.myFunction = onRequest(
  // Bind secret to your function
  { secrets: [config] },
  (req, res) => {
    // Access secret values via .value()
    const apiKey = config.value().someapi.key;
    // ...
});
```
फ़ंक्शन डिप्लॉय करना

बदलावों को लागू करने और सीक्रेट की अनुमतियां बाइंड करने के लिए, अपडेट किए गए फ़ंक्शन डिप्लॉय करें.
```
firebase deploy --only functions:<your-function-name>
```

एनवायरमेंट वैरिएबल जो अपने-आप भर जाते हैं

कुछ एनवायरमेंट वैरिएबल ऐसे होते हैं जो फ़ंक्शन के रनटाइम और स्थानीय तौर पर एम्युलेट किए गए फ़ंक्शन में अपने-आप भर जाते हैं. इनमें वे वैरिएबल शामिल हैं जो Google Cloudसे भर जाते हैं, साथ ही Firebase के लिए खास एनवायरमेंट वैरिएबल भी शामिल हैं:

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

{
  databaseURL: 'https://DATABASE_NAME.firebaseio.com',
  storageBucket: 'PROJECT_ID.firebasestorage.app',
  projectId: 'PROJECT_ID'
}

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

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

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

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

import * as functions from 'firebase-functions/v1';
import * as admin from 'firebase-admin';
import 'firebase-functions/v1';
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);