আপনার কন্টেইনারাইজড এজেন্টটি এজেন্ট রানটাইমে স্থাপন করুন।

১. সংক্ষিপ্ত বিবরণ

এজেন্ট রানটাইম (পূর্বে এজেন্ট ইঞ্জিন) একটি পরিচালিত রানটাইম পরিবেশ প্রদান করে, যা এআই এজেন্টদের কার্যকরভাবে স্থাপন, চালানো এবং স্কেল করার জন্য ডিজাইন করা হয়েছে। ডিফল্টরূপে, প্ল্যাটফর্মটি স্থাপন প্রক্রিয়ার সময় স্বয়ংক্রিয়ভাবে আপনার সোর্স কোড এবং নির্ভরতাগুলো বান্ডল করে।

তবে, এন্টারপ্রাইজ ওয়ার্কলোডগুলির জন্য প্রায়শই রানটাইম এনভায়রনমেন্টের উপর সম্পূর্ণ মালিকানা প্রয়োজন হয়। এটিকে সমর্থন করার জন্য, এজেন্ট রানটাইম ‘ব্রিং ইওর ওন কন্টেইনার ’ (BYOC) সুবিধা প্রদান করে, যা আপনাকে আগে থেকে তৈরি কাস্টম কন্টেইনার ইমেজ স্থাপন করার সুযোগ দেয়।

এই কোডল্যাবে গুগল এজেন্ট ডেভেলপমেন্ট কিট (ADK) দিয়ে তৈরি একটি এজেন্টকে কন্টেইনারাইজ করা, প্রয়োজনীয় গুগল ক্লাউড পারমিশন কনফিগার করা এবং পাইথন SDK অথবা টেরাফর্ম ব্যবহার করে এজেন্ট রানটাইমে ডিপ্লয় করার সম্পূর্ণ প্রক্রিয়াটি বর্ণনা করা হয়েছে।

এই কোডল্যাবটি আপনাকে নিম্নলিখিত বিষয়গুলিতে নির্দেশনা দেবে:

  1. গুগল এজেন্ট ডেভেলপমেন্ট কিট (ADK) ব্যবহার করে একটি পাইথন এজেন্ট তৈরি করা।
  2. এজেন্টটিকে একটি FastAPI অ্যাপ্লিকেশনে আবদ্ধ করা।
  3. ডকার ব্যবহার করে অ্যাপ্লিকেশনটিকে কন্টেইনারাইজ করা।
  4. গুগল ক্লাউডের অনুমতি নির্ধারণ করা হচ্ছে।
  5. এজেন্ট রানটাইমে কন্টেইনারাইজড এজেন্ট স্থাপন এবং পরীক্ষা করা হচ্ছে।

বিল্ড এবং ডেপ্লয়মেন্ট ফ্লো

নিম্নলিখিত ডায়াগ্রামটি এই কোডল্যাবে আপনার ম্যানুয়ালি সম্পাদন করা বিল্ড এবং ডিপ্লয়মেন্ট ধাপগুলির কার্যপ্রবাহ চিত্রিত করে:

সিআই/সিডি ফ্লো ডায়াগ্রাম

আপনার যা প্রয়োজন

  • বিলিং সক্ষম একটি গুগল ক্লাউড প্রজেক্ট।
  • ক্লাউড শেল-এ অ্যাক্সেস (প্রস্তাবিত) অথবা gcloud এবং docker ইনস্টল করা একটি স্থানীয় ডেভেলপমেন্ট এনভায়রনমেন্ট।
  • পাইথন ও ডকার সম্পর্কে প্রাথমিক জ্ঞান।

২. পরিবেশ সেটআপ

শুরু করার আগে, আপনাকে প্রয়োজনীয় এপিআইগুলো সক্রিয় করতে এবং আপনার পরিবেশ কনফিগার করতে হবে।

ধাপ ১: ক্লাউড শেল খুলুন

গুগল ক্লাউড কনসোলের উপরের ডানদিকে থাকা ‘Activate Cloud Shell’ বোতামটিতে ক্লিক করুন।

ক্লাউড শেল

