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

Firebase Remote Config Node.js (v12.1.0+), Python (v6.7.0+), Java (v9.7.0+), और Go (v4.17.0+) के लिए, Firebase Admin SDK टूल का इस्तेमाल करके सर्वर-साइड कॉन्फ़िगरेशन की सुविधा देता है.

इस सुविधा की मदद से, Remote Config का इस्तेमाल करके, सर्वर-साइड ऐप्लिकेशन के व्यवहार और कॉन्फ़िगरेशन को डाइनैमिक तरीके से मैनेज किया जा सकता है. इसमें सर्वरलेस इंप्लीमेंटेशन शामिल हैं, जैसे कि Cloud Functions for Firebase और Cloud Run पर कंटेनर वाली सेवाएं.

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

सर्वर-साइड Remote Config की मदद से, ये काम किए जा सकते हैं:

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

सर्वर साइड Remote Config को Cloud Run, Cloud Functions for Firebase या खुद होस्ट किए गए सर्वर एनवायरमेंट पर डिप्लॉय किया जा सकता है.

शुरू करने से पहले

Firebase प्रोजेक्ट बनाने, सेवा खाता सेट अप करने, और अपने सर्वर में Firebase Admin SDK जोड़ने के लिए, अपने सर्वर में Firebase Admin SDK जोड़ें में दिए गए निर्देशों का पालन करें. पक्का करें कि आपने अपने प्लैटफ़ॉर्म के लिए, Admin SDK के साथ काम करने वाले वर्शन का इस्तेमाल किया हो:

  • Node.js: Firebase Admin Node.js SDK का वर्शन 12.1.0 या इसके बाद का वर्शन
  • Python: Firebase Admin Python SDK v6.7.0+
  • Java: Firebase Admin Java SDK v9.7.0+
  • Go: Firebase Admin Go SDK v4.17.0+

पहला चरण: Firebase Admin SDK को शुरू करें और एपीआई अनुरोधों को अनुमति दें

जब Admin SDK को बिना किसी पैरामीटर के शुरू किया जाता है, तो SDK Google Application Default Credentials का इस्तेमाल करता है. साथ ही, GOOGLE_APPLICATION_CREDENTIALS एनवायरमेंट वैरिएबल से विकल्प पढ़ता है. एसडीके को शुरू करें और अपने प्लैटफ़ॉर्म के लिए Remote Config को कॉन्फ़िगर करें:

Node.js

initializeApp और getRemoteConfig इंपोर्ट करें. इसके बाद, Firebase ऐप्लिकेशन इंस्टेंस शुरू करें:

import { initializeApp } from "firebase-admin/app";
import { getRemoteConfig } from "firebase-admin/remote-config";

// Initialize Firebase
const firebaseApp = initializeApp();

Python

firebase_admin को इंपोर्ट करें. साथ ही, टेंप्लेट को एसिंक्रोनस तरीके से लोड करने और JSON पार्स करने के लिए asyncio और json को इंपोर्ट करें. इसके बाद, ऐप्लिकेशन को शुरू करें:

import firebase_admin
import asyncio
import json

firebase_admin.initialize_app()

Java

FirebaseOptions और अपने सेवा खाते के क्रेडेंशियल का इस्तेमाल करके, Firebase Admin SDK को शुरू करें:

// Initialize the Firebase Admin SDK
FirebaseOptions options = new FirebaseOptions.Builder()
    .setCredentials(GoogleCredentials.fromStream(serviceAccount))
    .build();
FirebaseApp.initializeApp(options);

जाएं

Firebase ऐप्लिकेशन को शुरू करें और RemoteConfig क्लाइंट इंस्टेंस बनाएं:

ctx := context.Background()

// Initialize Firebase
app, err := firebase.NewApp(ctx, nil)
if err != nil {
    log.Fatalln("Error initializing app:", err)
}

remoteConfig, err := app.RemoteConfig(ctx)
if err != nil {
    log.Fatalln("Error initializing remote config client:", err)
}

