इस पेज का अनुवाद Cloud Translation API से किया गया है.

Gemini के साथ काम करने वाले चैट ऐप्लिकेशन को Cloud Run पर डिप्लॉय करने का तरीका

1. परिचय

खास जानकारी

इस कोडलैब में, आपको Vertex AI Gemini API और Vertex AI क्लाइंट लाइब्रेरी का इस्तेमाल करके, नोड में लिखा हुआ बेसिक चैट बॉट बनाने का तरीका बताया जाएगा. यह ऐप्लिकेशन Google Cloud Firestore के साथ काम करने वाले एक्सप्रेस सेशन स्टोर का इस्तेमाल करता है.

आपको इनके बारे में जानकारी मिलेगी

Cloud Run सेवा बनाने के लिए htmx, tailwindcss, और express.js का इस्तेमाल कैसे करें
Google API की पुष्टि करने के लिए, Vertex AI क्लाइंट लाइब्रेरी इस्तेमाल करने का तरीका
Gemini मॉडल के साथ इंटरैक्ट करने के लिए चैटबॉट कैसे बनाएँ
डॉक फ़ाइल के बिना, क्लाउड रन सेवा में डिप्लॉयमेंट करने का तरीका
Google Cloud Firestore के साथ काम करने वाले एक्सप्रेस सेशन स्टोर को इस्तेमाल करने का तरीका

2. सेटअप और ज़रूरी शर्तें

ज़रूरी शर्तें

आपने Cloud Console में लॉग इन किया है.
आपने पहले Cloud Run सेवा को डिप्लॉय किया है. उदाहरण के लिए, शुरू करने के लिए सोर्स कोड क्विकस्टार्ट की मदद से वेब सेवा डिप्लॉय करें का पालन करें.

Cloud Shell चालू करें

Cloud Console में, Cloud Shell चालू करें पर क्लिक करें.

अगर आपने Cloud Shell का इस्तेमाल पहली बार किया है, तो आपको बीच में आने वाली स्क्रीन दिखेगी. इसमें यह बताया जाएगा कि यह क्या है. अगर आपको बीच के लेवल पर मिलने वाली स्क्रीन दिखती है, तो जारी रखें पर क्लिक करें.

प्रावधान करने और Cloud Shell से कनेक्ट होने में कुछ ही समय लगेगा.

इस वर्चुअल मशीन में डेवलपमेंट के सभी ज़रूरी टूल मौजूद हैं. इसमें लगातार पांच जीबी की होम डायरेक्ट्री मिलती है और यह Google Cloud में काम करती है. यह नेटवर्क की परफ़ॉर्मेंस और ऑथेंटिकेशन को बेहतर बनाने में मदद करती है. अगर सभी नहीं, तो इस कोडलैब में आपका बहुत सारा काम ब्राउज़र से किया जा सकता है.

Cloud Shell से कनेक्ट करने के बाद, आपको दिखेगा कि आपकी पुष्टि हो चुकी है और प्रोजेक्ट आपके प्रोजेक्ट आईडी पर सेट है.

यह पुष्टि करने के लिए Cloud Shell में नीचे दिया गया कमांड चलाएं कि आपकी पुष्टि हो गई है:

gcloud auth list

कमांड आउटपुट

 Credentialed Accounts
ACTIVE  ACCOUNT
*       <my_account>@<my_domain.com>

To set the active account, run:
    $ gcloud config set account `ACCOUNT`

Cloud Shell में यह कमांड चलाएं, ताकि यह पुष्टि की जा सके कि gcloud के लिए कमांड को आपके प्रोजेक्ट के बारे में जानकारी है:

gcloud config list project

कमांड आउटपुट

[core]
project = <PROJECT_ID>

अगर ऐसा नहीं है, तो आप इसे इस निर्देश की मदद से सेट कर सकते हैं:

gcloud config set project <PROJECT_ID>

कमांड आउटपुट

Updated property [core/project].

3. एपीआई चालू करें और एनवायरमेंट वैरिएबल सेट करें

