เปลี่ยนภาษาที่เป็นธรรมชาติให้เป็นการดำเนินการจริงใน Google Cloud ด้วย Gemini + MCP ใน Cloud Run

1. บทนำ

Codelab นี้จะแนะนำวิธีสร้างเซิร์ฟเวอร์ MCP (Model Context Protocol) ที่กำหนดเองโดยใช้ Python, การติดตั้งใช้งานใน Google Cloud Run และการเชื่อมต่อกับ Gemini CLI เพื่อดำเนินการจริงใน Google Cloud Storage โดยใช้ภาษาธรรมชาติ

โฟลว์สถาปัตยกรรม: Gemini CLI → Cloud Run → MCP

e149713a547f4157.png

ลองนึกภาพว่าคุณเปิดเทอร์มินัลและพิมพ์พรอมต์ง่ายๆ ในเอเจนต์ AI เช่น พรอมต์ที่แสดงด้านล่าง

  • List my GCS buckets
  • Create a GCS bucket named <bucket-name>
  • Tell me about the metadata of my GCS object

ระบบคลาวด์จะฟังและดำเนินการภายในไม่กี่วินาที ไม่ต้องใช้คำสั่งที่ซับซ้อน ไม่ต้องสลับแท็บไปมาไม่รู้จบ เพียงแค่ใช้ภาษาธรรมดาๆ ก็เปลี่ยนเป็นการดำเนินการจริงในระบบคลาวด์ได้

สิ่งที่คุณต้องทำ

คุณจะสร้างและทำให้ใช้งานได้เซิร์ฟเวอร์ MCP ที่กำหนดเองซึ่งเชื่อมต่อ Gemini CLI กับ Google Cloud Storage

คุณจะได้รับสิ่งต่อไปนี้

  • สร้างเซิร์ฟเวอร์ MCP ที่ใช้ Python
  • สร้างคอนเทนเนอร์ให้แอปพลิเคชัน
  • ทำให้ใช้งานได้กับ Cloud Run
  • รักษาความปลอดภัยโดยใช้ IAM และโทเค็นระบุตัวตน
  • เชื่อมต่อกับ Gemini CLI
  • ดำเนินการ GCS แบบเรียลไทม์โดยใช้ภาษาธรรมชาติ

สิ่งที่คุณจะได้เรียนรู้

  • MCP (Model Context Protocol) คืออะไรและทำงานอย่างไร
  • วิธีสร้างความสามารถในการเรียกใช้เครื่องมือโดยใช้ Python
  • วิธีทำให้แอปพลิเคชันที่สร้างโดยใช้คอนเทนเนอร์ใช้งานได้กับ Cloud Run
  • วิธีที่ Gemini CLI ผสานรวมกับเซิร์ฟเวอร์ MCP ภายนอก
  • วิธีตรวจสอบสิทธิ์บริการ Cloud Run อย่างปลอดภัย
  • วิธีดำเนินการจริงใน Google Cloud Storage โดยใช้ AI

สิ่งที่คุณต้องมี

  • เว็บเบราว์เซอร์ Chrome
  • บัญชี Gmail
  • โปรเจ็กต์ Google Cloud ที่เปิดใช้การเรียกเก็บเงิน
  • Gemini CLI (ติดตั้งไว้ล่วงหน้าใน Google Cloud Shell)
  • มีความคุ้นเคยพื้นฐานกับ Python และ Google Cloud

Codelab นี้คาดหวังว่าผู้ใช้จะมีความรู้พื้นฐานเกี่ยวกับ Python

2. ก่อนเริ่มต้น

สร้างโปรเจ็กต์

  1. ในคอนโซล Google Cloud ให้เลือกหรือสร้างโปรเจ็กต์ Google Cloud ในหน้าตัวเลือกโปรเจ็กต์
  2. ตรวจสอบว่าได้เปิดใช้การเรียกเก็บเงินสำหรับโปรเจ็กต์ Cloud แล้ว ดูวิธีตรวจสอบว่าได้เปิดใช้การเรียกเก็บเงินในโปรเจ็กต์แล้วหรือไม่
  3. คุณจะใช้ Cloud Shell ซึ่งเป็นสภาพแวดล้อมบรรทัดคำสั่งที่ทำงานใน Google Cloud และโหลด bq ไว้ล่วงหน้า คลิกเปิดใช้งาน Cloud Shell ที่ด้านบนของคอนโซล Google Cloud

