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

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

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

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

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

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

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

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

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

    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. डायरेक्ट्री में Firebase प्रोजेक्ट को शुरू करने के लिए:

    cd $PROJECT_ROOT
firebase init genkit

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

2. फ़्लो की परिभाषाएं अपडेट करना

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

अपने फ़्लो को डिप्लॉय करने के लिए, आपको उन्हें तय करने के तरीके में कुछ छोटे बदलाव करने होंगे. कोर लॉजिक में कोई बदलाव नहीं होगा. हालांकि, आपको कुछ और जानकारी जोड़नी होगी, ताकि उन्हें आसानी से डिप्लॉय किया जा सके और डिप्लॉय होने के बाद वे ज़्यादा सुरक्षित हों.

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

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;
  }
);

यहां दिए गए सेक्शन में, उन बदलावों के बारे में बताया गया है जिन्हें लागू करने से पहले आपको करना होगा.

onFlow की मदद से फ़्लो तय करना

Genkit.defineFlow() का इस्तेमाल करके अपने फ़्लो को तय करने के बजाय, Firebase प्लग इन के onFlow() फ़ंक्शन का इस्तेमाल करें. इस फ़ंक्शन का इस्तेमाल करके, अपने फ़्लो लॉजिक को onCall की तरह ही Cloud Functions के अनुरोध हैंडलर में रैप किया जा सकता है.

import { onFlow } from "@genkit-ai/firebase/functions";

export const generatePoem = onFlow(
  ai,
  {
    // ...
  },
  async (subject: string) => {
    // ...
  }
);

ध्यान दें कि onFlow, Genkit का कोई तरीका नहीं है. यह एक ऐसा फ़ंक्शन है जो अपने पहले पैरामीटर के तौर पर Genkit इंस्टेंस लेता है. इसके अलावा, सिंटैक्स defineFlow जैसा ही होता है.

अनुमति की नीति तय करना

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

import { firebaseAuth } from "@genkit-ai/firebase/auth";

export const generatePoem = onFlow(
  ai,
  {
    name: "generatePoem",
    // ...
    authPolicy: firebaseAuth((user, input) => {
      if (!user.email_verified) {
        throw new Error("Verified email required to run flow");
      }
    }),
  },
  async (subject: string) => {
    // ...
  }
);

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

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

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

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

Gemini (Google का एआई)

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

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

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

    firebase functions:secrets:set GOOGLE_GENAI_API_KEY

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

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

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

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

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

    export const generatePoem = onFlow(
  {
    name: "generatePoem",
    // ...
    httpsOptions: {
      secrets: [googleAIapiKey],  // Add this line.
    },
  },
  async (subject) => {
    // ...
  }
);

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

Gemini (Vertex AI)

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

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

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

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

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

export const generatePoem = onFlow(
  ai,
  {
    name: "generatePoem",
    // ...
    httpsOptions: {
      cors: '*',
    },
  },
  async (subject: string) => {
    // ...
  }
);

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

पूरा उदाहरण

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

const googleAIapiKey = defineSecret("GOOGLE_GENAI_API_KEY");

export const generatePoem = onFlow(
  ai,
  {
    name: "generatePoem",
    inputSchema: z.string(),
    outputSchema: z.string(),
    authPolicy: firebaseAuth((user, input) => {
      if (!user.email_verified) {
        throw new Error("Verified email required to run flow");
      }
    }),
    httpsOptions: {
      secrets: [googleAIapiKey],
      cors: '*',
    },
  },
  async (subject: string) => {
    const { text } = await ai.generate(`Compose a poem about ${subject}.`);
    return text;
  }
);

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

onFlow का इस्तेमाल करके फ़्लो तय करने के बाद, उन्हें उसी तरह डिप्लॉय किया जा सकता है जिस तरह अन्य 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 खाते से साइन इन करना होगा. इसके बाद, एंडपॉइंट के अनुरोध शुरू किए जा सकते हैं.

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

डेवलपर यूज़र इंटरफ़ेस (यूआई) में, onFlow का इस्तेमाल करके तय किए गए फ़्लो को ठीक उसी तरह से चलाया जा सकता है जिस तरह से 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 से ट्रैस लोड करेगा.