ধাপ ২: এনভায়রনমেন্ট ভেরিয়েবল কনফিগার করুন

ক্লাউড শেলে, আপনার প্রজেক্ট আইডি সেট করুন এবং এই কোডল্যাব জুড়ে ব্যবহৃত মূল এনভায়রনমেন্ট ভেরিয়েবলগুলো নির্ধারণ করুন। "YOUR_PROJECT_ID" এর জায়গায় আপনার আসল গুগল ক্লাউড প্রজেক্ট আইডি বসান:

gcloud config set project "YOUR_PROJECT_ID"
export PROJECT_ID=$(gcloud config get-value project)
export LOCATION="us-central1"
export MODEL="gemini-3.1-flash-lite"
export MODEL_REGION="global"

এই ভেরিয়েবলগুলো টার্গেট ডেপ্লয়মেন্ট সেটিংস কনফিগার করে:

  • PROJECT_ID : আপনার গুগল ক্লাউড প্রজেক্টের অনন্য শনাক্তকারী, যেখানে জেমিনি এন্টারপ্রাইজ এজেন্ট প্ল্যাটফর্মের সমস্ত রিসোর্স এবং আর্টিফ্যাক্ট রেজিস্ট্রি থাকবে।
  • LOCATION : ভৌগোলিক অঞ্চল (যেমন us-central1 ) যেখানে আপনার রিপোজিটরি এবং রানটাইম ওয়ার্কলোডগুলো হোস্ট করা আছে।
  • MODEL : এজেন্ট কনটেক্সট দ্বারা লোড করা জেমিনি মডেল সংস্করণ (যেমন gemini-3.1-flash-lite )।
  • MODEL_REGION : মডেলের এন্ডপয়েন্ট অঞ্চল। গ্লোবাল এন্ডপয়েন্টগুলো থেকে জেমিনি মডেলটি চালু করতে এখানে "global" হিসেবে সেট করুন।

ধাপ ৩: এপিআই সক্রিয় করুন

প্রয়োজনীয় গুগল ক্লাউড এপিআইগুলো সক্রিয় করুন:

gcloud services enable \
    aiplatform.googleapis.com \
    cloudbuild.googleapis.com \
    compute.googleapis.com \
    artifactregistry.googleapis.com \
    storage.googleapis.com

ধাপ ৪: SDK ইনস্টল করুন

এজেন্ট ইঞ্জিন এবং ADK সাপোর্ট সহ Vertex AI SDK ইনস্টল করুন:

pip install --upgrade "google-cloud-aiplatform[agent_engines,adk]>=1.144"

৩. উৎস ফাইল সেটআপ

এই ধাপে আপনি আপনার এজেন্টের কাঠামো এবং কোড তৈরি করবেন।

ডিরেক্টরি কাঠামোর সংক্ষিপ্ত বিবরণ

এই কোডল্যাবটি শেষ হওয়ার পর, আপনার ফাইলগুলো নিম্নলিখিত ওয়ার্কস্পেস স্তরবিন্যাস অনুসারে সাজানো থাকবে:

weather-agent-byoc/
├── Dockerfile                  # Container definition
├── deploy_byoc.py              # Python SDK deployment script
├── main.py                     # FastAPI server wrapper
├── query_agent.py              # Verify / query script
├── requirements.txt            # Python dependencies
│
├── weather_agent/              # Agent source module
│   ├── __init__.py             # Package declaration
│   ├── agent.py                # Agent & mock tools logic
│   └── config.json             # Environment config variables
│
└── terraform/                  # Terraform configuration files
    ├── main.tf
    ├── outputs.tf
    ├── providers.tf
    ├── terraform.tfvars
    └── variables.tf

ধাপ ১: ডিরেক্টরি তৈরি করুন

আপনার হোম ডিরেক্টরি থেকে শুরু করুন এবং ওয়ার্কস্পেস কাঠামোটি তৈরি করুন:

cd ~
mkdir -p weather-agent-byoc/weather_agent
cd weather-agent-byoc

ধাপ ২: কনফিগারেশন ফাইল তৈরি করুন

