अपना ऐप्लिकेशन कनेक्ट करें और प्रोटोटाइप बनाना शुरू करें

Firebase Local Emulator Suite का इस्तेमाल शुरू करने से पहले, पक्का करें कि आपने Firebase प्रोजेक्ट बना लिया हो, डेवलपमेंट एनवायरमेंट सेट अप कर लिया हो, और अपने प्लैटफ़ॉर्म के लिए Firebase SDK टूल चुनकर इंस्टॉल कर लिए हों. इसके लिए, अपने प्लैटफ़ॉर्म के लिए Get started with Firebase विषयों को देखें. जैसे: Apple, Android या Web.

प्रोटोटाइप बनाना और परफ़ॉर्मेंस की जांच करना

Local Emulator Suite में, कई प्रॉडक्ट एम्युलेटर शामिल होते हैं. इनके बारे में, Introduction to Firebase Local Emulator Suite लेख में बताया गया है. प्रोटोटाइप बनाने और परफ़ॉर्मेंस की जांच करने के लिए, अलग-अलग एम्युलेटर के साथ-साथ, एम्युलेटर के कॉम्बिनेशन का इस्तेमाल किया जा सकता है. यह इस बात पर निर्भर करता है कि प्रोडक्शन में Firebase के किन प्रॉडक्ट का इस्तेमाल किया जा रहा है.

इस विषय के लिए, Local Emulator Suite वर्कफ़्लो के बारे में बताने के लिए, मान लें कि आप किसी ऐसे ऐप्लिकेशन पर काम कर रहे हैं जो प्रॉडक्ट के सामान्य कॉम्बिनेशन का इस्तेमाल करता है. जैसे: Firebase डेटाबेस और उस डेटाबेस पर होने वाली कार्रवाइयों से ट्रिगर होने वाले क्लाउड फ़ंक्शन.

अपने Firebase प्रोजेक्ट को स्थानीय तौर पर शुरू करने के बाद, Local Emulator Suite का इस्तेमाल करके डेवलपमेंट साइकल में आम तौर पर तीन चरण शामिल होते हैं:

1. एम्युलेटर और Emulator Suite UI के साथ इंटरैक्टिव तरीके से प्रोटोटाइप बनाना.

2. अगर डेटाबेस एम्युलेटर या Cloud Functions एम्युलेटर का इस्तेमाल किया जा रहा है, तो अपने ऐप्लिकेशन को एम्युलेटर से कनेक्ट करने के लिए, एक बार का चरण पूरा करें.

3. एम्युलेटर और कस्टम स्क्रिप्ट की मदद से, अपने टेस्ट को ऑटोमेट करना.

Firebase प्रोजेक्ट को स्थानीय तौर पर शुरू करना

पक्का करें कि आपने सीएलआई इंस्टॉल कर लिया हो या उसे सबसे नए वर्शन में अपडेट कर लिया हो.

curl -sL firebase.tools | bash

अगर आपने अब तक ऐसा नहीं किया है, तो मौजूदा वर्किंग डायरेक्ट्री को Firebase प्रोजेक्ट के तौर पर शुरू करें. इसके लिए, स्क्रीन पर दिखने वाले निर्देशों का पालन करें. साथ ही, यह भी बताएं कि आप Cloud Functions और या तो Cloud Firestore या Realtime Database का इस्तेमाल कर रहे हैं:

firebase init

अब आपकी प्रोजेक्ट डायरेक्ट्री में, Firebase कॉन्फ़िगरेशन फ़ाइलें, डेटाबेस के लिए a Firebase Security Rules परिभाषा वाली फ़ाइल, क्लाउड फ़ंक्शन कोड वाली a functions डायरेक्ट्री , और अन्य ज़रूरी फ़ाइलें शामिल होंगी.

इंटरैक्टिव तरीके से प्रोटोटाइप बनाना

Local Emulator Suite को नई सुविधाओं के प्रोटोटाइप तेज़ी से बनाने के लिए डिज़ाइन किया गया है, साथ ही, Suite का बिल्ट-इन यूज़र इंटरफ़ेस (यूआई), प्रोटोटाइप बनाने के सबसे काम के टूल में से एक है. यह कुछ-कुछ, Firebase कंसोल को स्थानीय तौर पर चलाने जैसा है.

