Firebase Cloud Functions के साथ जेनकिट तैयार करने की सुविधा

Firebase Genkit में एक ऐसा प्लगिन शामिल है जो आपके फ़्लो को Firebase Cloud Functions पर डिप्लॉय करने में मदद करता है. उदाहरण के तौर पर, इस पेज पर आपको Firebase में डिफ़ॉल्ट सैंपल फ़्लो को डिप्लॉय करने की प्रोसेस के बारे में जानकारी दी गई है.

फ़्लो को Cloud फ़ंक्शन के तौर पर डिप्लॉय करना

1. ज़रूरी टूल इंस्टॉल करें:

   1. पक्का करें कि Node.js का 20 या इसके बाद वाला वर्शन इस्तेमाल किया जा रहा है. जांच करने के लिए, node --version चलाएं.

   2. Firebase सीएलआई इंस्टॉल करें.

2. Firebase कंसोल का इस्तेमाल करके नया Firebase प्रोजेक्ट बनाएं या कोई मौजूदा Firebase प्रोजेक्ट चुनें.

   प्रोजेक्ट को ब्लेज़ प्लान में अपग्रेड करें, जो क्लाउड फ़ंक्शन डिप्लॉय करने के लिए ज़रूरी है.

3. Firebase सीएलआई की मदद से लॉग इन करें:

   firebase login
   firebase login --reauth # alternative, if necessary
   firebase login --no-localhost # if running in a remote shell
   

4. नई प्रोजेक्ट डायरेक्ट्री बनाएं:

   export PROJECT_ROOT=~/tmp/genkit-firebase-project1
   mkdir -p $PROJECT_ROOT
   

5. फ़ोल्डर में Genkit के साथ Firebase प्रोजेक्ट शुरू करने के लिए:

   cd $PROJECT_ROOT
   firebase init genkit
   

   • वह प्रोजेक्ट चुनें जिसे आपने पहले बनाया था.
   • मॉडल की सेवा देने वाली उस कंपनी को चुनें जिसका आपको इस्तेमाल करना है.

   बचे हुए प्रॉम्प्ट के लिए, डिफ़ॉल्ट सेटिंग स्वीकार करें. genkit टूल, सैंपल के तौर पर कुछ सोर्स फ़ाइलें बनाएगा, ताकि आप अपने एआई फ़्लो डेवलप कर सकें. हालांकि, इस ट्यूटोरियल के बाकी हिस्सों के लिए, आपको सिर्फ़ सैंपल फ़्लो डिप्लॉय करना होगा.

6. अपने Cloud Function में एपीआई क्रेडेंशियल उपलब्ध कराएं. आपने मॉडल बनाने वाली जो कंपनी चुनी है उसके आधार पर, इनमें से कोई एक काम करें:

   Gemini (Google का एआई)

   1. पक्का करें कि Google का एआई आपके इलाके में उपलब्ध हो.

   2. Google AI Studio की मदद से, Gemini API के लिए एपीआई पासकोड जनरेट करें.

   3. GOOGLE_GENAI_API_KEY एनवायरमेंट वैरिएबल को अपनी कुंजी पर सेट करें:

      export GOOGLE_GENAI_API_KEY=<your API key>
      

   4. src/index.ts में बदलाव करें और मौजूदा इंपोर्ट के बाद ये चीज़ें जोड़ें:

   import {defineSecret} from "firebase-functions/params";
   defineSecret("GOOGLE_GENAI_API_KEY");
   

   इस फ़ंक्शन को डिप्लॉय करने पर, आपकी एपीआई पासकोड, Cloud Secret Manager में सेव हो जाएगा और Cloud Functions एनवायरमेंट में उपलब्ध होगा.

   Gemini (Vertex AI)

   1. Cloud Console में, अपने Firebase प्रोजेक्ट के लिए Vertex AI API चालू करें.

   2. आईएएम पेज पर, पक्का करें कि डिफ़ॉल्ट कंप्यूट सेवा खाते को Vertex AI User की भूमिका दी गई हो.

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

      export GCLOUD_PROJECT=<your project ID>
      export GCLOUD_LOCATION=us-central1
      gcloud auth application-default login
      

   इस ट्यूटोरियल के लिए आपको सिर्फ़ मॉडल उपलब्ध कराने वाली कंपनी के लिए सीक्रेट सेट अप करना होगा. हालांकि, आम तौर पर आपको अपने फ़्लो में इस्तेमाल की जाने वाली हर सेवा के लिए कुछ ऐसा ही करना होगा.