কনফিগারেশন প্যারামিটারগুলো সরাসরি weather_agent/config.json ফাইলে লেখার জন্য ক্লাউড শেলে নিম্নলিখিত কমান্ডটি চালান। এই কমান্ডটি স্বয়ংক্রিয়ভাবে ভেরিয়েবলগুলোকে আপনার এনভায়রনমেন্টের মান দিয়ে প্রতিস্থাপন করে:

cat <<EOF > weather_agent/config.json
{
    "PROJECT_ID": "${PROJECT_ID}",
    "LOCATION": "${LOCATION}",
    "MODEL": "${MODEL}",
    "MODEL_REGION": "${MODEL_REGION}"
}
EOF

ধাপ ৩: এজেন্টকে সংজ্ঞায়িত করুন

weather_agent/agent.py ফাইলে এজেন্ট কনফিগারেশন এবং মক টুল লজিক লেখার জন্য নিম্নলিখিত স্ক্রিপ্টটি চালান:

cat << 'EOF' > weather_agent/agent.py
import json
import random
from google.adk.agents import Agent
from google.adk.models.google_llm import Gemini
from functools import cached_property
from google.genai import Client

# Load config
llm_config = json.load(open("weather_agent/config.json"))
PROJECT_ID = llm_config["PROJECT_ID"]
MODEL = llm_config["MODEL"]
MODEL_REGION = llm_config["MODEL_REGION"]

# Override Gemini class for global endpoint compatibility
class GlobalGemini(Gemini):
  @cached_property
  def api_client(self) -> Client:
    return Client(vertexai=True, location="global")

# Define Tool
def get_temperature(place: str) -> str:
    '''Returns the current temperature of a given place.

    Args:
        place: The name of the city or location.

    Returns:
        str: A string describing the temperature.
    '''
    temp = random.randint(-10, 40)
    return f"The current temperature in {place} is {temp}°C."

# Initialize LLM
llm_model = GlobalGemini(model=MODEL) if MODEL_REGION == "global" else Gemini(model=MODEL)

# Initialize Agent
root_agent = Agent(
    model=llm_model,
    name='weather_agent',
    description='An agent that provides temperature information for locations.',
    instruction='You are a helpful assistant that can provide the current temperature for any given place using the get_temperature tool.',
    tools=[get_temperature],
)
EOF

weather_agent কে পাইথন প্যাকেজ হিসেবে তৈরি করতে একটি খালি __init__.py তৈরি করুন:

touch weather_agent/__init__.py

ধাপ ৪: FastAPI র‍্যাপার তৈরি করুন

main.py তে FastAPI সার্ভার এন্ট্রিপয়েন্ট কনফিগারেশন লেখার জন্য নিম্নলিখিত স্ক্রিপ্টটি চালান:

cat << 'EOF' > main.py
import inspect
import json
import logging
import os
from typing import Any, Dict, Optional
import uvicorn
import vertexai
from weather_agent.agent import root_agent
from fastapi import FastAPI, encoders, responses
from pydantic import BaseModel
from vertexai import agent_engines

app = FastAPI()

config_json = json.load(open("weather_agent/config.json"))
PROJECT_ID = config_json["PROJECT_ID"]
LOCATION = config_json["LOCATION"]
MODEL_REGION = config_json["MODEL_REGION"]

class QueryRequest(BaseModel):
    input: Optional[Dict[str, Any]] = None
    class_method: Optional[str] = None

vertexai.init(project=PROJECT_ID, location=MODEL_REGION)
adk_app = agent_engines.AdkApp(agent=root_agent)

def _encode_chunk_to_json(chunk):
  try:
    json_chunk = encoders.jsonable_encoder(chunk)
    return json.dumps(json_chunk) + "\n"
  except Exception:
    logging.exception("Failed to encode chunk")
    return None

async def json_generator(output):
  async for chunk in output:
    encoded_chunk = _encode_chunk_to_json(chunk)
    if encoded_chunk is None:
      break
    yield encoded_chunk

async def _invoke_callable_or_raise(invocation_callable, invocation_payload):
  if inspect.iscoroutinefunction(invocation_callable):
    return await invocation_callable(**invocation_payload)
  else:
    return invocation_callable(**invocation_payload)