एपीआई चालू करें

इस कोडलैब का इस्तेमाल शुरू करने से पहले, आपको कई एपीआई चालू करने होंगे. इस कोडलैब के लिए, नीचे दिए गए एपीआई का इस्तेमाल करना ज़रूरी है. नीचे दिए गए निर्देश की मदद से, उन एपीआई को चालू किया जा सकता है:

gcloud services enable run.googleapis.com \
    cloudbuild.googleapis.com \
    aiplatform.googleapis.com \
    secretmanager.googleapis.com

एनवायरमेंट वैरिएबल सेटअप करें

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

PROJECT_ID=<YOUR_PROJECT_ID>
REGION=<YOUR_REGION, e.g. us-central1>
SERVICE=chat-with-gemini
SERVICE_ACCOUNT="vertex-ai-caller"
SERVICE_ACCOUNT_ADDRESS=$SERVICE_ACCOUNT@$PROJECT_ID.iam.gserviceaccount.com
SECRET_ID="SESSION_SECRET"

4. Firebase प्रोजेक्ट बनाना और उसे कॉन्फ़िगर करना

Firebase कंसोल में, प्रोजेक्ट जोड़ें पर क्लिक करें.
<YOUR_PROJECT_ID> डालें Firebase को अपने किसी मौजूदा Google Cloud प्रोजेक्ट में जोड़ने के लिए
अगर कहा जाए, तो Firebase की शर्तों को पढ़ें और स्वीकार करें.
जारी रखें पर क्लिक करें.
Firebase बिलिंग प्लान की पुष्टि करने के लिए, प्लान की पुष्टि करें पर क्लिक करें.
इस कोडलैब के लिए Google Analytics को चालू करना ज़रूरी नहीं है.
Firebase जोड़ें पर क्लिक करें.
प्रोजेक्ट बनाने के बाद, जारी रखें पर क्लिक करें.
बिल्ड मेन्यू में, डेटा स्टोर फिर से स्टोर करें पर क्लिक करें.
डेटाबेस बनाएं पर क्लिक करें.
जगह ड्रॉप-डाउन से अपना क्षेत्र चुनें. इसके बाद, आगे बढ़ें पर क्लिक करें.
डिफ़ॉल्ट रूप से, प्रोडक्शन मोड में चालू करें का इस्तेमाल करें. इसके बाद, बनाएं पर क्लिक करें.

5. सेवा खाता बनाना

Vertex AI Gemini API को कॉल करने के लिए, Cloud Run इस सेवा खाते का इस्तेमाल करेगा. इस सेवा खाते के पास Firestore को पढ़ने, उसमें बदलाव करने, और सीक्रेट मैनेजर के सीक्रेट पढ़ने की अनुमतियां भी होंगी.

सबसे पहले, इस निर्देश को चलाकर सेवा खाता बनाएं:

gcloud iam service-accounts create $SERVICE_ACCOUNT \
  --display-name="Cloud Run to access Vertex AI APIs"

दूसरा, सेवा खाते को Vertex AI के उपयोगकर्ता की भूमिका दें.

gcloud projects add-iam-policy-binding $PROJECT_ID \
  --member serviceAccount:$SERVICE_ACCOUNT_ADDRESS \
  --role=roles/aiplatform.user

अब, सीक्रेट मैनेजर में सीक्रेट बनाएं. Cloud Run सेवा इस सीक्रेट को एक एनवायरमेंट वैरिएबल के रूप में ऐक्सेस करेगी, जिसका समाधान इंस्टेंस स्टार्टअप के समय किया जाता है. सीक्रेट और Cloud Run के बारे में ज़्यादा जानें.

gcloud secrets create $SECRET_ID --replication-policy="automatic"
printf "keyboard-cat" | gcloud secrets versions add $SECRET_ID --data-file=-

और सेवा खाते को सीक्रेट मैनेजर में एक्सप्रेस सेशन सीक्रेट का ऐक्सेस दें.