รูปภาพปุ่มเปิดใช้งาน Cloud Shell

  1. เมื่อเชื่อมต่อกับ Cloud Shell แล้ว ให้ตรวจสอบว่าคุณได้รับการตรวจสอบสิทธิ์แล้วและตั้งค่าโปรเจ็กต์เป็นรหัสโปรเจ็กต์โดยใช้คำสั่งต่อไปนี้
gcloud auth list
  1. เรียกใช้คำสั่งต่อไปนี้ใน Cloud Shell เพื่อยืนยันว่าคำสั่ง gcloud รู้จักโปรเจ็กต์ของคุณ
gcloud config list project
  1. หากไม่ได้ตั้งค่าโปรเจ็กต์ ให้ใช้คำสั่งต่อไปนี้เพื่อตั้งค่า
gcloud config set project <YOUR_PROJECT_ID>
  1. เปิดใช้ API ที่จำเป็นผ่านคำสั่งที่แสดงด้านล่าง การดำเนินการนี้อาจใช้เวลาสักครู่ โปรดอดทนรอ
gcloud services enable \
  run.googleapis.com \
  artifactregistry.googleapis.com \
  cloudbuild.googleapis.com

หากได้รับแจ้งให้ให้สิทธิ์ ให้คลิก "ให้สิทธิ์" เพื่อดำเนินการต่อ

5e681903144bdfbe.png

เมื่อเรียกใช้คำสั่งสำเร็จ คุณควรเห็นข้อความที่คล้ายกับข้อความที่แสดงด้านล่าง

Operation "operations/..." finished successfully.

หากพลาด API ใดไป คุณก็เปิดใช้ได้เสมอในระหว่างการติดตั้งใช้งาน

โปรดดูคำสั่งและการใช้งาน gcloud ในเอกสารประกอบ

เตรียมโปรเจ็กต์ Python

ในส่วนนี้ คุณจะได้สร้างโปรเจ็กต์ Python ที่จะโฮสต์เซิร์ฟเวอร์ MCP และกำหนดค่าทรัพยากร Dependency สำหรับการทำให้ใช้งานได้ใน Cloud Run

สร้างไดเรกทอรีโปรเจ็กต์

เริ่มต้นด้วยการสร้างโฟลเดอร์ใหม่ชื่อ mcp-on-cloudrun เพื่อจัดเก็บซอร์สโค้ด

mkdir gcs-mcp-server && cd gcs-mcp-server

สร้าง requirements.txt

touch requirements.txt
cloudshell edit ~/gcs-mcp-server/requirements.txt

เพิ่มเนื้อหาต่อไปนี้ลงในไฟล์

fastmcp
google-cloud-storage
google-api-core
pydantic

บันทึกไฟล์

3. สร้างเซิร์ฟเวอร์ MCP

ในส่วนนี้ คุณจะได้สร้างเซิร์ฟเวอร์ MCP ที่แสดงการดำเนินการของ Google Cloud Storage เป็นเครื่องมือที่เรียกใช้ได้

เซิร์ฟเวอร์นี้จะทำสิ่งต่อไปนี้

  • ลงทะเบียนเครื่องมือ MCP
  • เชื่อมต่อกับ Google Cloud Storage
  • เรียกใช้ผ่าน HTTP
  • ทำให้ใช้งานได้กับ Cloud Run

ตอนนี้เรามาสร้างตรรกะ MCP หลักภายใน main.py กัน

ด้านล่างนี้คือโค้ดที่สมบูรณ์ซึ่งกำหนดเครื่องมือหลายอย่างสำหรับการจัดการ Google Cloud Storage ตั้งแต่การแสดงและการสร้างที่เก็บข้อมูล ไปจนถึงการอัปโหลด การดาวน์โหลด และการจัดการ Blob

สร้างไฟล์แอปพลิเคชันหลัก

สร้างไฟล์ใหม่ชื่อ main.py ในไดเรกทอรี mcp-on-cloudrun

touch main.py

เปิดไฟล์โดยใช้ Cloud Shell Editor

cloudshell edit ~/gcs-mcp-server/main.py