@app.post("/api/reasoning_engine")
async def query(request: QueryRequest) -> responses.JSONResponse:
    method = getattr(adk_app, request.class_method)
    output = await _invoke_callable_or_raise(method, request.input or {})
    try:
      json_serialized_content = encoders.jsonable_encoder({"output": output})
    except ValueError as encoding_error:
      logging.exception("Failed to encode response")
      raise encoding_error
    return responses.JSONResponse(content=json_serialized_content)

@app.post("/api/stream_reasoning_engine")
async def stream_query(request: QueryRequest) -> responses.StreamingResponse:
    method = getattr(adk_app, request.class_method)
    output = await _invoke_callable_or_raise(method, request.input or {})
    return responses.StreamingResponse(
        content=json_generator(output),
        media_type="application/json",
    )

if __name__ == "__main__":
    uvicorn.run(app, host="0.0.0.0", port=int(os.environ.get("PORT", 8080)))
EOF

ধাপ ৫: নির্ভরতা নির্ধারণ করুন

requirements.txt ফাইলে প্রয়োজনীয় পাইথন ডিপেন্ডেন্সিগুলো লিখুন: 

cat << 'EOF' > requirements.txt
fastapi
uvicorn
vertexai
google-cloud-aiplatform[agent_engines,adk]>=1.144
pydantic
EOF

৪. কন্টেইনারাইজেশন

এখন, আপনার এজেন্টকে কীভাবে একটি কন্টেইনারে প্যাকেজ করা হবে তা নির্ধারণ করুন।

ধাপ ১: ডকারফাইল তৈরি করুন

আপনার FastAPI অ্যাপ্লিকেশনটি কীভাবে বিল্ড করা হবে তা নির্দিষ্ট করতে আপনার প্রজেক্ট ডিরেক্টরির রুটে Dockerfile টি তৈরি করুন: 

cat << 'EOF' > Dockerfile
FROM python:3.11-slim

WORKDIR /app

COPY weather_agent/ /app/weather_agent/
COPY main.py .
COPY requirements.txt .
RUN pip install -r requirements.txt

CMD ["sh", "-c", "uvicorn main:app --host 0.0.0.0 --port $PORT"]
EOF

৫. আর্টিফ্যাক্ট রেজিস্ট্রি ও ক্লাউড বিল্ড সেটআপ করুন

কন্টেইনার ইমেজ সংরক্ষণের জন্য আপনার একটি রিপোজিটরি এবং সেটি পুশ করার অনুমতি প্রয়োজন।

ধাপ ১: রিপোজিটরি তৈরি করুন

কনফিগারেশনের সময় নির্ধারিত এনভায়রনমেন্ট ভেরিয়েবল ব্যবহার করে আর্টিফ্যাক্ট রেজিস্ট্রি-র ভিতরে রিপোজিটরির নাম নির্ধারণ করুন এবং একটি ডকার রিপোজিটরি তৈরি করুন: 

export REPOSITORY_NAME="agents-repo"

gcloud artifacts repositories create $REPOSITORY_NAME \
    --project=$PROJECT_ID \
    --repository-format=docker \
    --location=$LOCATION \
    --description="Docker repository for Agents"

ধাপ ২: পরিষেবা অ্যাকাউন্টের অনুমতি কনফিগার করুন

ডিফল্ট কম্পিউট সার্ভিস অ্যাকাউন্টকে আর্টিফ্যাক্ট রেজিস্ট্রি-তে ইমেজ পুশ করার অনুমতি দিন।

প্রথমে, আপনার প্রজেক্ট নম্বরটি সংগ্রহ করুন: 

export PROJECT_NUMBER=$(gcloud projects describe $PROJECT_ID --format="value(projectNumber)")

ভূমিকাগুলো মঞ্জুর করুন: 

# Allow pushing to Artifact Registry
gcloud projects add-iam-policy-binding $PROJECT_ID \
    --member="serviceAccount:$PROJECT_NUMBER-compute@developer.gserviceaccount.com" \
    --role="roles/artifactregistry.writer" \
    --condition=None