दूसरा चरण: अपने सर्वर ऐप्लिकेशन के लिए डिफ़ॉल्ट पैरामीटर वैल्यू की पहचान करना

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

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

पैरामीटर का नाम ब्यौरा टाइप डिफ़ॉल्ट वैल्यू
model_name मॉडल के एपीआई का नाम स्ट्रिंग gemini-2.0-flash
preamble_prompt उपयोगकर्ता की क्वेरी से पहले जोड़ने के लिए प्रॉम्प्ट स्ट्रिंग I'm a developer who wants to learn about Firebase and you are a helpful assistant who knows everything there is to know about Firebase!
generation_config मॉडल को भेजे जाने वाले पैरामीटर JSON {"stopSequences": ["I hope this helps"], "temperature": 0.7, "maxOutputTokens": 512, "topP": 0.1, "topK": 20}

तीसरा चरण: सर्वर ऐप्लिकेशन को कॉन्फ़िगर करना

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

  1. Remote Config सर्वर टेंप्लेट को ऐक्सेस करें और लोड करें.

    Node.js

    initServerTemplate() का इस्तेमाल करके सर्वर टेंप्लेट को शुरू करें और बैकएंड से टेंप्लेट फ़ेच करने के लिए load() को कॉल करें:

    // Initialize server-side Remote Config
const rc = getRemoteConfig(firebaseApp);
const template = rc.initServerTemplate();

// Load Remote Config
await template.load();

    अगर Cloud Functions for Firebase में Node.js का इस्तेमाल किया जा रहा है, तो एक ही चरण में टेंप्लेट को शुरू करने और लोड करने के लिए, एसिंक्रोनस getServerTemplate() फ़ंक्शन का इस्तेमाल किया जा सकता है:

    // Initialize server-side Remote Config
const rc = getRemoteConfig(firebaseApp);
const template = await rc.getServerTemplate();

    Python

    init_server_template() का इस्तेमाल करके सर्वर टेंप्लेट को शुरू करें और बैकएंड से टेंप्लेट फ़ेच करने के लिए load() को कॉल करें:

    from firebase_admin import remote_config

# Initialize server-side Remote Config
template = remote_config.init_server_template()

# Load the template from the backend
asyncio.run(template.load())

    इसके अलावा, अगर Python के साथ Cloud Functions for Firebase का इस्तेमाल किया जा रहा है, तो एक ही चरण में टेंप्लेट को शुरू करने और लोड करने के लिए, एसिंक्रोनस get_server_template() फ़ंक्शन का इस्तेमाल किया जा सकता है:

    # Initialize server-side Remote Config
template = await remote_config.get_server_template()

    Java

    FirebaseRemoteConfig.getInstance() का इस्तेमाल करके, सर्वर-साइड Remote Config क्लाइंट को शुरू करें:

    // Initialize server-side Remote Config client
FirebaseRemoteConfig rc = FirebaseRemoteConfig.getInstance();

    इसके अलावा, अगर Java के साथ Cloud Functions for Firebase का इस्तेमाल किया जा रहा है, तो एक ही चरण में टेंप्लेट को शुरू करने और लोड करने के लिए, getServerTemplate() का इस्तेमाल किया जा सकता है:

    ServerTemplate template = rc.getServerTemplate();

    जाएं

    InitServerTemplate() का इस्तेमाल करके सर्वर टेंप्लेट को शुरू करें और बैकएंड से टेंप्लेट फ़ेच करने के लिए Load() को कॉल करें:

    // Initialize server-side Remote Config
defaultConfig := make(map[string]any)
templateDataJSON := ""
template, err := remoteConfig.InitServerTemplate(defaultConfig, templateDataJSON)
if err != nil {
    log.Fatalln("Error initializing server template:", err)
}