เพิ่มแหล่งที่มาต่อไปนี้ลงในเนื้อหาไฟล์ main.py

import asyncio
import logging
import os
from datetime import timedelta
from typing import List, Dict, Any
from fastmcp import FastMCP
from google.cloud import storage
from google.api_core import exceptions

# ---------------------------------------------------------
# 🌐 Initialize MCP
# ---------------------------------------------------------
logging.basicConfig(format="[%(levelname)s]: %(message)s", level=logging.INFO)
logger = logging.getLogger(__name__)

mcp = FastMCP(name="MyEnhancedGCSMCPServer")
# ---------------------------------------------------------
# 1️⃣ Simple Greeting
# ---------------------------------------------------------
@mcp.tool
def sayhi(name: str) -> str:
  """Returns a friendly greetings"""
  return f"Hello {name}! It's a pleasure to connect from your enhanced MCP Server."

# ---------------------------------------------------------
# 2️⃣ List all GCS buckets
# ---------------------------------------------------------
@mcp.tool
def list_gcs_buckets() -> List[str]:
  """Lists all GCS buckets in the project."""
  try:
      storage_client = storage.Client()
      buckets = storage_client.list_buckets()
      return [bucket.name for bucket in buckets]
  except exceptions.Forbidden as e:
      return [f"Error: Permission denied to list buckets. Details: {e}"]
  except Exception as e:
      return [f"An unexpected error occurred: {e}"]

# ---------------------------------------------------------
# 3️⃣ Create a new bucket
# ---------------------------------------------------------
@mcp.tool
def create_bucket(bucket_name: str, location: str = "US") -> str:
  """Creates a new GCS bucket. Bucket names must be globally unique."""
  try:
      storage_client = storage.Client()
      bucket = storage_client.bucket(bucket_name)
      bucket.location = location
      storage_client.create_bucket(bucket)
      return f"✅ Bucket '{bucket_name}' created successfully in '{location}'."
  except exceptions.Conflict:
      return f"⚠️ Error: Bucket '{bucket_name}' already exists."
  except exceptions.Forbidden as e:
      return f"❌ Error: Permission denied to create bucket. Details: {e}"
  except Exception as e:
      return f"❌ Unexpected error: {e}"

# ---------------------------------------------------------
# 4️⃣ Delete a bucket
# ---------------------------------------------------------
@mcp.tool
def delete_bucket(bucket_name: str) -> str:
  """Deletes a GCS bucket."""
  try:
      storage_client = storage.Client()
      bucket = storage_client.bucket(bucket_name)
      bucket.delete(force=True)
      return f"🗑️ Bucket '{bucket_name}' deleted successfully."
  except exceptions.NotFound:
      return f"⚠️ Error: Bucket '{bucket_name}' not found."
  except exceptions.Forbidden as e:
      return f"❌ Error: Permission denied to delete bucket. Details: {e}"
  except Exception as e:
      return f"❌ Unexpected error: {e}"

# ---------------------------------------------------------
# 5️⃣ List objects in a bucket
# ---------------------------------------------------------
@mcp.tool
def list_objects(bucket_name: str) -> List[str]:
  """Lists all objects in a specified GCS bucket."""
  try:
      storage_client = storage.Client()
      blobs = storage_client.list_blobs(bucket_name)
      return [blob.name for blob in blobs]
  except exceptions.NotFound:
      return [f"⚠️ Error: Bucket '{bucket_name}' not found."]
  except Exception as e:
      return [f"❌ Unexpected error: {e}"]
# ---------------------------------------------------------
# Delete file from a bucket
# ---------------------------------------------------------
@mcp.tool
def delete_blob(bucket_name: str, blob_name: str) -> str:
  """Deletes a blob from a GCS bucket."""
  try:
      storage_client = storage.Client()
      bucket = storage_client.bucket(bucket_name)
      blob = bucket.blob(blob_name)
      blob.delete()
      return f"🗑️ Blob '{blob_name}' deleted from bucket '{bucket_name}'."
  except exceptions.NotFound:
      return f"⚠️ Error: Bucket '{bucket_name}' or blob '{blob_name}' not found."
  except exceptions.Forbidden as e:
      return f" Permission denied. Details: {e}"
  except Exception as e:
      return f" Unexpected error: {e}"