# Allow Cloud Build to read storage objects
gcloud projects add-iam-policy-binding $PROJECT_NUMBER \
    --member="serviceAccount:$PROJECT_NUMBER-compute@developer.gserviceaccount.com" \
    --role="roles/storage.objectViewer" \
    --condition=None

ধাপ ৩: পরিষেবা এজেন্টদের অনুমতি প্রদান করুন

আর্টিফ্যাক্ট রেজিস্ট্রি পাঠকদের এআই প্ল্যাটফর্ম এবং রিজনিং ইঞ্জিন পরিষেবা এজেন্টগুলিতে অ্যাক্সেস দিন: 

gcloud projects add-iam-policy-binding $PROJECT_NUMBER \
    --member="serviceAccount:service-$PROJECT_NUMBER@gcp-sa-aiplatform-re.iam.gserviceaccount.com" \
    --role="roles/artifactregistry.reader"  --condition=None

gcloud projects add-iam-policy-binding $PROJECT_NUMBER \
    --member="serviceAccount:service-$PROJECT_NUMBER@gcp-sa-aiplatform.iam.gserviceaccount.com" \
    --role="roles/artifactregistry.reader"  --condition=None

ধাপ ৪: ইমেজ তৈরি এবং পুশ করুন

কন্টেইনার ইমেজটি বিল্ড ও পুশ করতে ক্লাউড বিল্ড ব্যবহার করুন: 

gcloud builds submit \
    --project=$PROJECT_ID \
    --region=$LOCATION \
    --tag $LOCATION-docker.pkg.dev/$PROJECT_ID/$REPOSITORY_NAME/weather-agent-image:latest \
    .

৬. SDK ব্যবহার করে এজেন্টটি স্থাপন করুন

এখন যেহেতু অনুমতিগুলো কনফিগার করা হয়ে গেছে, আপনি আপনার কাস্টম কন্টেইনারটি ডেপ্লয় করতে পারেন।

ধাপ ১: BYOC এজেন্ট স্থাপন করুন

এজেন্ট রানটাইমে রেজিস্ট্রি-হোস্টেড কন্টেইনারটি ডেপ্লয় করতে, আপনার প্রজেক্ট ডিরেক্টরির রুটে deploy_byoc.py নামের পাইথন ফাইলটি তৈরি করুন: 

cat << 'EOF' > deploy_byoc.py
import json
import os
import vertexai
from google.cloud import aiplatform

config = json.load(open("weather_agent/config.json"))
PROJECT_ID = config["PROJECT_ID"]
LOCATION = config["LOCATION"]
REPOSITORY_NAME = "agents-repo"

vertexai.init(project=PROJECT_ID, location=LOCATION)
client = vertexai.Client(project=PROJECT_ID, location=LOCATION)

image_uri = f"{LOCATION}-docker.pkg.dev/{PROJECT_ID}/{REPOSITORY_NAME}/weather-agent-image:latest"

print(f"Deploying custom container agent from {image_uri}...")
remote_agent = client.agent_engines.create(
    config={
        "display_name": "byoc_weather_agent",
        "description": "BYOC weather agent from custom container",
        "container_spec": {
            "image_uri": image_uri
        },
        "class_methods": [
            # For convenience to interact with the agent through the Python SDK
            # https://docs.cloud.google.com/gemini-enterprise-agent-platform/scale/runtime/use-an-adk-agent#supported-operations
            {"api_mode": "", "name": "get_session"},
            {"api_mode": "", "name": "list_sessions"},
            {"api_mode": "", "name": "create_session"},
            {"api_mode": "", "name": "delete_session"},
            {"api_mode": "async", "name": "async_get_session"},
            {"api_mode": "async", "name": "async_list_sessions"},
            {"api_mode": "async", "name": "async_create_session"},
            {"api_mode": "async", "name": "async_delete_session"},
            {"api_mode": "async", "name": "async_add_session_to_memory"},
            {"api_mode": "async", "name": "async_search_memory"},
            {"api_mode": "stream", "name": "stream_query"},
            {"api_mode": "async_stream", "name": "async_stream_query"},
            {"api_mode": "async_stream", "name": "streaming_agent_run_with_events"},
        ],
        "agent_framework": "google-adk",
    },
)