// Load Remote Config
err = template.Load(ctx)
if err != nil {
    log.Fatalln("Error fetching server template:", err)
}

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

  2. यह पक्का करने के लिए कि Remote Config बैकएंड सर्वर से कनेक्शन कट जाने पर भी आपका ऐप्लिकेशन सही तरीके से काम करे, अपने ऐप्लिकेशन में हर पैरामीटर के लिए डिफ़ॉल्ट वैल्यू जोड़ें.

    Node.js

    अपने initServerTemplate या getServerTemplate टेंप्लेट फ़ंक्शन में defaultConfig ऑब्जेक्ट जोड़ें:

    const template = rc.initServerTemplate({
  defaultConfig: {
    model_name: "gemini-pro",
    generation_config: '{"stopSequences": [], "temperature": 0.7, "maxOutputTokens": 512, "topP": 0.1, "topK": 20}',
    preamble_prompt: "I'm a developer who wants to learn about Firebase and you are a helpful assistant who knows everything there is to know about Firebase!"
  },
});

// Load Remote Config
await template.load();

    Python

    अपने init_server_template या get_server_template टेंप्लेट फ़ंक्शन में default_config शब्दकोश जोड़ें:

    template = remote_config.init_server_template({
  'default_config': {
    'model_name': "gemini-pro",
    'generation_config': '{"stopSequences": [], "temperature": 0.7, "maxOutputTokens": 512, "topP": 0.1, "topK": 20}',
    'preamble_prompt': "I'm a developer who wants to learn about Firebase and you are a helpful assistant who knows everything there is to know about Firebase!"
  },
})

# Load Remote Config
asyncio.run(template.load())

    टेंप्लेट को शुरू करने का एक और तरीका है. इसके लिए, get_server_template फ़ंक्शन का इस्तेमाल करके, ज़रूरी सर्वर टेंप्लेट को वापस पाएं. template.to_json फ़ंक्शन का इस्तेमाल करके, इस टेंप्लेट को JSON फ़ॉर्मैट में बदला जा सकता है. इस JSON टेंप्लेट को स्थानीय तौर पर सेव किया जा सकता है. इसके बाद, init_server_template फ़ंक्शन का इस्तेमाल करके, इस JSON टेंप्लेट को शुरू किया जा सकता है.

    Java

    अपने getServerTemplate फ़ंक्शन में KeysAndValues का इस्तेमाल करके, defaultConfig ऑब्जेक्ट जोड़ें:

    // Initialize default config using KeysAndValues
KeysAndValues defaultConfig = new KeysAndValues.Builder()
                                  .put("rc_param_1", "default value 1")
                                  .put("rc_param_2", "default value 2")
                                  .build();
ServerTemplate template = rc.getServerTemplate(defaultConfig);

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

    String templateDataJSON = "{}"; // add your default template as JSON
ServerTemplate template = rc.serverTemplateBuilder()
                    .defaultConfig(defaultConfig)
                    .cachedTemplate(templateDataJSON)
                    .build();

    जाएं

    अपने InitServerTemplate या GetServerTemplate टेंप्लेट फ़ंक्शन में defaultConfig मैप जोड़ें:

    // Initialize server-side Remote Config
defaultConfig := make(map[string]any)
defaultConfig["model_name"] = "gemini-2.0-flash"

// Assume the type generationConfig has been defined
defaultConfig["generation_config"] = &generationConfig{
    StopSequences:   []string{"I hope this helps"},
    Temperature:     0.7,
    MaxOutputTokens: 512,
    TopP:            0.9,
    TopK:            30,
}

defaultConfig["preamble_prompt"] = "I'm a developer who wants to learn about Firebase and you are a helpful assistant who knows everything there is to know about Firebase!"

templateDataJSON := ""
template, err := remoteConfig.InitServerTemplate(defaultConfig, templateDataJSON)
if err != nil {
    log.Fatalln("Error initializing server template:", err)
}