# ---------------------------------------------------------
# Get bucket metadata
# ---------------------------------------------------------
@mcp.tool
def get_bucket_metadata(bucket_name: str) -> Dict[str, Any]:
  """Retrieves metadata for a GCS bucket."""
  try:
      storage_client = storage.Client()
      bucket = storage_client.get_bucket(bucket_name)
      return {
          "id": bucket.id,
          "name": bucket.name,
          "location": bucket.location,
          "storage_class": bucket.storage_class,
          "created": bucket.time_created.isoformat() if bucket.time_created else None,
          "updated": bucket.updated.isoformat() if bucket.updated else None,
          "versioning_enabled": bucket.versioning_enabled,
      }
  except exceptions.NotFound:
      return {"error": f" Bucket '{bucket_name}' not found."}
  except Exception as e:
      return {"error": f" Unexpected error: {e}"}

# ---------------------------------------------------------
# Get object metadata
# ---------------------------------------------------------
@mcp.tool
def get_blob_metadata(bucket_name: str, blob_name: str) -> Dict[str, Any]:
  """Retrieves metadata for a specific blob."""
  try:
      storage_client = storage.Client()
      bucket = storage_client.bucket(bucket_name)
      blob = bucket.get_blob(blob_name)
      if not blob:
          return {"error": f" Blob '{blob_name}' not found in '{bucket_name}'."}
      return {
          "name": blob.name,
          "bucket": blob.bucket.name,
          "size": blob.size,
          "content_type": blob.content_type,
          "updated": blob.updated.isoformat() if blob.updated else None,
          "storage_class": blob.storage_class,
          "crc32c": blob.crc32c,
          "md5_hash": blob.md5_hash,
      }
  except exceptions.NotFound:
      return {"error": f" Bucket '{bucket_name}' not found."}
  except Exception as e:
      return {"error": f" Unexpected error: {e}"}

# ---------------------------------------------------------
# 🚀 Entry Point
# ---------------------------------------------------------
if __name__ == "__main__":
  port = int(os.getenv("PORT", 8080))
  logger.info(f"🚀 Starting Enhanced GCS MCP Server on port {port}")
  asyncio.run(
      mcp.run_async(
          transport="http",
          host="0.0.0.0",
          port=port,
      )
  )

บันทึกไฟล์หลังจากเพิ่มโค้ด

ตอนนี้โครงสร้างโปรเจ็กต์ควรมีลักษณะดังนี้

gcs-mcp-server/
├── requirements.txt
└── main.py

มาทำความเข้าใจโค้ดโดยย่อกัน

การนำเข้าและการตั้งค่า:

โค้ดเริ่มต้นด้วยการนำเข้าไลบรารีที่จำเป็น

  • ไลบรารีมาตรฐาน: asyncio สำหรับการดำเนินการแบบไม่พร้อมกัน logging สำหรับการแสดงข้อความสถานะ และ os สำหรับตัวแปรสภาพแวดล้อม
  • FastMCP: เฟรมเวิร์กหลักที่ใช้สร้างเซิร์ฟเวอร์ Model Context Protocol
  • Google Cloud Storage: นำเข้าgoogle.cloud.storageไลบรารีเพื่อโต้ตอบกับ GCS พร้อมกับ exceptions สำหรับการจัดการข้อผิดพลาด

การเริ่มต้น

เรากำหนดค่ารูปแบบการบันทึกเพื่อช่วยแก้ไขข้อบกพร่องและติดตามข้อมูลประจำตัวของเซิร์ฟเวอร์ นอกจากนี้ เรายังกำหนดค่าอินสแตนซ์ของ FastMCP ที่ชื่อ MyEnhancedGCSMCPServer ด้วย ระบบจะใช้ออบเจ็กต์นี้ (mcp) เพื่อลงทะเบียนเครื่องมือ (ฟังก์ชัน) ทั้งหมดที่เซิร์ฟเวอร์แสดง เรากำหนดเครื่องมือต่อไปนี้

  • list_gcs_buckets: ดึงข้อมูลรายการที่เก็บข้อมูลทั้งหมดในโปรเจ็กต์ที่อยู่ในระบบคลาวด์ Google ที่เชื่อมโยง
  • create_bucket: สร้างที่เก็บข้อมูลใหม่ที่มีชื่อและตำแหน่งที่เฉพาะเจาะจง
  • delete_bucket: ลบ Bucket ที่มีอยู่
  • list_objects: แสดงรายการไฟล์ทั้งหมด (Blob) ภายใน Bucket ที่เฉพาะเจาะจง
  • delete_blob: ลบไฟล์ที่เฉพาะเจาะจงรายการเดียวจาก Bucket
  • get_bucket_metadata: แสดงรายละเอียดทางเทคนิคเกี่ยวกับ Bucket (สถานที่ตั้ง คลาสพื้นที่เก็บข้อมูล สถานะการกำหนดเวอร์ชัน เวลาที่สร้าง)
  • get_blob_metadata: แสดงรายละเอียดทางเทคนิคเกี่ยวกับไฟล์ที่เฉพาะเจาะจง (ขนาด ประเภทเนื้อหา แฮช MD5 อัปเดตล่าสุด)

