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

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

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

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

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

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

चेतावनी: functions.config के साथ एनवायरमेंट कॉन्फ़िगरेशन की सुविधा, वर्शन 6.0.0 में बंद कर दी गई थी. इसे अगले मुख्य वर्शन में पूरी तरह से बंद कर दिया जाएगा. दिसंबर 2025 के बाद, functions.config() के साथ नए डिप्लॉयमेंट नहीं हो पाएंगे. अगर functions.config() का इस्तेमाल किया जा रहा है, तो एनवायरमेंट वैरिएबल पर माइग्रेट करें या पैरामीटर वाले कॉन्फ़िगरेशन को जल्द से जल्द अपनाएं.

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

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

Node.js

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

Python

from firebase_functions import https_fn
from firebase_functions.params import IntParam, StringParam

MIN_INSTANCES = IntParam("HELLO_WORLD_MIN_INSTANCES")
WELCOME_MESSAGE = StringParam("WELCOME_MESSAGE")

# To use configured parameters inside the config for a function, provide them
# directly. To use them at runtime, call .value() on them.
@https_fn.on_request(min_instances=MIN_INSTANCES)
def hello_world(req):
    return https_fn.Response(f'{WELCOME_MESSAGE.value()}! I am a function!')

पैरामीटर वाले कॉन्फ़िगरेशन वैरिएबल के साथ किसी फ़ंक्शन को डिप्लॉय करते समय, Firebase CLI सबसे पहले उनकी वैल्यू को स्थानीय .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() का इस्तेमाल करें. यह कॉलबैक, प्रोडक्शन में कोई भी फ़ंक्शन चलने से पहले काम करता है. हालांकि, इसे डिप्लॉय करने के दौरान कॉल नहीं किया जाता है. इसलिए, पैरामीटर की वैल्यू को ऐक्सेस करने के लिए यह एक सुरक्षित जगह है.

Node.js

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

const apiKey = defineSecret('GOOGLE_API_KEY');

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

Python

from firebase_functions.core import init
from firebase_functions.params import StringParam, PROJECT_ID
import firebase_admin
import vertexai

location = StringParam("LOCATION")

x = "hello"

@init
def initialize():
  # Note: to write back to a global, you'll need to use the "global" keyword
  # to avoid creating a new local with the same name.
  global x
  x = "world"
  firebase_admin.initialize_app()
  vertexai.init(PROJECT_ID.value, location.value)

अगर आपने Secret टाइप के पैरामीटर इस्तेमाल किए हैं, तो ध्यान दें कि ये सिर्फ़ उन फ़ंक्शन की प्रोसेस में उपलब्ध होते हैं जिन्होंने सीक्रेट को बाइंड किया है. अगर कोई सीक्रेट सिर्फ़ कुछ फ़ंक्शन में बाइंड किया गया है, तो उसका इस्तेमाल करने से पहले यह देखें कि secret.value() फ़ॉल्सी है या नहीं.

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

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

Node.js

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: params.select(["odd", "even"])});

const memory = defineInt("MEMORY", {
  description: "How much memory do you need?",
  input: params.select({ "micro": 256, "chonky": 2048 }),
});

const extensions = defineList("EXTENSIONS", {
  description: "Which file types should be processed?",
  input: params.multiSelect(["jpg", "tiff", "png", "webp"]),
});

const storageBucket = defineString('BUCKET', {
  description: "This will automatically
populate the selector field with the deploying Cloud Project’s
storage buckets",
  input: params.PICK_STORAGE_BUCKET,
});

Python

from firebase_functions.params import (
    StringParam,
    ListParam,
    TextInput,
    SelectInput,
    SelectOptions,
    ResourceInput,
    ResourceType,
)

MIN_INSTANCES = IntParam("HELLO_WORLD_MIN_INSTANCES")

WELCOME_MESSAGE = StringParam(
    "WELCOME_MESSAGE",
    default="Hello World",
    description="The greeting that is returned to the caller of this function",
)

ONLY_PHONE_NUMBERS = StringParam(
    "PHONE_NUMBER",
    input=TextInput(
        validation_regex="\d{3}-\d{3}-\d{4}",
        validation_error_message="Please enter a phone number in the format XXX-YYY-XXX",
    ),
)

SELECT_OPTION = StringParam(
    "PARITY",
    input=SelectInput([SelectOptions(value="odd"), SelectOptions(value="even")]),
)

STORAGE_BUCKET = StringParam(
    "BUCKET",
    input=ResourceInput(type=ResourceType.STORAGE_BUCKET),
    description="This will automatically populate the selector field with the deploying Cloud Project's storage buckets",
)

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

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

गोपनीय
स्ट्रिंग
बूलियन
पूर्णांक
फ़्लोट
सूची (Node.js)

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

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

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

Node.js

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

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

Python

from firebase_functions import https_fn
from firebase_functions.params import IntParam

MIN_INSTANCES = IntParam("HELLO_WORLD_MIN_INSTANCES")

@https_fn.on_request(min_instances=MIN_INSTANCES)
def hello_world(req):
    ...

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

Node.js

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

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

Python

from firebase_functions import https_fn
from firebase_functions.params import IntParam, StringParam

ENVIRONMENT = StringParam("ENVIRONMENT", default="dev")
MIN_INSTANCES = ENVIRONMENT.equals("PRODUCTION").then(10, 0)

@https_fn.on_request(min_instances=MIN_INSTANCES)
def hello_world(req):
    ...

सिर्फ़ रनटाइम के दौरान इस्तेमाल किए जाने वाले पैरामीटर और पैरामीटर एक्सप्रेशन को उनके value फ़ंक्शन से ऐक्सेस किया जा सकता है:

Node.js

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

Python