gcloud secrets add-iam-policy-binding $SECRET_ID \
    --member serviceAccount:$SERVICE_ACCOUNT_ADDRESS \
    --role='roles/secretmanager.secretAccessor'

आखिर में, सेवा खाते को Firestore को पढ़ने और लिखने का ऐक्सेस दें.

gcloud projects add-iam-policy-binding $PROJECT_ID \
  --member serviceAccount:$SERVICE_ACCOUNT_ADDRESS \
  --role=roles/datastore.user

6. Cloud Run सेवा बनाना

सबसे पहले, सोर्स कोड के लिए एक डायरेक्ट्री बनाएं और उस डायरेक्ट्री में cd डालें.

mkdir chat-with-gemini && cd chat-with-gemini

इसके बाद, इस कॉन्टेंट के साथ एक package.json फ़ाइल बनाएं:

{
  "name": "chat-with-gemini",
  "version": "1.0.0",
  "description": "",
  "main": "app.js",
  "scripts": {
    "start": "node app.js",
    "nodemon": "nodemon app.js",
    "cssdev": "npx tailwindcss -i ./input.css -o ./public/output.css --watch",
    "tailwind": "npx tailwindcss -i ./input.css -o ./public/output.css",
    "dev": "npm run tailwind && npm run nodemon"
  },
  "keywords": [],
  "author": "",
  "license": "ISC",
  "dependencies": {
    "@google-cloud/connect-firestore": "^3.0.0",
    "@google-cloud/firestore": "^7.5.0",
    "@google-cloud/vertexai": "^0.4.0",
    "axios": "^1.6.8",
    "express": "^4.18.2",
    "express-session": "^1.18.0",
    "express-ws": "^5.0.2",
    "htmx.org": "^1.9.10"
  },
  "devDependencies": {
    "nodemon": "^3.1.0",
    "tailwindcss": "^3.4.1"
  }
}

इसके बाद, नीचे दिए गए कॉन्टेंट के साथ एक app.js सोर्स फ़ाइल बनाएं. इस फ़ाइल में सेवा का एंट्री पॉइंट और ऐप्लिकेशन का मुख्य लॉजिक शामिल है.

const express = require("express");
const app = express();
app.use(express.urlencoded({ extended: true }));
app.use(express.json());
const path = require("path");

const fs = require("fs");
const util = require("util");
const { spinnerSvg } = require("./spinnerSvg.js");

// cloud run retrieves secret at instance startup time
const secret = process.env.SESSION_SECRET;

const { Firestore } = require("@google-cloud/firestore");
const { FirestoreStore } = require("@google-cloud/connect-firestore");
var session = require("express-session");
app.set("trust proxy", 1); // trust first proxy
app.use(
    session({
        store: new FirestoreStore({
            dataset: new Firestore(),
            kind: "express-sessions"
        }),
        secret: secret,
        /* set secure to false for local dev session history testing */
        /* see more at https://expressjs.com/en/resources/middleware/session.html */
        cookie: { secure: true },
        resave: false,
        saveUninitialized: true
    })
);

const expressWs = require("express-ws")(app);

app.use(express.static("public"));

// Vertex AI Section
const { VertexAI } = require("@google-cloud/vertexai");

// instance of Vertex model
let generativeModel;

// on startup
const port = parseInt(process.env.PORT) || 8080;
app.listen(port, async () => {
    console.log(`demo1: listening on port ${port}`);

    // get project and location from metadata service
    const metadataService = require("./metadataService.js");

    const project = await metadataService.getProjectId();
    const location = await metadataService.getRegion();

    // Vertex client library instance
    const vertex_ai = new VertexAI({
        project: project,
        location: location
    });

    // Instantiate models
    generativeModel = vertex_ai.getGenerativeModel({
        model: "gemini-1.0-pro-001"
    });
});