จุดแรกเข้า:

ซึ่งจะกำหนดค่าพอร์ต โดยค่าเริ่มต้นจะเป็น 8080 หากไม่ได้ตั้งค่าไว้ จากนั้นจะใช้ asyncio.run() เพื่อเริ่มเซิร์ฟเวอร์แบบไม่พร้อมกันด้วย mcp.run_async สุดท้ายคือการกำหนดค่าเซิร์ฟเวอร์ให้ทำงานผ่าน HTTP (host 0.0.0.0) เพื่อให้เข้าถึงได้สำหรับคำขอเครือข่ายขาเข้า

4. สร้างคอนเทนเนอร์เซิร์ฟเวอร์ MCP

ในส่วนนี้ คุณจะได้สร้าง Dockerfile เพื่อให้ติดตั้งใช้งานเซิร์ฟเวอร์ MCP ใน Cloud Run ได้

Cloud Run ต้องใช้แอปพลิเคชันที่มีคอนเทนเนอร์ คุณจะกำหนดวิธีสร้างและเริ่มต้นแอปพลิเคชัน

สร้าง Dockerfile

สร้างไฟล์ใหม่ชื่อ Dockerfile

touch Dockerfile

เปิดใน Cloud Shell Editor โดยทำดังนี้

cloudshell edit ~/gcs-mcp-server/Dockerfile

เพิ่มการกำหนดค่า Docker

วางเนื้อหาต่อไปนี้ลงใน Dockerfile