// Load Remote Config
err = template.Load(ctx)
if err != nil {
    log.Fatalln("Error fetching server template:", err)
}

  3. टेंप्लेट लोड होने के बाद, टेंप्लेट का आकलन करें, ताकि टेंप्लेट से पैरामीटर और वैल्यू इंपोर्ट की जा सकें:

    Node.js

    template.evaluate() का इस्तेमाल करें:

    // Add template parameters to config
const config = template.evaluate();

    Python

    template.evaluate() का इस्तेमाल करें:

    # Add template parameters to config
config = template.evaluate()

    Java

    template.evaluate() का इस्तेमाल करें:

    // Add template parameters to config
ServerConfig config = template.evaluate();

    जाएं

    जब कोई शर्त लागू नहीं की जाती है, तब खाली आकलन कॉन्टेक्स्ट के साथ template.Evaluate() का इस्तेमाल करें:

    // An empty evaluation context means no conditions are applied.
evaluationContext := make(map[string]any)
config, err := template.Evaluate(evaluationContext)
if err != nil {
    log.Fatalln("Error evaluating template:", err)
}

  4. अगर आपने Remote Config टेंप्लेट में शर्तें सेट की हैं, तो अपनी पसंद के हिसाब से कॉन्टेक्स्ट वैल्यू तय करें और उन्हें उपलब्ध कराएं. हालांकि, ऐसा करना ज़रूरी नहीं है:

    • अगर प्रतिशत की शर्तें इस्तेमाल की जा रही हैं, तो टेंप्लेट के आकलन वाले फ़ंक्शन में, रैंडमाइज़ेशन आईडी (randomizationId, randomization_id या randomizationID) जोड़ें. यह आईडी, शर्तों का आकलन करने के लिए इस्तेमाल किया जाएगा.
    • अगर कस्टम सिग्नल का इस्तेमाल किया जा रहा है, तो एट्रिब्यूट और उनकी वैल्यू तय करें. कस्टम सिग्नल, Firebase Admin Node.js SDK v12.5.0+, Python SDK v6.7.0+, Java SDK v9.7.0+, और Go SDK v4.17.0+ के साथ उपलब्ध हैं.

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

    शर्तों के बारे में ज़्यादा जानने के लिए, शर्त वाले नियम के टाइप देखें.

    Node.js

    template.evaluate() को randomizationId और कोई भी कस्टम सिग्नल शामिल करने वाला, आकलन का कॉन्टेक्स्ट ऑब्जेक्ट पास करें:

    // Add template parameters to `config`. Evaluates the
// template and returns the parameter value assigned to
// the group assigned to the {randomizationId} and version.
const config = template.evaluate({
  randomizationId: "2ac93c28-c459-4760-963d-a3974ec26c04",
  version: "1.0",
  platform: "Android"
});

    Python

    randomization_id और किसी भी कस्टम सिग्नल वाली डिक्शनरी को template.evaluate() में पास करें:

    # Add template parameters to `config`. Evaluates the
# template and returns the parameter value assigned to
# the group assigned to the {randomization_id} and version.
config = template.evaluate({
  'randomization_id': "2ac93c28-c459-4760-963d-a3974ec26c04",
  'version': "1.0",
  'platform': "Android"
})

    Java

    KeysAndValues और randomizationId कस्टम सिग्नल वाला कॉन्टेक्स्ट बनाएं. इसके बाद, इसे template.evaluate() को पास करें:

    // Add custom signals and randomizationId
KeysAndValues context = new KeysAndValues.Builder()
                                .put("custom_signal_key", "99")
                                .put("randomizationId", "2ac93c28")
                                .build();

// Evaluate the template with signals
ServerConfig config = template.evaluate(context);

    जाएं

    template.Evaluate() को randomizationID और कोई भी कस्टम सिग्नल शामिल करने वाला, आकलन के कॉन्टेक्स्ट का मैप पास करें:

    // Add template parameters to `config`. Evaluates the
