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


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

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

Local Emulator Suite में, प्रॉडक्ट के कई एम्युलेटर शामिल हैं. इनके बारे में, Introduction to 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 की मदद से लॉन्च करें. 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 में मौजूद अलग-अलग एम्युलेटर के बारे में जानकारी देखें. इसमें, सर्वर-साइड ऐप्लिकेशन डेवलपमेंट के लिए इनका इस्तेमाल करने का तरीका भी शामिल है:

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

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