Firebase के लिए Cloud Functions का इस्तेमाल करके फ़्लो डिप्लॉय करना

'Firebase के लिए Cloud Functions' में एक onCallGenkit तरीका है, जिसकी मदद से Genkit ऐक्शन (जैसे, फ़्लो) के साथ, कॉल किया जा सकने वाला फ़ंक्शन तुरंत बनाया जा सकता है. इन फ़ंक्शन को genkit/beta/clientया Functions क्लाइंट SDK टूल का इस्तेमाल करके कॉल किया जा सकता है. यह टूल, पुष्टि करने की जानकारी अपने-आप जोड़ देता है.

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

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

1. Firebase प्रोजेक्ट सेट अप करना

अगर आपके पास पहले से, TypeScript Cloud Functions के साथ सेट अप किया गया Firebase प्रोजेक्ट नहीं है, तो यह तरीका अपनाएं:

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

2. प्रोजेक्ट को Blaze प्लान पर अपग्रेड करें. Cloud Functions को डिप्लॉय करने के लिए, ऐसा करना ज़रूरी है.

3. Firebase CLI इंस्टॉल करें.

4. Firebase CLI से लॉग इन करें:

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

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

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

6. डायरेक्ट्री में Firebase प्रोजेक्ट को शुरू करने के लिए:

   cd $PROJECT_ROOT
   firebase init genkit

   इस पेज के बाकी हिस्से में यह माना गया है कि आपने अपने फ़ंक्शन, TypeScript में लिखने का फ़ैसला लिया है. हालांकि, JavaScript का इस्तेमाल करने पर भी Genkit फ़्लो को डिप्लॉय किया जा सकता है.

2. onCallGenkit में फ़्लो को रैप करना

Cloud Functions की मदद से Firebase प्रोजेक्ट सेट अप करने के बाद, प्रोजेक्ट की functions/src डायरेक्ट्री में फ़्लो की परिभाषाएं कॉपी की जा सकती हैं या लिखी जा सकती हैं. साथ ही, उन्हें index.ts में एक्सपोर्ट किया जा सकता है.

अपने फ़्लो को डिप्लॉय करने के लिए, आपको उन्हें onCallGenkit में रैप करना होगा. इस तरीके में, सामान्य onCall की सभी सुविधाएं मौजूद होती हैं. यह अपने-आप, स्ट्रीमिंग और JSON रिस्पॉन्स, दोनों के साथ काम करता है.

मान लें कि आपके पास यह फ़्लो है:

const generatePoemFlow = ai.defineFlow(
  {
    name: "generatePoem",
    inputSchema: z.string(),
    outputSchema: z.string(),
  },
  async (subject: string) => {
    const { text } = await ai.generate(`Compose a poem about ${subject}.`);
    return text;
  }
);

onCallGenkit का इस्तेमाल करके, इस फ़्लो को कॉल किए जा सकने वाले फ़ंक्शन के तौर पर दिखाया जा सकता है:

import { onCallGenkit } from 'firebase-functions/https';

export generatePoem = onCallGenkit(generatePoemFlow);

अनुमति से जुड़ी नीति तय करना

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

export const generatePoem = onCallGenkit({
  authPolicy: (auth) => auth?.token?.email_verified,
}, generatePoemFlow);

इस सैंपल में, पुष्टि करने की नीति के तौर पर मैन्युअल फ़ंक्शन का इस्तेमाल किया गया है. इसके अलावा, https library, signedIn() और hasClaim() हेल्पर को एक्सपोर्ट करती है. यहां वही कोड दिया गया है, जिसमें इनमें से किसी एक हेल्पर का इस्तेमाल किया गया है:

import { hasClaim } from 'firebase-functions/https';

export const generatePoem = onCallGenkit({
  authPolicy: hasClaim('email_verified'),
}, generatePoemFlow);

डिप्लॉय किए गए फ़्लो के लिए एपीआई क्रेडेंशियल उपलब्ध कराना

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

इस उदाहरण के लिए, चुने गए मॉडल की सेवा देने वाली कंपनी के आधार पर, इनमें से कोई एक काम करें:

Gemini (Google का एआई)

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

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

3. Cloud Secret Manager में अपनी एपीआई पासकोड सेव करने के लिए:

   firebase functions:secrets:set GOOGLE_GENAI_API_KEY

   यह चरण ज़रूरी है, ताकि आपकी एपीआई कुंजी गलती से लीक न हो. इस कुंजी से, मेज़र की जाने वाली सेवा का ऐक्सेस मिलता है.

   गोपनीय जानकारी मैनेज करने के बारे में ज़्यादा जानने के लिए, संवेदनशील कॉन्फ़िगरेशन जानकारी को सेव और ऐक्सेस करना देखें.

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

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

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

   export const generatePoem = onCallGenkit({
     secrets: [googleAIapiKey]
   }, generatePoemFlow);
   

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