app.ws("/sendMessage", async function (ws, req) {
    if (!req.session.chathistory || req.session.chathistory.length == 0) {
        req.session.chathistory = [];
    }

    let chatWithModel = generativeModel.startChat({
        history: req.session.chathistory
    });

    ws.on("message", async function (message) {

        console.log("req.sessionID: ", req.sessionID);
        // get session id

        let questionToAsk = JSON.parse(message).message;
        console.log("WebSocket message: " + questionToAsk);

        ws.send(`<div hx-swap-oob="beforeend:#toupdate"><div
                        id="questionToAsk"
                        class="text-black m-2 text-right border p-2 rounded-lg ml-24">
                        ${questionToAsk}
                    </div></div>`);

        // to simulate a natural pause in conversation
        await sleep(500);

        // get timestamp for div to replace
        const now = "fromGemini" + Date.now();

        ws.send(`<div hx-swap-oob="beforeend:#toupdate"><div
                        id=${now}
                        class=" text-blue-400 m-2 text-left border p-2 rounded-lg mr-24">
                        ${spinnerSvg} 
                    </div></div>`);

        const results = await chatWithModel.sendMessage(questionToAsk);
        const answer =
            results.response.candidates[0].content.parts[0].text;

        ws.send(`<div
                        id=${now}
                        hx-swap-oob="true"
                        hx-swap="outerHTML"
                        class="text-blue-400 m-2 text-left border p-2 rounded-lg mr-24">
                        ${answer}
                    </div>`);

                    // save to current chat history
        let userHistory = {
            role: "user",
            parts: [{ text: questionToAsk }]
        };
        let modelHistory = {
            role: "model",
            parts: [{ text: answer }]
        };

        req.session.chathistory.push(userHistory);
        req.session.chathistory.push(modelHistory);

        // console.log(
        //     "newly saved chat history: ",
        //     util.inspect(req.session.chathistory, {
        //         showHidden: false,
        //         depth: null,
        //         colors: true
        //     })
        // );
        req.session.save();
    });

    ws.on("close", () => {
        console.log("WebSocket was closed");
    });
});

function sleep(ms) {
    return new Promise((resolve) => {
        setTimeout(resolve, ms);
    });
}

// gracefully close the web sockets
process.on("SIGTERM", () => {
    server.close();
});

tailwindCSS के लिए tailwind.config.js फ़ाइल बनाएं.

/** @type {import('tailwindcss').Config} */
module.exports = {
    content: ["./**/*.{html,js}"],
    theme: {
        extend: {}
    },
    plugins: []
};

डिप्लॉय की गई Cloud Run सेवा के लिए, प्रोजेक्ट आईडी और इलाका पाने के लिए metadataService.js फ़ाइल बनाएं. इन वैल्यू का इस्तेमाल, Vertex AI क्लाइंट लाइब्रेरी के इंस्टेंस को इंस्टैंशिएट करने के लिए किया जाएगा.

const your_project_id = "YOUR_PROJECT_ID";
const your_region = "YOUR_REGION";

const axios = require("axios");

module.exports = {
    getProjectId: async () => {
        let project = "";
        try {
            // Fetch the token to make a GCF to GCF call
            const response = await axios.get(
                "http://metadata.google.internal/computeMetadata/v1/project/project-id",
                {
                    headers: {
                        "Metadata-Flavor": "Google"
                    }
                }
            );

            if (response.data == "") {
                // running locally on Cloud Shell
                project = your_project_id;
            } else {
                // running on Clodu Run. Use project id from metadata service
                project = response.data;
            }
        } catch (ex) {
            // running locally on local terminal
            project = your_project_id;
        }

        return project;
    },

    getRegion: async () => {
        let region = "";
        try {
            // Fetch the token to make a GCF to GCF call
            const response = await axios.get(
                "http://metadata.google.internal/computeMetadata/v1/instance/region",
                {
                    headers: {
                        "Metadata-Flavor": "Google"
                    }
                }
            );

            if (response.data == "") {
                // running locally on Cloud Shell
                region = your_region;
            } else {
                // running on Clodu Run. Use region from metadata service
                let regionFull = response.data;
                const index = regionFull.lastIndexOf("/");
                region = regionFull.substring(index + 1);
            }
        } catch (ex) {
            // running locally on local terminal
            region = your_region;
        }
        return region;
    }
};