print(f"Agent successfully deployed!")
print(f"Resource Name: {remote_agent.api_resource.name}")

# Save resource name for testing
with open("agent_resource_name.txt", "w") as f:
    f.write(remote_agent.api_resource.name)
EOF

এজেন্ট রানটাইমে এজেন্টটি ডেপ্লয় করতে ডেপ্লয়মেন্ট স্ক্রিপ্টটি চালান: 

python3 deploy_byoc.py

৭. Terraform ব্যবহার করে এজেন্টটি স্থাপন করুন

বিকল্পভাবে, আপনি Terraform ব্যবহার করে একই কন্টেইনারাইজড এজেন্টটি স্থাপন করতে পারেন। প্রোডাকশন পরিবেশে ইনফ্রাস্ট্রাকচার অ্যাজ কোড পরিচালনা করার জন্য এটিই সুপারিশ করা হয়।

ধাপ ১: টেরাফর্ম ডিরেক্টরিতে যান

আপনার প্রজেক্ট রুটে একটি terraform ডিরেক্টরি তৈরি করুন এবং সেখানে যান: 

mkdir -p terraform
cd terraform

ধাপ ২: প্রোভাইডার কনফিগারেশন তৈরি করুন

providers.tf ফাইলে প্রোভাইডারদের ম্যাপিং লেখার জন্য নিম্নলিখিত স্ক্রিপ্টটি চালান: 

cat << 'EOF' > providers.tf
terraform {
  required_providers {
    google = {
      source  = "hashicorp/google"
      version = ">= 5.28.0"
    }
  }
}

provider "google" {
  project = var.project_id
  region  = var.location
}
EOF

ধাপ ৩: ভেরিয়েবলের সংজ্ঞা তৈরি করুন

variables.tf ফাইলে ইনপুট বর্ণনা ব্লকটি লিখুন: 

cat << 'EOF' > variables.tf
variable "project_id" {
  type        = string
  description = "The Google Cloud Project ID"
}

variable "location" {
  type        = string
  description = "The region to deploy the reasoning engine"
  default     = "us-central1"
}

variable "repository_name" {
  type        = string
  description = "The Artifact Registry repository name"
  default     = "agents-repo"
}

variable "image_tag" {
  type        = string
  description = "The tag of the container image to deploy"
  default     = "latest"
}
EOF

ধাপ ৪: মূল কনফিগারেশন তৈরি করুন

main.tf ফাইলে প্রধান রিসোর্স সংজ্ঞার প্যারামিটারগুলো লিখুন: 

cat << 'EOF' > main.tf
locals {
  class_methods = [
    {"api_mode" = "", "name" = "get_session"},
    {"api_mode" = "", "name" = "list_sessions"},
    {"api_mode" = "", "name" = "create_session"},
    {"api_mode" = "", "name" = "delete_session"},
    {"api_mode" = "async", "name" = "async_get_session"},
    {"api_mode" = "async", "name" = "async_list_sessions"},
    {"api_mode" = "async", "name" = "async_create_session"},
    {"api_mode" = "async", "name" = "async_delete_session"},
    {"api_mode" = "async", "name" = "async_add_session_to_memory"},
    {"api_mode" = "async", "name" = "async_search_memory"},
    {"api_mode" = "stream", "name" = "stream_query"},
    {"api_mode" = "async_stream", "name" = "async_stream_query"},
    {"api_mode" = "async_stream", "name" = "streaming_agent_run_with_events"}
  ]
}

# define the resource with the BYOC configuration, set agent_framework to "google-adk" to enable interactive features on the console.
resource "google_vertex_ai_reasoning_engine" "byoc_weather_agent" {
  display_name = "byoc_weather_agent_tf"
  description  = "BYOC weather agent deployed via Terraform"
  project      = var.project_id
  location     = var.location

  spec {
    class_methods = jsonencode(local.class_methods)
    agent_framework = "google-adk"
    container_spec {
      image_uri = "${var.location}-docker.pkg.dev/${var.project_id}/${var.repository_name}/weather-agent-image:${var.image_tag}"
    }
  }
}
EOF

