आम तौर पर, आपको अपने फ़ंक्शन के लिए अतिरिक्त कॉन्फ़िगरेशन की ज़रूरत पड़ेगी, जैसे कि तीसरे पक्ष की एपीआई कुंजियां या ट्यून करने लायक सेटिंग. 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 प्रोजेक्ट पर चालू है).
ये फ़ंक्शन, हर मामले में उपयोगकर्ता के तय किए गए स्ट्रिंग पैरामीटर की तरह होते हैं. हालांकि, इनकी वैल्यू हमेशा 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 फ़ाइल में दिए गए एनवायरमेंट वैरिएबल लोड करने के लिए dotenv फ़ाइल फ़ॉर्मैट के साथ काम करता है. लागू होने के बाद, एनवायरमेंट वैरिएबल को 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 पास करें.
सीक्रेट की बिलिंग कैसे की जाती है
Secret Manager में 6 ऐक्टिव सीक्रेट वर्शन बिना किसी शुल्क के इस्तेमाल किए जा सकते हैं. इसका मतलब है कि आप किसी Firebase प्रोजेक्ट में बिना किसी शुल्क के हर महीने छह सीक्रेट रख सकते हैं.
डिफ़ॉल्ट रूप से, Firebase सीएलआई जहां ज़रूरत हो वहां, इस्तेमाल नहीं किए गए सीक्रेट वर्शन को अपने-आप खत्म करने की कोशिश करता है. जैसे, जब सीक्रेट के नए वर्शन वाले फ़ंक्शन डिप्लॉय किए जाते हैं. साथ ही, इस्तेमाल नहीं किए गए सीक्रेट हटाए जा सकते हैं. इसके लिए, आपको
functions:secrets:destroy और functions:secrets:prune का इस्तेमाल करना होगा.
सीक्रेट मैनेजर, सीक्रेट रणनीति के लिए हर महीने 10,000 बिना बिल वाली ऐक्सेस कार्रवाइयों की अनुमति देता है. जब भी फ़ंक्शन कोल्ड स्टार्ट किया जाता है, तब ये सिर्फ़ अपने runWith पैरामीटर में बताए गए सीक्रेट को पढ़ते हैं. अगर आपके पास बहुत सारे सीक्रेट पढ़ने के लिए, कई फ़ंक्शन इंस्टेंस हैं, तो आपके प्रोजेक्ट को इस सीमा को पार करना पड़ सकता है. इस स्थिति में, आपसे हर 10,000 ऐक्सेस ऑपरेशन के लिए 0.03 डॉलर लिए जाएंगे.
ज़्यादा जानकारी के लिए, Secret Manager Pricing देखें.
एम्युलेटर सहायता
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 फ़ाइल में दिए गए हर उपनाम या प्रोजेक्ट के कॉन्फ़िगरेशन को .env फ़ाइलों के तौर पर दिखाता है. उदाहरण के लिए, local, dev, और prod.
माइग्रेट करने के लिए, 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 का इस्तेमाल करना होगा, जैसा कि 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();
अगर आपको सेवा खाते के क्रेडेंशियल का इस्तेमाल करके, एडमिन SDK को डिफ़ॉल्ट प्रोजेक्ट कॉन्फ़िगरेशन के साथ शुरू करना है, तो किसी फ़ाइल में मौजूद क्रेडेंशियल लोड करके उन्हें FIREBASE_CONFIG में इस तरह जोड़ें:
serviceAccount = require('./serviceAccount.json');
const adminConfig = JSON.parse(process.env.FIREBASE_CONFIG);
adminConfig.credential = admin.credential.cert(serviceAccount);
admin.initializeApp(adminConfig);