spinnerSvg.js नाम की फ़ाइल बनाएं

module.exports.spinnerSvg = `<svg class="animate-spin -ml-1 mr-3 h-5 w-5 text-blue-500"
                    xmlns="http://www.w3.org/2000/svg"
                    fill="none"
                    viewBox="0 0 24 24"
                >
                    <circle
                        class="opacity-25"
                        cx="12"
                        cy="12"
                        r="10"
                        stroke="currentColor"
                        stroke-width="4"
                    ></circle>
                    <path
                        class="opacity-75"
                        fill="currentColor"
                        d="M4 12a8 8 0 018-8V0C5.373 0 0 5.373 0 12h4zm2 5.291A7.962 7.962 0 014 12H0c0 3.042 1.135 5.824 3 7.938l3-2.647z"
                    ></path></svg>`;

आखिर में, tailwindCSS के लिए input.css फ़ाइल बनाएं.

@tailwind base;
@tailwind components;
@tailwind utilities;

अब, एक नई public डायरेक्ट्री बनाएं.

mkdir public
cd public

और उस सार्वजनिक डायरेक्ट्री में, फ़्रंट एंड के लिए index.html फ़ाइल बनाएं, जो htmx का इस्तेमाल करेगी.

<!DOCTYPE html>
<html lang="en">
    <head>
        <meta charset="UTF-8" />
        <meta
            name="viewport"
            content="width=device-width, initial-scale=1.0"
        />
        <script
            src="https://unpkg.com/htmx.org@1.9.10"
            integrity="sha384-D1Kt99CQMDuVetoL1lrYwg5t+9QdHe7NLX/SoJYkXDFfX37iInKRy5xLSi8nO7UC"
            crossorigin="anonymous"
        ></script>

        <link href="./output.css" rel="stylesheet" />
        <script src="https://unpkg.com/htmx.org/dist/ext/ws.js"></script>

        <title>Demo 1</title>
    </head>
    <body>
        <div id="herewego" text-center>
            <!-- <div id="replaceme2" hx-swap-oob="true">Hello world</div> -->
            <div
                class="container mx-auto mt-8 text-center max-w-screen-lg"
            >
                <div
                    class="overflow-y-scroll bg-white p-2 border h-[500px] space-y-4 rounded-lg m-auto"
                >
                    <div id="toupdate"></div>
                </div>
                <form
                    hx-trigger="submit, keyup[keyCode==13] from:body"
                    hx-ext="ws"
                    ws-connect="/sendMessage"
                    ws-send=""
                    hx-on="htmx:wsAfterSend: document.getElementById('message').value = ''"
                >
                    <div class="mb-6 mt-6 flex gap-4">
                        <textarea
                            rows="2"
                            type="text"
                            id="message"
                            name="message"
                            class="block grow rounded-lg border p-6 resize-none"
                            required
                        >
Is C# a programming language or a musical note?</textarea
                        >
                        <button
                            type="submit"
                            class="bg-blue-500 text-white px-4 py-2 rounded-lg text-center text-sm font-medium"
                        >
                            Send
                        </button>
                    </div>
                </form>
            </div>
        </div>
    </body>
</html>

7. सेवा को स्थानीय तौर पर चलाएं

सबसे पहले, पक्का करें कि आप कोडलैब के लिए रूट डायरेक्ट्री chat-with-gemini में हैं.

cd .. && pwd

इसके बाद, नीचे दिए गए कमांड की मदद से डिपेंडेंसी इंस्टॉल करें:

npm install

डिवाइस पर चलाते समय ADC का इस्तेमाल करना