ধাপ ৫: আউটপুট সংজ্ঞা তৈরি করুন

আউটপুটস ব্লকটি outputs.tf ফাইলে লিখুন: 

cat << 'EOF' > outputs.tf
output "reasoning_engine_id" {
  value       = google_vertex_ai_reasoning_engine.byoc_weather_agent.id
  description = "The ID of the deployed reasoning engine"
}

output "reasoning_engine_resource_name" {
  value       = google_vertex_ai_reasoning_engine.byoc_weather_agent.id
  description = "The resource name of the deployed reasoning engine"
}
EOF

ধাপ ৬: ভেরিয়েবলের মান ফাইল (tfvars) তৈরি করুন

প্লেসহোল্ডার সম্পাদনা ছাড়াই ডায়নামিকভাবে ডিপ্লয় করতে, এনভায়রনমেন্ট ভেরিয়েবলগুলো সরাসরি terraform.tfvars এ যুক্ত করুন। 

cat <<EOF > terraform.tfvars
project_id      = "${PROJECT_ID}"
location        = "${LOCATION}"
repository_name = "agents-repo"
image_tag       = "latest"
EOF

ধাপ ৭: প্রারম্ভিকীকরণ এবং প্রয়োগ

টেরাফর্ম চালু করুন এবং কনফিগারেশন প্রয়োগ করুন: 

terraform init
terraform apply

অনুরোধ করা হলে yes টাইপ করে আবেদনটি নিশ্চিত করুন।

কাজটি সম্পন্ন হলে, Terraform রিসোর্সের নামটি আউটপুট করে। প্রোগ্রাম্যাটিকভাবে এটিকে agent_resource_name.txt ফাইলে ক্যাপচার করুন এবং রুট ফোল্ডারে ফিরিয়ে দিন: 

terraform output -raw reasoning_engine_resource_name > ../agent_resource_name.txt
cd ..

৮. এজেন্টকে জিজ্ঞাসা করুন

আপনার এজেন্টটি চালু আছে এবং সাড়া দিচ্ছে কিনা তা যাচাই করুন।

ধাপ ১: কোয়েরি স্ক্রিপ্ট তৈরি করুন

অবস্থানের স্থানাঙ্ক সংগ্রহ করার জন্য একটি ডাইনামিক সেটআপ কনফিগারেশন চেক ব্যবহার করে query_agent.py তে ভেরিফিকেশন স্ক্রিপ্টটি লিখুন: 

cat << 'EOF' > query_agent.py
import json
import os
import requests
from google import auth as google_auth
from google.auth.transport import requests as google_requests

# Load config coordinates directly
config_json = json.load(open("weather_agent/config.json"))
LOCATION = config_json["LOCATION"]
PROJECT_ID = config_json["PROJECT_ID"]

# Load agent resource name
with open("agent_resource_name.txt", "r") as f:
    agent_resource_name = f.read().strip()

def get_identity_token():
    credentials, _ = google_auth.default()
    auth_request = google_requests.Request()
    credentials.refresh(auth_request)
    return credentials.token

# Access the agent at the fastapi endpoint that was specified in main.py
url = f"https://{LOCATION}-aiplatform.googleapis.com/v1/{agent_resource_name}/api/stream_reasoning_engine"

payload = {
    "class_method": "async_stream_query",
    "input": {
        "user_id": "codelab_test_user",
        "message": "What is the temperature in Tokyo?",
    },
}

print(f"Sending query to {url}...")
response = requests.post(
    url,
    headers={
        "Content-Type": "application/json",
        "Authorization": f"Bearer {get_identity_token()}",
    },
    data=json.dumps(payload),
    stream=True,
)

for chunk in response.iter_content(chunk_size=8192):
    if chunk:
        print(chunk.decode('utf-8'))
EOF

কোয়েরি স্ক্রিপ্টটি চালান: 

python3 query_agent.py

আপনি এজেন্ট থেকে আউটপুট ফিরে আসতে দেখবেন, যার মধ্যে টোকিওর জন্য অনুমিত তাপমাত্রাও অন্তর্ভুক্ত থাকবে।