Gemini (Vertex AI)

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

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

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

ऐप्लिकेशन की जांच करने की नीति जोड़ना

Firebase App Check, पहले से मौजूद पुष्टि करने के तरीके का इस्तेमाल करके यह पुष्टि करता है कि आपके एपीआई को सिर्फ़ आपके ऐप्लिकेशन से कॉल किया जा रहा है. onCallGenkit, ऐप्लिकेशन की जांच करने की नीति को लागू करने के लिए, एलान करने की सुविधा के साथ काम करता है.

export const generatePoem = onCallGenkit({
  enforceAppCheck: true,
  // Optional. Makes App Check tokens only usable once. This adds extra security
  // at the expense of slowing down your app to generate a token for every API
  // call
  consumeAppCheckToken: true,
}, generatePoemFlow);

सीओआरएस नीति सेट करना

कॉल किए जा सकने वाले फ़ंक्शन, डिफ़ॉल्ट रूप से किसी भी डोमेन को आपके फ़ंक्शन को कॉल करने की अनुमति देते हैं. अगर आपको उन डोमेन को पसंद के मुताबिक बनाना है जिन पर यह सुविधा काम कर सकती है, तो cors विकल्प का इस्तेमाल करें. सही पुष्टि (खास तौर पर ऐप्लिकेशन की जांच) के साथ, सीओआरएस की ज़रूरत अक्सर नहीं होती.

export const generatePoem = onCallGenkit({
  cors: 'mydomain.com',
}, generatePoemFlow);

पूरा उदाहरण

ऊपर बताए गए सभी बदलाव करने के बाद, डिप्लॉय किया जा सकने वाला फ़्लो कुछ ऐसा दिखता है:

import { genkit } from 'genkit';
import { onCallGenkit, hasClaim } from 'firebase-functions/https';
import { defineSecret } from 'firebase-functions/params';

const apiKey = defineSecret("GOOGLE_GENAI_API_KEY");

const generatePoemFlow = ai.defineFlow({
  name: "generatePoem",
  inputSchema: z.string(),
  outputSchema: z.string(),
}, async (subject: string) => {
  const { text } = await ai.generate(`Compose a poem about ${subject}.`);
  return text;
});

export const generateFlow = onCallGenkit({
  secrets: [apiKey],
  authPolicy: hasClaim("email_verified"),
  enforceAppCheck: true,
}, generatePoemFlow);

3. Firebase में फ़्लो डिप्लॉय करना

onCallGenkit का इस्तेमाल करके फ़्लो तय करने के बाद, उन्हें उसी तरह डिप्लॉय किया जा सकता है जिस तरह अन्य Cloud Functions को डिप्लॉय किया जाता है:

cd $PROJECT_ROOT
firebase deploy --only functions

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

ज़रूरी नहीं: डिप्लॉय किए गए फ़्लो को आज़माना

अपने फ़्लो एंडपॉइंट को आज़माने के लिए, यहां दिया गया छोटा उदाहरण वेब ऐप्लिकेशन डिप्लॉय करें:

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="generatePoem">Compose a poem on this subject</button>
         <p id="generatedPoem"></p>
       </div>
       <script type="module">
         import { initializeApp } from "https://www.gstatic.com/firebasejs/11.0.1/firebase-app.js";
         import {
           getAuth,
           onAuthStateChanged,
           GoogleAuthProvider,
           signInWithPopup,
         } from "https://www.gstatic.com/firebasejs/11.0.1/firebase-auth.js";
         import {
           getFunctions,
           httpsCallable,
         } from "https://www.gstatic.com/firebasejs/11.0.1/firebase-functions.js";
   
         const firebaseConfig = await fetch("/__/firebase/init.json");
         initializeApp(await firebaseConfig.json());
   
         async function generatePoem() {
           const poemFlow = httpsCallable(getFunctions(), "generatePoem");
           const subject = document.querySelector("#subject").value;
           const response = await poemFlow(subject);
           document.querySelector("#generatedPoem").innerText = response.data;
         }
   
         function signIn() {
           signInWithPopup(getAuth(), new GoogleAuthProvider());
         }
   
         document.querySelector("#signinBtn").addEventListener("click", signIn);
         document
           .querySelector("#generatePoem")
           .addEventListener("click", generatePoem);
   
         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 फ़ंक्शन को डिप्लॉय करें:

   cd $PROJECT_ROOT
   firebase deploy

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

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

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

cd $PROJECT_ROOT/functions
npx genkit start -- npx tsx --watch src/index.ts

या

cd $PROJECT_ROOT/functions
npm run genkit:start

अब genkit start कमांड से प्रिंट किए गए यूआरएल पर जाकर, उसे ऐक्सेस किया जा सकता है.

ज़रूरी नहीं: Firebase Local Emulator Suite का इस्तेमाल करके डेवलप करना

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

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

npx genkit start -- firebase emulators:start --inspect-functions

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

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