from firebase_functions import https_fn
from firebase_functions.params import StringParam

WELCOME_MESSAGE = StringParam("WELCOME_MESSAGE")

@https_fn.on_request()
def hello_world(req):
    return https_fn.Response(f'{WELCOME_MESSAGE.value()}! I am a function!')

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

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

Node.js

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

Python

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

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

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

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

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

Node.js

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

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

Python

from firebase_functions import https_fn
from firebase_functions.params import SecretParam

DISCORD_API_KEY = SecretParam('DISCORD_API_KEY')

@https_fn.on_request(secrets=[DISCORD_API_KEY])
def post_to_discord(req):
    api_key = DISCORD_API_KEY.value

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

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

Cloud Functions for Firebase, dotenv फ़ाइल फ़ॉर्मैट के साथ काम करता है. इसकी मदद से, .env फ़ाइल में दिए गए एनवायरमेंट वैरिएबल को आपके ऐप्लिकेशन के रनटाइम में लोड किया जा सकता है. डप्लॉय करने के बाद, एनवायरमेंट वैरिएबल को process.env इंटरफ़ेस (Node.js पर आधारित प्रोजेक्ट में) या os.environ (Python पर आधारित प्रोजेक्ट में) के ज़रिए पढ़ा जा सकता है.

अपने एनवायरमेंट को इस तरह से कॉन्फ़िगर करने के लिए, अपने प्रोजेक्ट में .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.
# ...
```

कस्टम एनवायरमेंट वैरिएबल डिप्लॉय होने के बाद, आपका फ़ंक्शन कोड उन्हें ऐक्सेस कर सकता है:

Node.js

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

Python

import os

@https_fn.on_request()
def hello(req):
    return https_fn.Response(
        f"Hello {os.environ.get('PLANET')} and {os.environ.get('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 CLI का इस्तेमाल करें.

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

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

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

डिप्लॉय करने से पहले, पक्का करें कि आपके फ़ंक्शन के कोड में, फ़ंक्शन को runWith पैरामीटर का इस्तेमाल करके सीक्रेट को ऐक्सेस करने की अनुमति मिली हो:

Node.js

const { onRequest } = require('firebase-functions/v2/https');

exports.processPayment = onRequest(
  { secrets: ["SECRET_NAME"] },
  (req, res) => {
    const myBillingService = initializeBillingService(
      // reference the secret value
      process.env.SECRET_NAME
    );
    // Process the payment
  }
);

Python

import os
from firebase_functions import https_fn

@https_fn.on_request(secrets=["SECRET_NAME"])
def process_payment(req):
    myBillingService = initialize_billing(key=os.environ.get('SECRET_NAME'))
    # Process the payment
    ...

Cloud Functions डिप्लॉय करें:
```
firebase deploy --only functions
```
अब इसे किसी अन्य एनवायरमेंट वैरिएबल की तरह ऐक्सेस किया जा सकेगा. इसके उलट, अगर कोई दूसरा फ़ंक्शन, runWith में सीक्रेट के बारे में जानकारी दिए बिना सीक्रेट को ऐक्सेस करने की कोशिश करता है, तो उसे कोई वैल्यू नहीं मिलती:
Node.js
```
exports.anotherEndpoint = 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
});
```
Python
```
@https_fn.on_request()
def another_endpoint(req):
    return https_fn.Response(f"The secret API key is {os.environ.get("SECRET_NAME")}")
    # Responds with "The secret API key is None" because the `secrets` parameter is missing.
```

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

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

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

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

सीक्रेट मैनेज करने के लिए, 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 CLI, इस्तेमाल नहीं किए गए सीक्रेट वर्शन को अपने-आप मिटाने की कोशिश करता है. ऐसा तब होता है, जब सीक्रेट के नए वर्शन के साथ फ़ंक्शन डिप्लॉय किए जाते हैं. इसके अलावा, functions:secrets:destroy और functions:secrets:prune का इस्तेमाल करके, इस्तेमाल नहीं किए गए सीक्रेट को मिटाया जा सकता है.

Secret Manager की मदद से, हर महीने 10,000 बार सीक्रेट को ऐक्सेस किया जा सकता है. इसके लिए, कोई शुल्क नहीं लिया जाता. फ़ंक्शन इंस्टेंस, हर बार कोल्ड स्टार्ट होने पर सिर्फ़ उन सीक्रेट को पढ़ते हैं जो उनके runWith पैरामीटर में तय किए गए हैं. अगर आपके पास ऐसे फ़ंक्शन इंस्टेंस हैं जो कई सीक्रेट पढ़ते हैं, तो हो सकता है कि आपका प्रोजेक्ट इस सीमा से ज़्यादा हो जाए. ऐसे में, आपसे हर 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 के साथ एनवायरमेंट कॉन्फ़िगरेशन का इस्तेमाल किया है, तो आपको 2025 के आखिर तक अपने मौजूदा कॉन्फ़िगरेशन को एनवायरमेंट वैरिएबल (dotenv फ़ॉर्मैट में) के तौर पर माइग्रेट करना होगा. ऐसा इसलिए, क्योंकि 2025 के आखिर में functions.config को बंद कर दिया जाएगा. दिसंबर 2025 के बाद, functions.config के साथ नए डिप्लॉयमेंट नहीं किए जा सकेंगे.

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 फ़ाइलों से हटा दें. इसके बजाय, उन्हें Secret Manager में सुरक्षित तरीके से सेव करें.

आपको अपने फ़ंक्शन का कोड भी अपडेट करना होगा. functions.config का इस्तेमाल करने वाले सभी फ़ंक्शन को अब process.env का इस्तेमाल करना होगा. इसके बारे में एनवायरमेंट वैरिएबल में बताया गया है.