// template and returns the parameter value assigned to
// the group assigned to the {randomizationID}, version, and platform.
evaluationContext := make(map[string]any)
evaluationContext["randomizationID"] = "2ac93c28-c459-4760-963d-a3974ec26c04"
evaluationContext["version"] = "1.0"
evaluationContext["platform"] = "Android"

config, err := template.Evaluate(evaluationContext)
if err != nil {
    log.Fatalln("Error evaluating template:", err)
}

  5. इसके बाद, आकलन किए गए कॉन्फ़िगरेशन ऑब्जेक्ट से, अपनी ज़रूरत के हिसाब से पैरामीटर वैल्यू निकालें. Remote Config से वैल्यू को उम्मीद के मुताबिक फ़ॉर्मैट में बदलने के लिए, getter तरीकों का इस्तेमाल करें.

    उदाहरण के लिए, अगर आपको अपने सर्वर पर Agent Platform लागू करना है और मॉडल और मॉडल पैरामीटर बदलने हैं, तो model_name और generation_config के लिए पैरामीटर कॉन्फ़िगर किए जा सकते हैं. यहां getter के ऐसे तरीके दिए गए हैं जिनका इस्तेमाल किया जा सकता है. साथ ही, हर प्लैटफ़ॉर्म के लिए Remote Config वैल्यू ऐक्सेस करने का एक उदाहरण दिया गया है:

    Node.js

    इस्तेमाल किए जा सकने वाले गेटर तरीके:

    • बूलियन: getBoolean
    • ऑब्जेक्ट: getValue
    • नंबर: getNumber
    • स्ट्रिंग: getString

    // Replace defaults with values from Remote Config.
const generationConfig =
  JSON.parse(
    config.getString('generation_config'));

const is_ai_enabled = config.getBoolean('is_ai_enabled');

const model = config.getString('model_name');

// Generates a prompt comprised of the Remote Config
// parameter and prepends it to the user prompt
const prompt = `${config.getString('preamble_prompt')} ${req.query.prompt}`;

    Python

    इस्तेमाल किए जा सकने वाले गेटर तरीके:

    • बूलियन: get_bool
    • पूर्णांक: get_int
    • फ़्लोट: get_float
    • स्ट्रिंग: get_string
    • वैल्यू का सोर्स: get_value_source

    # Replace defaults with values from Remote Config.
generation_config = json.loads(config.get_string('generation_config'))
is_ai_enabled = config.get_bool('is_ai_enabled')
model = config.get_string('model_name')

# Generates a prompt comprised of the Remote Config
# parameter and prepends it to the user prompt.
prompt = f"{config.get_string('preamble_prompt')}{req.args.get('prompt')}"

    Java

    इस्तेमाल किए जा सकने वाले गेटर तरीके:

    • बूलियन: getBoolean
    • स्ट्रिंग: getString
    • डबल: getDouble
    • लंबा: getLong
    • वैल्यू का सोर्स: getValueSource

    // Get the model name
String modelName = config.getString("model_name");
// Get the origin of value assigned to param
ValueSource modelNameSource = config.getValueSource("model_name");

    getValueSource तरीके से ValueSource मिलता है. इससे पता चलता है कि पैरामीटर की वैल्यू का सोर्स STATIC, REMOTE या DEFAULT है.

    जाएं

    इस्तेमाल किए जा सकने वाले गेटर तरीके:

    • बूलियन: GetBoolean
    • पूर्णांक: GetInt
    • फ़्लोट: GetFloat
    • स्ट्रिंग: GetString
    • वैल्यू का सोर्स: GetValueSource

    // Replace defaults with values from Remote Config.

// Assume the type generationConfig has been defined
var genConfig generationConfig
err = json.Unmarshal([]byte(config.GetString("generation_config")), &genConfig)
if err != nil {
    log.Fatalln("Error unmarshaling generation config:", err)
}
model := config.GetString("model_name")

// Parameter created on the console
isAIEnabled := config.GetBoolean("is_ai_enabled")