अगर क्लाउड शेल में चलाया जा रहा है, तो इसका मतलब है कि Google Compute Engine की वर्चुअल मशीन पहले से ही चल रही है. इस वर्चुअल मशीन से जुड़े आपके क्रेडेंशियल (जैसा कि gcloud auth list चलाकर दिखाया गया है) ऐप्लिकेशन के डिफ़ॉल्ट क्रेडेंशियल की मदद से, अपने-आप इस्तेमाल किए जाएंगे. इसलिए, gcloud auth application-default login निर्देश का इस्तेमाल करना ज़रूरी नहीं है. आपके पास सीधे लोकल सेशन सीक्रेट बनाएं सेक्शन पर जाने का विकल्प है

हालांकि, अगर आपके लोकल टर्मिनल पर इस्तेमाल किया जा रहा है, जैसे कि Cloud Shell में नहीं, तो Google API की पुष्टि करने के लिए, आपको ऐप्लिकेशन के डिफ़ॉल्ट क्रेडेंशियल का इस्तेमाल करना होगा. आपके पास 1) अपने क्रेडेंशियल का इस्तेमाल करके लॉगिन करने का विकल्प है (बशर्ते आपके पास Vertex AI और Datastore उपयोगकर्ता की भूमिकाएं हों) या 2) इस कोडलैब में इस्तेमाल किए जाने वाले सेवा खाते की पहचान चुराकर लॉगिन किया जा सकता है.

पहला विकल्प) ADC के लिए अपने क्रेडेंशियल का इस्तेमाल करना

अगर आपको अपने क्रेडेंशियल का इस्तेमाल करना है, तो सबसे पहले gcloud auth list चलाकर देखें कि gcloud में आपकी पुष्टि कैसे हुई है. इसके बाद, आपको अपनी पहचान Vertex AI उपयोगकर्ता की भूमिका देनी पड़ सकती है. अगर आपकी पहचान को मालिक की भूमिका मिली है, तो इसका मतलब है कि आपके पास Vertex AI की यह उपयोगकर्ता भूमिका पहले से है. अगर ऐसा नहीं है, तो अपनी पहचान Vertex AI उपयोगकर्ता की भूमिका और Datastore उपयोगकर्ता की भूमिका देने के लिए, इस निर्देश को चलाया जा सकता है.

USER=<YOUR_PRINCIPAL_EMAIL>

gcloud projects add-iam-policy-binding $PROJECT_ID \
  --member user:$USER \
  --role=roles/aiplatform.user

gcloud projects add-iam-policy-binding $PROJECT_ID \
  --member user:$USER \
  --role=roles/datastore.user

इसके बाद, इन कमांड को चलाएं

gcloud auth application-default login

दूसरा विकल्प) एडीसी के लिए सेवा खाते के नाम का इस्तेमाल करना

अगर आपको इस कोडलैब में बनाए गए सेवा खाते का इस्तेमाल करना है, तो आपके उपयोगकर्ता खाते के पास सेवा खाता टोकन क्रिएटर की भूमिका होनी चाहिए. नीचे दिए गए कमांड का इस्तेमाल करके, इस भूमिका को हासिल किया जा सकता है:

gcloud projects add-iam-policy-binding $PROJECT_ID \
  --member user:$USER \
  --role=roles/iam.serviceAccountTokenCreator

इसके बाद, आपको सेवा खाते के साथ ADC का इस्तेमाल करने के लिए, नीचे दिया गया कमांड चलाना होगा

gcloud auth application-default login --impersonate-service-account=$SERVICE_ACCOUNT_ADDRESS

लोकल सेशन सीक्रेट बनाना

अब, लोकल डेवलपमेंट के लिए लोकल सेशन सीक्रेट बनाएं.

export SESSION_SECRET=local-secret

ऐप्लिकेशन को डिवाइस में चलाएं

आखिर में, नीचे दी गई स्क्रिप्ट चलाकर ऐप्लिकेशन को शुरू किया जा सकता है. यह स्क्रिप्ट, tailwindCSS से आउटपुट.css फ़ाइल भी जनरेट करेगी.

npm run dev