FROM python:3.11-slim
ENV PYTHONDONTWRITEBYTECODE=1
ENV PYTHONUNBUFFERED=1
WORKDIR /app
RUN apt-get update && apt-get install -y \
   build-essential \
   gcc \
   && rm -rf /var/lib/apt/lists/*
RUN pip install --upgrade pip
COPY . .
RUN pip install -r requirements.txt
ENV PORT=8080
EXPOSE 8080
CMD ["python", "main.py"]

บันทึกไฟล์หลังจากเพิ่มเนื้อหา ตอนนี้โครงสร้างโปรเจ็กต์ควรมีลักษณะดังนี้

gcs-mcp-server/
├── requirements.txt
├── main.py
└── Dockerfile

5. การติดตั้งใช้งานกับ Cloud Run

ตอนนี้คุณสามารถทำให้เซิร์ฟเวอร์ MCP ใช้งานได้โดยตรงจากแหล่งที่มา

เรียกใช้คำสั่งต่อไปนี้ใน Cloud Shell

gcloud run deploy gcs-mcp-server \
   --no-allow-unauthenticated \
   --region=us-central1 \
   --source=. \
   --labels=session=buildersdayblr

เมื่อได้รับแจ้ง

  • อนุญาตคำขอที่ไม่ผ่านการตรวจสอบสิทธิ์ไหม → ไม่

Cloud Build จะทำสิ่งต่อไปนี้

  • สร้างอิมเมจคอนเทนเนอร์
  • พุชไปยัง Artifact Registry
  • ทำให้ใช้งานได้กับ Cloud Run

ป้อน Y เพื่อยืนยันว่าสร้างที่เก็บ Artifact Registry ได้

Deploying from source requires an Artifact Registry Docker repository to store built containers. A repository named [cloud-run-source-deploy] in region [us-central1] will be created.

Do you want to continue (Y/n)?  Y

หลังจากทําให้ใช้งานได้สําเร็จแล้ว คุณจะเห็นข้อความว่าทําสําเร็จพร้อม URL ของบริการ Cloud Run

นอกจากนี้ คุณยังยืนยันการติดตั้งใช้งานจากคอนโซล Google Cloud ในส่วน Cloud Run → Services ได้ด้วย

53f95a2aa7a169d6.png

6. การกำหนดค่า Gemini CLI

ตอนนี้เราได้สร้างและติดตั้งใช้งานเซิร์ฟเวอร์ MCP ใน Cloud Run แล้ว

ตอนนี้ก็ถึงเวลาสนุกแล้ว นั่นคือการเชื่อมต่อกับ Gemini CLI และเปลี่ยนพรอมต์ภาษาธรรมชาติเป็นการดำเนินการจริงในระบบคลาวด์

ให้สิทธิ์ผู้เรียกใช้ Cloud Run

เนื่องจากบริการ Cloud Run ของเราเป็นแบบส่วนตัว เราจึงจะตรวจสอบสิทธิ์โดยใช้โทเค็นข้อมูลประจำตัวและกำหนดสิทธิ์ IAM ที่ถูกต้อง

เราได้ติดตั้งใช้งานบริการด้วย --no-allow-unauthenticated ดังนั้นคุณต้องให้สิทธิ์ในการเรียกใช้บริการ

ตั้งค่ารหัสโปรเจ็กต์

export GOOGLE_CLOUD_PROJECT=$(gcloud config get-value project)

มอบบทบาทผู้เรียกใช้ Cloud Run ให้ตัวเองโดยทำดังนี้

gcloud projects add-iam-policy-binding $GOOGLE_CLOUD_PROJECT \
  --member=user:$(gcloud config get-value account) \
  --role='roles/run.invoker'

ซึ่งจะช่วยให้บัญชีของคุณเรียกใช้บริการ Cloud Run ได้อย่างปลอดภัย

สร้างโทเค็นข้อมูลประจำตัว

Cloud Run ต้องใช้โทเค็นข้อมูลประจำตัวสำหรับการเข้าถึงที่ผ่านการตรวจสอบสิทธิ์

สร้างดังนี้

export PROJECT_NUMBER=$(gcloud projects describe $GOOGLE_CLOUD_PROJECT --format="value(projectNumber)")
export ID_TOKEN=$(gcloud auth print-identity-token)

ยืนยันโดยทำดังนี้

echo $PROJECT_NUMBER
echo $ID_TOKEN

คุณจะใช้โทเค็นนี้ในการกำหนดค่า Gemini CLI

กำหนดค่าเซิร์ฟเวอร์ MCP ใน Gemini CLI

เปิดไฟล์การตั้งค่า Gemini CLI โดยทำดังนี้

cloudshell edit ~/.gemini/settings.json

เพิ่มการกำหนดค่าต่อไปนี้

{
 "ide": {
   "enabled": true,
   "hasSeenNudge": true
 },
 "mcpServers": {
   "my-cloudrun-server": {
     "httpUrl": "https://gcs-mcp-server-$PROJECT_NUMBER.asia-south1.run.app/mcp",
     "headers": {
       "Authorization": "Bearer $ID_TOKEN"
     }
   }
 },
 "security": {
   "auth": {
     "selectedType": "cloud-shell"
   }
 }
}

ตรวจสอบเซิร์ฟเวอร์ MCP ที่กำหนดค่าใน Gemini CLI

เปิดใช้ Gemini CLI ในเทอร์มินัล Cloud Shell โดยใช้คำสั่งต่อไปนี้

gemini

คุณจะเห็นเอาต์พุตด้านล่าง

193224319056d340.png

ใน Gemini CLI ให้เรียกใช้คำสั่งต่อไปนี้

/mcp refresh
/mcp list

ตอนนี้คุณควรเห็นว่า gcs-cloudrun-server ได้รับการลงทะเบียนแล้ว ตัวอย่างภาพหน้าจอแสดงอยู่ด้านล่าง

726738c48290fc30.png

7. เรียกใช้การดำเนินการของ Google Storage ผ่านภาษาธรรมชาติ

สร้างที่เก็บข้อมูล

Create a bucket named my-ai-bucket in asia-south1 region

ซึ่งจะแจ้งให้คุณขอสิทธิ์ในการเรียกใช้เครื่องมือ create_bucket จากเซิร์ฟเวอร์ MCP

5ab2225295285077.png

คลิก "อนุญาตครั้งเดียว" แล้วระบบจะสร้าง Bucket ในภูมิภาคที่คุณขอเรียบร้อย

แสดงรายการที่เก็บข้อมูล

หากต้องการแสดงรายการที่เก็บข้อมูล ให้ป้อนพรอมต์ด้านล่าง

List all my GCS buckets

ลบที่เก็บข้อมูล

หากต้องการลบที่เก็บข้อมูล ให้ป้อนพรอมต์ด้านล่าง (แทนที่ <your_bucket_name> ด้วยชื่อที่เก็บข้อมูลของคุณ)

Delete the bucket <your_bucket_name>

รับข้อมูลเมตาของที่เก็บข้อมูล

หากต้องการดูข้อมูลเมตาของที่เก็บข้อมูล ให้ป้อนพรอมต์ด้านล่าง (แทนที่ <your_bucket_name> ด้วยชื่อที่เก็บข้อมูลของคุณ)

Give me metadata of the <your_bucket_name>

8. ล้างข้อมูล

โปรดอ่านทั้งส่วนนี้ก่อนตัดสินใจลบโปรเจ็กต์ Google Cloud เนื่องจากโดยปกติแล้วการดำเนินการนี้จะย้อนกลับไม่ได้

โปรดทำตามขั้นตอนต่อไปนี้เพื่อเลี่ยงไม่ให้เกิดการเรียกเก็บเงินกับบัญชี Google Cloud สำหรับทรัพยากรที่ใช้ในโค้ดแล็บนี้

  • ในคอนโซล Google Cloud ให้ไปที่หน้าจัดการทรัพยากร
  • ในรายการโปรเจ็กต์ ให้เลือกโปรเจ็กต์ที่ต้องการลบ
  • คลิกลบ

ในกล่องโต้ตอบ ให้พิมพ์รหัสโปรเจ็กต์ แล้วคลิกปิดเพื่อลบโปรเจ็กต์อย่างถาวร

การลบโปรเจ็กต์จะหยุดการเรียกเก็บเงินสำหรับทรัพยากรทั้งหมดที่ใช้ภายในโปรเจ็กต์นั้น ซึ่งรวมถึงบริการ Cloud Run และอิมเมจคอนเทนเนอร์ที่จัดเก็บไว้ใน Artifact Registry

หรือหากต้องการเก็บโปรเจ็กต์ไว้แต่ลบบริการที่ใช้งานอยู่ ให้ทำดังนี้

  1. ไปที่ Cloud Run ในคอนโซล Google Cloud
  2. เลือกบริการ gcs-mcp-server
  3. คลิกลบเพื่อนำบริการออก

หรือป้อนคำสั่ง gcloud ต่อไปนี้ในเทอร์มินัล Cloud Shell

gcloud run services delete gcs-mcp-server --region=us-central1

9. บทสรุป

🎉 ยินดีด้วย คุณเพิ่งสร้างเวิร์กโฟลว์ระบบคลาวด์ที่ทำงานด้วยระบบ AI รายการแรก

คุณได้ติดตั้งใช้งานสิ่งต่อไปนี้

  • เซิร์ฟเวอร์ MCP ที่กำหนดเองซึ่งใช้ Python
  • ความสามารถในการเรียกใช้เครื่องมือสำหรับ Google Cloud Storage
  • การขนส่งด้วยคอนเทนเนอร์โดยใช้ Docker
  • การติดตั้งใช้งานกับ Cloud Run อย่างปลอดภัย
  • การตรวจสอบสิทธิ์ตามข้อมูลระบุตัวตน
  • การผสานรวมกับ Gemini CLI

ตอนนี้คุณสามารถขยายสถาปัตยกรรมนี้เพื่อรองรับบริการเพิ่มเติมของ Google Cloud เช่น BigQuery, Pub/Sub หรือ Compute Engine

รูปแบบนี้แสดงให้เห็นว่าระบบ AI สามารถโต้ตอบกับโครงสร้างพื้นฐานของระบบคลาวด์ได้อย่างปลอดภัยผ่านการเรียกใช้เครื่องมือที่มีโครงสร้างได้อย่างไร