Emulator Suite UI का इस्तेमाल करके, डेटाबेस के डिज़ाइन को बेहतर बनाया जा सकता है. साथ ही, क्लाउड फ़ंक्शन वाले अलग-अलग डेटाफ़्लो आज़माए जा सकते हैं, Security Rules में किए गए बदलावों का आकलन किया जा सकता है, और यह पुष्टि करने के लिए लॉग देखे जा सकते हैं कि आपके बैक-एंड की सेवाएं कैसा परफ़ॉर्म कर रही हैं. इसके अलावा, और भी कई काम किए जा सकते हैं. इसके बाद, अगर आपको फिर से शुरू करना है, तो बस अपना डेटाबेस मिटाएं और नए डिज़ाइन आइडिया के साथ शुरुआत करें.

जब आप Local Emulator Suite शुरू करते हैं, तो यह सब उपलब्ध होता है:

firebase emulators:start

अपने काल्पनिक ऐप्लिकेशन का प्रोटोटाइप बनाने के लिए, डेटाबेस में टेक्स्ट एंट्री में बदलाव करने के लिए, एक बुनियादी क्लाउड फ़ंक्शन सेट अप करें और उसकी जांच करें. साथ ही, उसे ट्रिगर करने के लिए, उस डेटाबेस को Emulator Suite UI में बनाएं और उसमें डेटा भरें.

1. अपनी प्रोजेक्ट डायरेक्ट्री में मौजूद functions/index.js फ़ाइल में बदलाव करके, डेटाबेस में लिखने की कार्रवाई से ट्रिगर होने वाला क्लाउड फ़ंक्शन बनाएं. मौजूदा फ़ाइल के कॉन्टेंट को, यहां दिए गए स्निपेट से बदलें. यह फ़ंक्शन `messages` कलेक्शन में मौजूद दस्तावेज़ों में होने वाले बदलावों को सुनता है. साथ ही, दस्तावेज़ के `original` फ़ील्ड के कॉन्टेंट को अपरकेस में बदलता है और नतीजे को उस दस्तावेज़ के `uppercase` फ़ील्ड में सेव करता है.

  const functions = require('firebase-functions/v1');

  exports.makeUppercase = functions.firestore.document('/messages/{documentId}')
      .onCreate((snap, context) => {
        const original = snap.data().original;
        console.log('Uppercasing', context.params.documentId, original);
        const uppercase = original.toUpperCase();
        return snap.ref.set({uppercase}, {merge: true});
      });
  

2. Local Emulator Suite को firebase emulators:start की मदद से लॉन्च करें. Cloud Functions और डेटाबेस एम्युलेटर शुरू हो जाते हैं. इन्हें आपस में काम करने के लिए, अपने-आप कॉन्फ़िगर किया जाता है.
3. अपने ब्राउज़र में http://localhost:4000 पर जाकर, यूज़र इंटरफ़ेस (यूआई) देखें. यूज़र इंटरफ़ेस (यूआई) के लिए, पोर्ट 4000 डिफ़ॉल्ट तौर पर सेट होता है. हालांकि, Firebase सीएलआई से मिलने वाले टर्मिनल मैसेज देखें. उपलब्ध एम्युलेटर का स्टेटस देखें. हमारे मामले में, Cloud Functions और Cloud Firestore एम्युलेटर चालू होंगे.
   यूज़र इंटरफ़ेस (यूआई) का मुख्य पेज देखें
4. यूज़र इंटरफ़ेस (यूआई) में, Firestore > डेटा टैब पर, कलेक्शन शुरू करें पर क्लिक करें. इसके बाद, निर्देशों का पालन करके, messages कलेक्शन में एक नया दस्तावेज़ बनाएं. इसमें फ़ील्ड का नाम original और वैल्यू test होनी चाहिए. इससे हमारा क्लाउड फ़ंक्शन ट्रिगर होता है. ध्यान दें कि कुछ ही समय में, एक नया uppercase फ़ील्ड दिखता है. इसमें स्ट्रिंग "TEST" होती है.
   कलेक्शन बनाने का तरीका देखें फ़ंक्शन से मिलने वाले अपडेट देखें
5. Firestore > अनुरोध टैब पर, एम्युलेट किए गए अपने डेटाबेस के लिए किए गए अनुरोधों की जांच करें. इनमें, उन अनुरोधों को पूरा करने के लिए, Firebase Security Rules आकलन शामिल हैं.
6. लॉग टैब देखें, ताकि यह पुष्टि की जा सके कि डेटाबेस को अपडेट करते समय, आपके फ़ंक्शन में कोई गड़बड़ी नहीं हुई.

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

अपने ऐप्लिकेशन को एम्युलेटर से कनेक्ट करना

