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


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

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

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

Firebase डेटाबेस और फ़ंक्शन एम्युलेटर के बीच इंटरैक्शन
डेटाबेस और Cloud Functions एम्युलेटर, पूरे Local Emulator Suite के हिस्से के तौर पर.

इस विषय के लिए, 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` फ़ील्ड में सेव करता है.
    2.   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 की मदद से लॉन्च करें. The 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 UI

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

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

Kotlin
// 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
}
Java
// 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);
Swift
let settings = Firestore.firestore().settings
settings.host = "127.0.0.1:8080"
settings.cacheSettings = MemoryCacheSettings()
settings.isSSLEnabled = false
Firestore.firestore().settings = settings

Web

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

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

Web

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

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

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

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

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

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

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

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