// Generates a prompt comprised of the Remote Config
// parameter and prepends it to the user prompt (assume it is extracted from the request body)
userPrompt := "What is Remote Config?"
prompt := fmt.Sprintf("%s %s", config.GetString("preamble_prompt"), userPrompt)

  6. अगर आपका सर्वर, सर्वरलेस एनवायरमेंट के बजाय लंबे समय तक चलता है, तो समय-समय पर टेंप्लेट को फिर से लोड करें. उदाहरण के लिए, Node.js में setInterval या Java में java.util.Timer का इस्तेमाल करके. इससे यह पुष्टि की जा सकेगी कि Remote Config सर्वर से सबसे नया टेंप्लेट फ़ेच किया जा रहा है.

चौथा चरण: Remote Config में सर्वर के हिसाब से पैरामीटर वैल्यू सेट करना

इसके बाद, सर्वर Remote Config टेंप्लेट बनाएं. साथ ही, अपने ऐप्लिकेशन में इस्तेमाल करने के लिए पैरामीटर और वैल्यू कॉन्फ़िगर करें.

सर्वर के हिसाब से Remote Config टेंप्लेट बनाने का तरीका यहां बताया गया है:

  1. Firebase console में, DevOps और जुड़ाव > रिमोट कॉन्फ़िगरेशन > पैरामीटर पेज पर जाएं.

  2. पेज पर सबसे ऊपर मौजूद, क्लाइंट/सर्वर सिलेक्टर से, सर्वर चुनें.

  3. अपने ऐप्लिकेशन में तय किए गए पैरामीटर के नाम और डेटा टाइप के हिसाब से, Remote Config पैरामीटर तय करें और उनकी वैल्यू दें. जब टेंप्लेट को फ़ेच और उसका आकलन किया जाता है और इन वैल्यू को अपने वैरिएबल को असाइन किया जाता है, तब ये वैल्यू, अपने सर्वर ऐप्लिकेशन को कॉन्फ़िगर करें में सेट किए गए डिफ़ॉल्ट कॉन्फ़िगरेशन (defaultConfig या default_config) को बदल देंगी.

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

  5. पैरामीटर जोड़ने के बाद, बदलाव पब्लिश करें पर क्लिक करें.

  6. बदलावों की समीक्षा करें और फिर से बदलाव पब्लिश करें पर क्लिक करें.

पांचवां चरण: Cloud Functions for Firebase या Cloud Run का इस्तेमाल करके डिप्लॉय करना

अगर आपका सर्वर ऐप्लिकेशन हल्का है और इवेंट पर आधारित है, तो आपको Cloud Functions for Firebase का इस्तेमाल करके अपना कोड डिप्लॉय करना चाहिए. उदाहरण के लिए, मान लें कि आपके पास एक ऐसा ऐप्लिकेशन है जिसमें जनरेटिव एआई एपीआई (जैसे, Google AI या Agent Platform) की मदद से, किरदार के डायलॉग जनरेट किए जाते हैं. इस मामले में, एलएलएम को सेवा देने वाले लॉजिक को ऐसे फ़ंक्शन में होस्ट किया जा सकता है जिसे आपका ऐप्लिकेशन ज़रूरत के हिसाब से कॉल करता है.

अगर आपको सर्वर-रेंडर किया गया वेब ऐप्लिकेशन बनाना है, तो App Hosting में लोकप्रिय वेब फ़्रेमवर्क इस्तेमाल किए जा सकते हैं.

अगर ऐसा नहीं है, तो Cloud Run पर जाएं. Cloud Run के साथ अपने सर्वर ऐप्लिकेशन को डिप्लॉय करने के लिए, अपनी भाषा में क्विकस्टार्ट गाइड देखें:

Cloud Run और Cloud Functions for Firebase के सबसे सही इस्तेमाल के उदाहरणों के बारे में ज़्यादा जानने के लिए, Cloud Functions for Firebase बनाम Cloud Run: किसका इस्तेमाल कब करना चाहिए लेख पढ़ें.

अगले चरण