ধাপ ২: কনসোল ব্যবহার করুন

  1. এজেন্ট প্ল্যাটফর্ম > এজেন্ট > ডিপ্লয়মেন্ট নির্বাচন করে ডিপ্লয় করা এজেন্টে নেভিগেট করুন এবং এজেন্টের তালিকা ফিল্টার করুন।

এজেন্টের ছবি

  1. এজেন্টের ড্যাশবোর্ড থেকে প্লেগ্রাউন্ড নির্বাচন করুন।

এজেন্ট ড্যাশবোর্ড

  1. একটি নতুন সেশন তৈরি করুন এবং আপনার কোয়েরি টাইপ করে পরীক্ষা করুন যে এজেন্ট দেখানো অনুযায়ী অনুরোধে সাড়া দিচ্ছে কিনা।

এজেন্ট মিথস্ক্রিয়া

৯. পরিচ্ছন্নতা

চার্জ এড়ানোর জন্য, আপনার তৈরি করা রিসোর্সগুলো পরিষ্কার করুন।

আপনি যদি Terraform ব্যবহার করে ডেপ্লয় করে থাকেন, তাহলে terraform ডিরেক্টরিতে প্রবেশ করুন এবং destroy অ্যাকশনটি চালান: 

cd ~/weather-agent-byoc/terraform
terraform destroy
cd ..

আপনি যদি SDK ব্যবহার করে ডেপ্লয় করে থাকেন, তাহলে ডেপ্লয় করা এজেন্টটি ডিলিট করার জন্য স্ক্রিপ্টটি তৈরি করুন: 

cat << 'EOF' > delete_agent.py
import json
import os
import vertexai
from google.cloud import aiplatform

config = json.load(open("weather_agent/config.json"))
PROJECT_ID = config["PROJECT_ID"]
LOCATION = config["LOCATION"]

vertexai.init(project=PROJECT_ID, location=LOCATION)
client = vertexai.Client(project=PROJECT_ID, location=LOCATION)

with open("agent_resource_name.txt", "r") as f:
    agent_resource_name = f.read().strip()

# 1. Delete the Agent
# Note: We retrieve the list first to ensure we delete the ones created in this session
try:
    page_size = 100
    reasoning_engines = client.agent_engines.list()
    for engine in reasoning_engines:
        if agent_resource_name in engine.api_resource.name:
            print(f"Deleting Reasoning Engine: {engine.api_resource.name}")
            engine.delete(force=True)
except Exception as e:
    print(f"Error deleting reasoning engines: {e}")
EOF

এজেন্টটি মুছে ফেলার জন্য স্ক্রিপ্টটি চালান: 

python3 delete_agent.py

অবশিষ্ট রিসোর্সগুলো পরিষ্কার করতে, আপনার হোম ডিরেক্টরিতে ফিরে যান এবং ক্লাউড শেলে নিম্নলিখিত কমান্ডগুলো চালান: 

cd ~

# 1. Delete the Artifact Registry Repository
gcloud artifacts repositories delete $REPOSITORY_NAME --location=$LOCATION --quiet

# 2. Clean up files (Optional)
rm -rf ~/weather-agent-byoc

১০. উপসংহার

অভিনন্দন! আপনি BYOC ব্যবহার করে এজেন্ট রানটাইমে একটি এআই এজেন্টকে সফলভাবে কন্টেইনারাইজ ও ডেপ্লয় করেছেন।

আপনি শিখেছেন কীভাবে:

  • ADK ব্যবহার করে একটি এজেন্ট সংজ্ঞায়িত করুন এবং FastAPI দিয়ে এটিকে র‍্যাপ করুন।
  • একটি ডকারফাইল তৈরি করুন এবং ক্লাউড বিল্ড ব্যবহার করে ইমেজ বিল্ড করুন।
  • এজেন্ট রানটাইমের জন্য IAM অনুমতিগুলো পরিচালনা করুন।
  • পাইথন এসডিকে এবং টেরাফর্ম উভয় ব্যবহার করে আপনার কাস্টম কন্টেইনার স্থাপন করুন।
  • আপনার ডেপ্লয় করা এজেন্টকে পরীক্ষা ও কোয়েরি করুন।