इंटरैक्टिव तरीके से प्रोटोटाइप बनाने में अच्छी प्रोग्रेस करने और डिज़ाइन तय कर लेने के बाद, अपने ऐप्लिकेशन में डेटाबेस ऐक्सेस करने वाला कोड जोड़ा जा सकता है. इसके लिए, सही एसडीके का इस्तेमाल करें. यह पुष्टि करने के लिए कि आपके ऐप्लिकेशन का व्यवहार सही है, आपको Emulator Suite के यूज़र इंटरफ़ेस (यूआई) में, डेटाबेस टैब और फ़ंक्शन के लिए, लॉग टैब का इस्तेमाल करना होगा.Emulator Suite UI

ध्यान रखें कि Local Emulator Suite स्थानीय डेवलपमेंट टूल है. प्रोडक्शन डेटाबेस में लिखने की कार्रवाइयों से, स्थानीय तौर पर प्रोटोटाइप किए जा रहे फ़ंक्शन ट्रिगर नहीं होंगे.

अपने ऐप्लिकेशन को डेटाबेस में लिखने की कार्रवाइयां करने के लिए, आपको अपने टेस्ट क्लास या ऐप्लिकेशन में मौजूद कॉन्फ़िगरेशन को Cloud Firestore एम्युलेटर पर पॉइंट करना होगा.

// 10.0.2.2 is the special IP address to connect to the 'localhost' of
// the host computer from an Android emulator.
val firestore = Firebase.firestore
firestore.useEmulator("10.0.2.2", 8080)

firestore.firestoreSettings = firestoreSettings {
    isPersistenceEnabled = false
}
EmulatorSuite.kt

// 10.0.2.2 is the special IP address to connect to the 'localhost' of
// the host computer from an Android emulator.
FirebaseFirestore firestore = FirebaseFirestore.getInstance();
firestore.useEmulator("10.0.2.2", 8080);

FirebaseFirestoreSettings settings = new FirebaseFirestoreSettings.Builder()
        .setPersistenceEnabled(false)
        .build();
firestore.setFirestoreSettings(settings);
EmulatorSuite.java

let settings = Firestore.firestore().settings
settings.host = "127.0.0.1:8080"
settings.cacheSettings = MemoryCacheSettings()
settings.isSSLEnabled = false
Firestore.firestore().settings = settings
ViewController.swift

FirebaseFirestore db = FirebaseFirestore.DefaultInstance;
// Connects to the Firestore Emulator running on port 8080
db.Settings.Host = "127.0.0.1:8080";
db.Settings.SslEnabled = false;

import { getFirestore, connectFirestoreEmulator } from "firebase/firestore";

// firebaseApps previously initialized using initializeApp()
const db = getFirestore();
connectFirestoreEmulator(db, '127.0.0.1', 8080);
fs_emulator_connect.js

// Firebase previously initialized using firebase.initializeApp().
var db = firebase.firestore();
if (location.hostname === "localhost") {
  db.useEmulator("127.0.0.1", 8080);
}
emulator-suite.js

कस्टम स्क्रिप्ट की मदद से, अपने टेस्ट को ऑटोमेट करना

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

firebase emulators:exec "./testdir/test.sh"

अलग-अलग एम्युलेटर के बारे में ज़्यादा जानकारी पाना

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

• प्रोटोटाइप बनाने के अपने वर्कफ़्लो में, Authentication एम्युलेटर जोड़ना
• Realtime Database एम्युलेटर की सुविधाओं के बारे में ज़्यादा जानना
• Cloud Storage for Firebase एम्युलेटर की सुविधाओं के बारे में ज़्यादा जानना
• Cloud Firestore एम्युलेटर की सुविधाओं के बारे में ज़्यादा जानना
• अपने ऐप्लिकेशन को Cloud Functions एम्युलेटर से कनेक्ट करना
• एम्युलेटर की मदद से, बिलिंग की लागत कम करते हुए, Firebase Extensions का आकलन करनाExtensions

आगे क्या करना है?

ऊपर लिंक किए गए, खास एम्युलेटर से जुड़े विषय ज़रूर पढ़ें. इसके बाद:

• चुने गए वीडियो और सिलसिलेवार तरीके से निर्देश देने वाले उदाहरणों के लिए, Firebase Emulators ट्रेनिंग प्लेलिस्ट देखें.
• Security Rules की टेस्टिंग और Firebase Test SDK के इस्तेमाल के बेहतर तरीके जानें: Security Rules की जांच करना (Cloud Firestore) , Security Rules की जांच करना (Realtime Database), और Security Rules की जांच करना (Cloud Storage for Firebase).