7. अगर किसी वेब ऐप्लिकेशन से फ़्लो को ऐक्सेस किया जाता है (यह काम अगले सेक्शन में किया जाएगा), तो httpsOptions पैरामीटर में, सीओआरएस नीति सेट करें:

   export const menuSuggestionFlow = onFlow(
     {
       name: "menuSuggestionFlow",
       // ...
       httpsOptions: {cors: true}, // Add this line.
     },
     async (subject) => {
       // ...
     }
   );
   

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

8. ज़रूरी नहीं: डेवलपर यूज़र इंटरफ़ेस (यूआई) में अपना फ़्लो आज़माएं:

   1. यूज़र इंटरफ़ेस (यूआई) शुरू करें:

      cd $PROJECT_ROOT/functions
      genkit start
      

   2. डेवलपर यूज़र इंटरफ़ेस (यूआई) (http://localhost:4000/) में, फ़्लो चलाएं:

      1. menuसुझावFlow पर क्लिक करें.

      2. इनपुट JSON टैब पर, मॉडल के लिए कोई विषय बताएं:

         "AI app developers"
         

      3. Auth JSON टैब पर, सिम्युलेट किया गया पुष्टि करने वाला ऑब्जेक्ट दें:

         {
           "uid": 0,
           "email_verified": true
         }
         

      4. Run पर क्लिक करें.

9. अगर अब तक सब कुछ उम्मीद के मुताबिक काम कर रहा है, तो फ़्लो को डिप्लॉय किया जा सकता है:

   cd $PROJECT_ROOT
   firebase deploy --only functions
   

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

डिप्लॉय किए गए फ़्लो को आज़माएं

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

डिफ़ॉल्ट सैंपल फ़्लो में, अनुमति देने से जुड़ी नीति इस तरह की होती है:

firebaseAuth((user) => {
  if (!user.email_verified) {
    throw new Error('Verified email required to run flow');
  }
});

इस नीति में firebaseAuth() हेल्पर का इस्तेमाल किया जाता है, ताकि आपके ऐप्लिकेशन के उन उपयोगकर्ताओं को ही ऐक्सेस दिया जा सके जिन्होंने रजिस्टर किया है और जिनके पास पुष्टि किए गए ईमेल पते हैं. क्लाइंट-साइड पर, आपको Authorization: Bearer हेडर को ऐसे Firebase आईडी टोकन पर सेट करना होगा जो आपकी नीति के मुताबिक हो. Cloud Functions क्लाइंट SDK टूल, कॉल करने लायक फ़ंक्शन के ऐसे तरीके उपलब्ध कराता है जिनकी मदद से इसे अपने-आप किया जा सकता है.

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

1. Firebase कंसोल के प्रोजेक्ट सेटिंग सेक्शन में, नया वेब ऐप्लिकेशन जोड़ें. इसके लिए, होस्टिंग सेट अप करने का विकल्प चुनें.

2. Firebase कंसोल के पुष्टि करना सेक्शन में, Google की सेवा देने वाली कंपनी को चालू करें. इस उदाहरण में, आपको सेवा देने वाली कंपनी का इस्तेमाल करना है.

3. अपनी प्रोजेक्ट डायरेक्ट्री में, Firebase होस्टिंग सेट अप करें. यहां सैंपल ऐप्लिकेशन डिप्लॉय किया जाएगा:

   cd $PROJECT_ROOT
   firebase init hosting
   

   सभी प्रॉम्प्ट के लिए डिफ़ॉल्ट सेटिंग स्वीकार करें.

4. public/index.html को इनसे बदलें:

   <!doctype html>
   <html>
     <head>
       <title>Genkit demo</title>
     </head>
     <body>
       <div id="signin" hidden>
         <button id="signinBtn">Sign in with Google</button>
       </div>
       <div id="callGenkit" hidden>
         Subject: <input type="text" id="subject" />
         <button id="suggestMenuItem">Suggest a menu theme</button>
         <p id="menuItem"></p>
       </div>
       <script type="module">
         import { initializeApp } from 'https://www.gstatic.com/firebasejs/10.10.0/firebase-app.js';
         import {
           getAuth,
           onAuthStateChanged,
           GoogleAuthProvider,
           signInWithPopup,
         } from 'https://www.gstatic.com/firebasejs/10.10.0/firebase-auth.js';
         import {
           getFunctions,
           httpsCallable,
         } from 'https://www.gstatic.com/firebasejs/10.10.0/firebase-functions.js';
   
         const firebaseConfig = await fetch('/__/firebase/init.json');
         initializeApp(await firebaseConfig.json());
   
         async function generateMenuItem() {
           const menuSuggestionFlow = httpsCallable(
             getFunctions(),
             'menuSuggestionFlow'
           );
           const subject = document.querySelector('#subject').value;
           const response = await menuSuggestionFlow(subject);
           document.querySelector('#menuItem').innerText = response.data;
         }
   
         function signIn() {
           signInWithPopup(getAuth(), new GoogleAuthProvider());
         }
   
         document
           .querySelector('#signinBtn')
           .addEventListener('click', signIn);
         document
           .querySelector('#suggestMenuItem')
           .addEventListener('click', generateMenuItem);
   
         const signinEl = document.querySelector('#signin');
         const genkitEl = document.querySelector('#callGenkit');
   
         onAuthStateChanged(getAuth(), (user) => {
           if (!user) {
             signinEl.hidden = false;
             genkitEl.hidden = true;
           } else {
             signinEl.hidden = true;
             genkitEl.hidden = false;
           }
         });
       </script>
     </body>
   </html>
   

5. वेब ऐप्लिकेशन और Cloud Function को डिप्लॉय करें:

   cd $PROJECT_ROOT
   firebase deploy
   

deploy निर्देश से प्रिंट किए गए यूआरएल पर जाकर वेब ऐप्लिकेशन खोलें. इस ऐप्लिकेशन में आपको Google खाते से साइन इन करना होगा. इसके बाद, एंडपॉइंट के लिए अनुरोध किए जा सकते हैं.

Firebase लोकल एम्युलेटर सुइट का इस्तेमाल करके डेवलप करना

Firebase, लोकल डेवलपमेंट के लिए एम्युलेटर का सुइट उपलब्ध कराता है. इसका इस्तेमाल, Genkit के साथ किया जा सकता है.

Firebase Emulator Suite के साथ Genkit का इस्तेमाल करने के लिए, इस तरह के Firebase एम्युलेटर को शुरू करें:

GENKIT_ENV=dev firebase emulators:start --inspect-functions

यह आपके कोड को एम्युलेटर में चलाएगा और Genkit फ़्रेमवर्क को डेवलेपमेंट मोड में चलाएगा, जो Genkit प्रतिबिंब एपीआई को लॉन्च और दिखाता है, लेकिन Dev यूज़र इंटरफ़ेस (यूआई) को नहीं.

इसके बाद, Firebase एम्युलेटर में चल रहे अपने कोड से कनेक्ट करने के लिए, --attach विकल्प का इस्तेमाल करके Genkit Dev यूज़र इंटरफ़ेस (यूआई) लॉन्च करें:

genkit start --attach http://localhost:3100 --port 4001

Dev यूज़र इंटरफ़ेस (यूआई) में Firestore से ट्रेस देखने के लिए, 'जांच करें' टैब पर जाएं और "Dev/Prod" स्विच को टॉगल करें. "प्रोडक्शन" पर टॉगल करने पर, यह फ़ायरस्टोर से ट्रेस लोड करेगा.