वेब झलक बटन खोलकर और झलक देखने वाले पोर्ट 8080 को चुनकर, वेबसाइट की झलक देखी जा सकती है

वेब प्रीव्यू - पोर्ट 8080 बटन पर प्रीव्यू

8. सेवा को डिप्लॉय करें

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

gcloud run deploy $SERVICE \
 --service-account $SERVICE_ACCOUNT_ADDRESS \
 --source . \
  --region $REGION \
  --allow-unauthenticated \
  --set-secrets="SESSION_SECRET=$(echo $SECRET_ID):1"

अगर आपको सूचना मिलती है कि "सोर्स से डिप्लॉय करने के लिए, पहले से बनाए गए कंटेनर को स्टोर करने के लिए Artifact Registry Docker रिपॉज़िटरी की ज़रूरत होती है. [us-central1] क्षेत्र में [cloud-run-source-deploy] नाम की एक रिपॉज़िटरी बनाई जाएगी.", स्वीकार करें और जारी रखें.

9. सेवा की जांच करें

डिप्लॉय होने के बाद, अपने वेब ब्राउज़र में सेवा का यूआरएल खोलें. इसके बाद, Gemini से कोई सवाल पूछें, जैसे कि "मैं गिटार की प्रैक्टिस करता हूं, लेकिन मैं सॉफ़्टवेयर इंजीनियर भी हूं. "C#" दिखने पर, मुझे इसे प्रोग्रामिंग भाषा के तौर पर देखना चाहिए या म्यूज़िकल नोट के तौर पर? मुझे इनमें से किसे चुनना चाहिए?"

10. बधाई हो!

कोडलैब पूरा करने के लिए बधाई!

हमारा सुझाव है कि आप Cloud Run और Vertex AI Gemini API दस्तावेज़ पढ़ें.

इसमें हमने इन विषयों के बारे में बताया

Cloud Run सेवा बनाने के लिए htmx, tailwindcss, और express.js का इस्तेमाल कैसे करें
Google API की पुष्टि करने के लिए, Vertex AI क्लाइंट लाइब्रेरी इस्तेमाल करने का तरीका
Gemini मॉडल के साथ इंटरैक्ट करने के लिए, चैट बॉट बनाने का तरीक़ा
डॉक फ़ाइल के बिना, क्लाउड रन सेवा में डिप्लॉयमेंट करने का तरीका
Google Cloud Firestore के साथ काम करने वाले एक्सप्रेस सेशन स्टोर को इस्तेमाल करने का तरीका

11. व्यवस्थित करें

अनजाने में लगने वाले शुल्कों से बचने के लिए, (उदाहरण के लिए, अगर Cloud Run सेवाओं का अनुरोध अनजाने में फ़्री टियर में हर महीने Cloud Run के लिए असाइन किए जाने वाले बजट से ज़्यादा हो जाता है), तो आप या तो Cloud Run को मिटा सकते हैं या दूसरे चरण में बनाए गए प्रोजेक्ट को मिटा सकते हैं.

Cloud Run सेवा को मिटाने के लिए, https://console.cloud.google.com/run पर Cloud Run Cloud Console पर जाएं और chat-with-gemini सेवा को मिटाएं. आपके पास, vertex-ai-caller सेवा खाता मिटाने या Vertex AI उपयोगकर्ता की भूमिका रद्द करने का विकल्प भी है. इससे, Gemini को गलती से कॉल करने से बचा जा सकता है.

अगर आपको पूरा प्रोजेक्ट मिटाना है, तो https://console.cloud.google.com/cloud-resource-manager पर जाएं और दूसरे चरण में बनाया गया प्रोजेक्ट चुनें. इसके बाद, 'मिटाएं' चुनें. अगर प्रोजेक्ट मिटाया जाता है, तो आपको Cloud SDK में प्रोजेक्ट बदलने होंगे. gcloud projects list चलाकर, सभी उपलब्ध प्रोजेक्ट की सूची देखी जा सकती है.