สร้าง AI Agent ที่ดำเนินการในนามของผู้ใช้ด้วย Agent Identity และ Auth Manager

1. บทนำ

ตัวแทนที่มีข้อมูลเข้าสู่ระบบของตนเองพร้อมสิทธิ์แบบกว้างจะเห็นข้อมูลของทุกคน ใน Codelab นี้ คุณจะสร้าง Agent ที่เรียกใช้ API ของบุคคลที่สามด้วยข้อมูลเข้าสู่ระบบของผู้ใช้ที่ลงชื่อเข้าใช้ เพื่อให้ Agent เห็นสิ่งที่บุคคลนั้นเห็นเท่านั้นและไม่มีอะไรเพิ่มเติม

โดยคุณจะสร้าง Agent ด้วย Google Agent Development Kit (ADK) และ Gemini Enterprise

โดยเฉพาะอย่างยิ่ง คุณจะได้เรียนรู้วิธีออกแบบสถาปัตยกรรมข้อมูลประจำตัวแบบคู่ซึ่งมีลักษณะดังนี้

  1. ตัวแทนดำเนินการในนามของตนเอง (ข้อมูลประจำตัวของตัวแทน): ตัวแทนจะเรียกใช้ Auth Manager, จัดเก็บข้อมูลการตรวจวัดระยะไกล และเรียกใช้ Cloud APIs ของ Google โดยใช้ข้อมูลประจำตัวของตัวแทนที่สนับสนุนโดย SPIFFE
  2. ตัวแทนดำเนินการในนามของผู้ใช้ (ข้อมูลประจำตัวที่ได้รับมอบสิทธิ์จากผู้ใช้): หากต้องการเข้าถึงแหล่งข้อมูลภายนอก เช่น GitHub ตัวแทนจะทริกเกอร์ขั้นตอนความยินยอม OAuth แบบ 3 ขา (3LO) เพื่อค้นหาเครื่องมืออย่างปลอดภัยโดยใช้ข้อมูลเข้าสู่ระบบของผู้ใช้

สถาปัตยกรรมข้อมูลประจำตัวแบบคู่

เพื่อให้บรรลุเป้าหมายนี้ คุณจะได้เรียนรู้วิธีทำสิ่งต่อไปนี้

  1. สร้าง Agent ของ ADK ที่เชื่อมต่อกับเซิร์ฟเวอร์ Model Context Protocol (MCP) ของ GitHub
  2. อัปเดตเครื่องมือของ Agent จาก PAT (โทเค็นเพื่อการเข้าถึงส่วนบุคคล) ของ GitHub แบบคงที่เป็นขั้นตอน OAuth แบบ 3 ทาง (3LO) โดยใช้ Google Cloud Auth Manager
  3. ทำให้ Agent ใช้งานได้อย่างปลอดภัยใน Agent Runtime และจัดสรรข้อมูลระบุตัวตนของ Agent
  4. กำหนดค่าบทบาท IAM เพื่อให้ข้อมูลระบุตัวตนของ Agent มีสิทธิ์เข้าถึงห้องนิรภัยของโทเค็นในนามของผู้ใช้
  5. ทำความเข้าใจขั้นตอน 3LO แบบครบวงจรสำหรับ Auth Manager ใน Google Cloud

ข้อกำหนดเบื้องต้น

ก่อนเริ่มต้น โปรดตรวจสอบว่าคุณมีสิ่งต่อไปนี้

  • โปรเจ็กต์ Google Cloud ที่เปิดใช้การเรียกเก็บเงิน
  • Google Cloud SDK (gcloud CLI) ที่ติดตั้งและตรวจสอบสิทธิ์กับโปรเจ็กต์ในเครื่องของคุณ ต้องใช้เวอร์ชัน 586.0.0 ขึ้นไป - เรียกใช้ gcloud components update
  • ติดตั้ง Python 3.10 ถึง 3.13 ไว้ในเครื่อง
  • ติดตั้งเครื่องมือจัดการแพ็กเกจ uv (pip install uv) แล้ว
  • บัญชี GitHub เพื่อลงทะเบียนแอปพลิเคชัน OAuth และสร้างโทเค็น หากไม่มีบัญชี GitHub คุณสามารถใช้เซิร์ฟเวอร์ MCP ของบุคคลที่สามที่รองรับ OAuth 2.0 แบบ 3 ทางแทนได้

2. การตั้งค่าโปรเจ็กต์

1. ตรวจสอบสิทธิ์ใน Google Cloud

ตรวจสอบสิทธิ์ใน Google Cloud จากบรรทัดคำสั่งในเครื่องเพื่อให้แน่ใจว่าสภาพแวดล้อมของคุณมีสิทธิ์ที่จำเป็นในการทำให้ Agent Runtime ใช้งานได้, จัดสรรข้อมูลประจำตัวของ Agent และกำหนดค่า Auth Manager ในระหว่างห้องทดลองนี้

เรียกใช้คำสั่งต่อไปนี้เพื่อลงชื่อเข้าใช้บัญชี Google Cloud, ตั้งค่าโปรเจ็กต์ที่ใช้งานอยู่ (แทนที่ YOUR_PROJECT_ID ด้วยรหัสโปรเจ็กต์ Google Cloud) และกำหนดค่า Application Default Credentials (ADC)

gcloud auth login
gcloud config set project YOUR_PROJECT_ID
gcloud auth application-default login

2. เปิดใช้บริการ Google Cloud ที่จำเป็น

เปิดใช้ API ที่จำเป็นในโปรเจ็กต์ที่อยู่ในระบบคลาวด์ของ Google เพื่อเรียกใช้ห้องทดลองนี้ เรียกใช้คำสั่งต่อไปนี้ในเทอร์มินัล

gcloud services enable \
    agentidentity.googleapis.com \
    agentregistry.googleapis.com \
    aiplatform.googleapis.com \
    apphub.googleapis.com

คำสั่งนี้อาจใช้เวลาสักครู่ในการดำเนินการ เมื่อเสร็จแล้ว ระบบจะกลับไปที่ Command Prompt เพื่อยืนยันว่า API ทำงานอยู่

3. ติดตั้ง CLI ของ Agent และตั้งค่าโปรเจ็กต์

agents-cli เป็นเครื่องมือบรรทัดคำสั่งที่ใช้ในการสร้างโครงสร้าง จัดการ ทดสอบ และติดตั้งใช้งาน Agent ของ ADK ไปยัง Gemini Enterprise ติดตั้งในเครื่อง:

uvx google-agents-cli setup

ยืนยันการติดตั้งโดยทำดังนี้

agents-cli --help

คุณควรเห็นเมนูความช่วยเหลือของ CLI แสดงคำสั่งที่ใช้ได้ (เช่น deploy, run และ status)

สร้างโครงสร้างโปรเจ็กต์เริ่มต้น คุณจะเริ่มต้นด้วยต้นแบบในเครื่องและปรับปรุงในภายหลังสำหรับการติดตั้งใช้งานรันไทม์ของ Agent โดยทำดังนี้

agents-cli create secure-agent-demo --prototype --yes

ซึ่งจะสร้างไดเรกทอรี secure-agent-demo ที่มีโค้ด Agent พื้นฐาน ทรัพยากร Dependency และไฟล์ทดสอบ

4. เพิ่มส่วนเสริม ADK ที่จำเป็น

เพิ่มส่วนเสริม 2 รายการที่ขาดหายไปใน pyproject.toml ที่สร้างขึ้น ได้แก่ mcp สำหรับชุดเครื่องมือ GitHub และ agent-identity สำหรับ Auth Manager ที่จะใช้ในภายหลังในห้องทดลอง เปิด secure-agent-demo/pyproject.toml และแทนที่ทั้ง

google-adk

บรรทัดการขึ้นต่อกันที่มีข้อมูลต่อไปนี้

"google-adk[agent-identity,gcp,mcp,otel-gcp]>=2.5.0,<3.0.0",

จากนั้นติดตั้งรายการต่อไปนี้

cd secure-agent-demo
agents-cli install

3. สร้างและทดสอบ Agent

1. สร้าง Agent

ในโปรเจ็กต์ ให้แทนที่โค้ดใน secure-agent-demo/app/agent.py ด้วยโค้ดต่อไปนี้

# app/agent.py

from google.adk.agents import Agent
from google.adk.apps import App
from google.adk.models import Gemini
from google.genai import types

from app.tools import github_toolset

import os
import google.auth

_, project_id = google.auth.default()
os.environ["GOOGLE_CLOUD_PROJECT"] = project_id
os.environ["GOOGLE_CLOUD_LOCATION"] = "global"
os.environ["GOOGLE_GENAI_USE_VERTEXAI"] = "True"

INSTRUCTION = """You are the DevOps Assistant. You help developers list and triage their GitHub issues and pull requests.
Your capabilities: You have a GitHub MCP toolset that you can use to perform actions that the user requests.

Rules:
- NEVER write, update, or delete. You are only allowed read access.
- Act on behalf of the signed-in user.
- If a tool returns an authentication or authorization error, guide the user to sign in.
- NEVER fabricate information. Only report real issues returned by tools.
"""

root_agent = Agent(
    name="root_agent",
    model=Gemini(
        model="gemini-3.8-flash",
        retry_options=types.HttpRetryOptions(attempts=3),
    ),
    instruction=INSTRUCTION,
    tools=[github_toolset()],
)

app = App(
    root_agent=root_agent,
    name="app",
)

ไฟล์นี้จะกำหนดองค์ประกอบหลัก 3 อย่างของ Agent ดังนี้

  • คำสั่งของระบบ (INSTRUCTION): กำหนดตัวตน กำหนดขอบเขตของผู้ช่วยให้ทำการคัดแยก GitHub และบังคับใช้กฎความปลอดภัยที่เข้มงวด (เช่น สิทธิ์เข้าถึงแบบอ่านอย่างเดียวและแนะนำผู้ใช้ให้ตรวจสอบสิทธิ์หากเกิดข้อผิดพลาด)
  • การกำหนดค่า Agent (root_agent): สร้างอินสแตนซ์ ADK Agent โดยใช้โมเดล gemini-3.8-flash, กำหนดค่าตรรกะการลองใหม่ของ HTTP และติดตั้งชุดเครื่องมือ GitHub ให้กับ Agent
  • App Wrapper (app): รวม Root Agent ไว้ในคอนเทนเนอร์ ADK App เพื่อให้ติดตั้งใช้งานใน Agent Runtime ได้

2. เพิ่มเครื่องมือ MCP ของ GitHub

Agent จะเชื่อมต่อกับ GitHub โดยใช้ Model Context Protocol (MCP) สร้างไฟล์ใหม่ที่ secure-agent-demo/app/tools.py เพื่อลงทะเบียนพารามิเตอร์การเชื่อมต่อเกตเวย์ MCP คัดลอกและวางโค้ดต่อไปนี้

# app/tools.py

from __future__ import annotations
import os
from google.adk.tools.mcp_tool import McpToolset
from google.adk.tools.mcp_tool.mcp_session_manager import StreamableHTTPConnectionParams

GITHUB_MCP_URL = "https://api.githubcopilot.com/mcp/"
GITHUB_TOKEN = os.environ.get("GITHUB_TOKEN", "")

def github_toolset() -> McpToolset:
    """Returns the McpToolset connecting to the public GitHub Copilot MCP gateway."""
    return McpToolset(
        connection_params=StreamableHTTPConnectionParams(
            url=GITHUB_MCP_URL,
            headers={
                "Authorization": f"Bearer {GITHUB_TOKEN}",
                "X-MCP-Toolsets": "all",
                "X-MCP-Readonly": "true",
            },
        )
    )

ฟังก์ชันนี้จะสร้างเครื่องมือที่เรียกใช้เซิร์ฟเวอร์ MCP ของ GitHub

  • ชุดเครื่องมือ MCP (McpToolset): ค้นหาและลงทะเบียนความสามารถของ GitHub เป็นเครื่องมือ Agent ที่เรียกใช้ได้แบบไดนามิก
  • พารามิเตอร์การเชื่อมต่อ (StreamableHTTPConnectionParams): ชี้ชุดเครื่องมือไปยังเกตเวย์ MCP สาธารณะของ GitHub
  • ส่วนหัวของการให้สิทธิ์: แทรก GITHUB_TOKEN เป็นโทเค็นสำหรับผู้ถือและบังคับใช้โหมดอ่านอย่างเดียว (X-MCP-Readonly: true) โดยตรงที่เลเยอร์การรับส่งข้อมูล

3. ทดสอบในเครื่องด้วย PAT (โทเค็นเพื่อการเข้าถึงส่วนบุคคล) ของ GitHub

วิธีเรียกใช้ Agent ในเครื่องด้วยข้อมูลเข้าสู่ระบบแบบคงที่

  1. สร้างโทเค็นเพื่อการเข้าถึงส่วนตัวแบบละเอียดในหน้าโทเค็นเพื่อการเข้าถึงส่วนตัวของ GitHub โดยทำดังนี้
    • คลิกสร้างโทเค็นใหม่ แล้วตั้งชื่อโทเค็น
    • ในส่วน Repository access ให้เลือก All repositories (หรือเลือกที่เก็บที่ต้องการทดสอบ)
    • ในส่วนสิทธิ์ > ที่เก็บ ให้คลิก +เพิ่มสิทธิ์ แล้วเลือกเนื้อหา ปัญหา และ Pull Request เป็นอ่านอย่างเดียว (ระบบจะตั้งค่าข้อมูลเมตาเป็นอ่านอย่างเดียวโดยอัตโนมัติ)
    • คลิก Generate token แล้วคัดลอกค่าโทเค็นที่สร้างขึ้น (หรือหากคุณใช้โทเค็นเพื่อการเข้าถึงส่วนบุคคล (คลาสสิก) ให้เลือกขอบเขต repo)
  2. ตั้งค่าในสภาพแวดล้อมของคุณโดยทำดังนี้
    export GITHUB_TOKEN="your_github_pat_here"
    
  3. ไปที่โฟลเดอร์ secure-agent-demo (หากยังไม่ได้อยู่ในโฟลเดอร์นั้น) แล้วเริ่ม Playground ในเครื่องโดยทำดังนี้
    cd secure-agent-demo
    agents-cli playground
    
  4. เปิดอินเทอร์เฟซ Playground แล้วเลือกโฟลเดอร์ app จากเมนูแบบเลื่อนลง ในกล่องแชท ให้ลองใช้พรอมต์ที่กำหนดเป้าหมาย เช่น "Get the last 2 GitHub issues reported against my name" หรือ "List my 3 most recently updated repositories" แล้วยืนยันว่า Agent เรียกใช้ชุดเครื่องมือ MCP ของ GitHub และแสดงข้อมูล GitHub ของคุณ หากต้องการทดสอบว่า Agent ใช้โทเค็น PAT เพื่อดำเนินการในนามของคุณจริงหรือไม่ ให้ลองถาม Agent เกี่ยวกับที่เก็บส่วนตัวหรือการมีส่วนร่วมของคุณ

4. กำหนดค่า Auth Manager

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

Google Cloud มี Agent Identity Auth Manager เพื่อแก้ปัญหานี้ เครื่องมือจัดการการตรวจสอบสิทธิ์ Agent Identity เป็นห้องนิรภัยสำหรับข้อมูลเข้าสู่ระบบที่ออกแบบมาเพื่อช่วยปกป้องข้อมูลเข้าสู่ระบบ ซึ่งช่วยให้ตัวแทนตรวจสอบสิทธิ์โดยใช้คีย์ API หรือรหัสไคลเอ็นต์ OAuth และรหัสลับ หรือในนามของผู้ใช้ผ่านการมอบสิทธิ์ OAuth โดยใช้โทเค็นเพื่อการเข้าถึงของผู้ใช้ปลายทาง

ใน Auth Manager คุณสามารถกำหนดค่าผู้ให้บริการตรวจสอบสิทธิ์ที่กำหนดประเภทการตรวจสอบสิทธิ์และข้อมูลเข้าสู่ระบบสำหรับแอปพลิเคชันของบุคคลที่สามที่เฉพาะเจาะจงได้ ผู้ให้บริการตรวจสอบสิทธิ์จะขึ้นอยู่กับภูมิภาค และภูมิภาคต้องตรงกับภูมิภาคที่คุณติดตั้งใช้งาน Agent เวิร์กโฟลว์ Auth Manager ตั้งแต่ต้นจนจบจะทำงานดังนี้

เวิร์กโฟลว์ Auth Manager

  1. การสกัดกั้นความยินยอมแบบไดนามิก: เมื่อตัวแทนพยายามเรียกใช้เครื่องมือในนามของผู้ใช้ ADK จะตรวจสอบ Auth Manager เพื่อหาข้อมูลเข้าสู่ระบบที่ถูกต้องที่มีอยู่ หากไม่มี Auth Manager จะแสดงผล URL การให้สิทธิ์เพื่อเริ่มขั้นตอนความยินยอมของ OAuth แบบ 3 ขา (3LO)
  2. Secure Vault Storage: เมื่อผู้ใช้ปลายทางให้สิทธิ์แอปพลิเคชัน Auth Manager จะสกัดกั้น Callback ของ OAuth โดยอัตโนมัติ และจัดเก็บโทเค็นการเข้าถึงและโทเค็นการรีเฟรชของผู้ใช้ที่ได้ไว้ในห้องนิรภัยของข้อมูลเข้าสู่ระบบที่จัดการโดย Google อย่างปลอดภัย
  3. วงจรโทเค็นอัตโนมัติ: Auth Manager จะจัดการการหมดอายุและการหมุนเวียนโทเค็นในเบื้องหลังแบบจัดการครบวงจร จึงไม่จำเป็นต้องใช้ตรรกะการรีเฟรชโทเค็นด้วยตนเองหรือช่วงพักการใช้งาน
  4. การเรียกใช้เครื่องมือโดยไม่มีข้อมูลลับ: สำหรับการดำเนินการต่อๆ ไป เอเจนต์ (ซึ่งตรวจสอบสิทธิ์ผ่านข้อมูลประจำตัวของเอเจนต์ SPIFFE) จะขอโทเค็นเพื่อการเข้าถึงที่ได้รับมอบสิทธิ์ของผู้ใช้จาก Auth Manager แบบไดนามิกที่รันไทม์ ซึ่งจะทำให้ทั้งโค้ดของไคลเอ็นต์และเอเจนต์ไม่มีข้อมูลลับเลย

ขั้นตอน ก: กำหนดค่า GitHub เป็นผู้ให้บริการตรวจสอบสิทธิ์

เรียกใช้คำสั่ง gcloud ต่อไปนี้เพื่อสร้างผู้ให้บริการตรวจสอบสิทธิ์ GitHub ในโปรเจ็กต์ที่อยู่ในระบบคลาวด์ Google คุณจะระบุรหัสไคลเอ็นต์และรหัสลับในภายหลัง โดย GitHub จะไม่ออกรหัสเหล่านี้จนกว่าจะทราบ URL Callback ของผู้ให้บริการรายนี้

gcloud agent-identity auth-providers create github-oauth-provider \
    --project="YOUR_PROJECT_ID" \
    --location="us-central1" \
    --three-legged-oauth-authorization-url="https://github.com/login/oauth/authorize" \
    --three-legged-oauth-token-url="https://github.com/login/oauth/access_token"

อธิบายผู้ให้บริการเพื่อดึงข้อมูล URL เปลี่ยนเส้นทาง OAuth ที่สร้างขึ้น ดังนี้

gcloud agent-identity auth-providers describe github-oauth-provider \
    --project="YOUR_PROJECT_ID" \
    --location="us-central1"

ฟิลด์คือ redirectUrl ซึ่งซ้อนอยู่ใต้ authProviderTypeParams.threeLeggedOauth หากต้องการอ่านโดยตรง ให้ทำดังนี้

gcloud agent-identity auth-providers describe github-oauth-provider \
    --project="YOUR_PROJECT_ID" --location="us-central1" \
    --format="value(authProviderTypeParams.threeLeggedOauth.redirectUrl)"

ดูเหมือนว่าจะเป็น https://agentidentitycredentials.googleapis.com/v1/projects/YOUR_PROJECT_ID/locations/us-central1/authProviders/github-oauth-provider/oauthcallback

ขั้นตอน ข: ลงทะเบียนแอป OAuth ใน GitHub

  1. ไปที่หน้าการตั้งค่านักพัฒนาซอฟต์แวร์ GitHub เลือกแอป OAuth ในแถบด้านข้างซ้าย แล้วคลิกแอป OAuth ใหม่ (หรือลงทะเบียนแอปพลิเคชันใหม่หากคุณยังไม่ได้สร้างแอปพลิเคชัน)
  2. กรอกข้อมูลในช่องของแบบฟอร์มใบสมัคร OAuth ดังนี้
    • ชื่อแอปพลิเคชัน: ป้อนชื่อแอปพลิเคชัน (เช่น secure-agent-demo)
    • URL ของหน้าแรก: ป้อน URL ของแอปพลิเคชันฟรอนท์เอนด์ (http://localhost:8501 สำหรับการสร้างต้นแบบในเครื่อง คุณสามารถอัปเดตเป็น URL ที่ใช้งานจริงในเวอร์ชันที่ใช้งานจริงได้)
    • Application description: ไม่บังคับ (คุณเว้นว่างไว้ได้)
    • Authorization callback URL (URI การเปลี่ยนเส้นทาง): วาง redirectUrl ที่ดึงมาในขั้นตอน ก
    • เปิดใช้โฟลว์อุปกรณ์: ไม่ต้องเลือก
  3. คลิกลงทะเบียนแอปพลิเคชัน
  4. ในหน้าแอปพลิเคชันที่ได้ ให้คัดลอกรหัสไคลเอ็นต์ แล้วคลิกสร้างรหัสลับไคลเอ็นต์ใหม่ และคัดลอกรหัสลับไคลเอ็นต์ที่สร้างขึ้น บันทึกทั้ง 2 ค่าไว้ เนื่องจากคุณจะต้องใช้เป็น YOUR_GITHUB_CLIENT_ID และ YOUR_GITHUB_CLIENT_SECRET ในขั้นตอนถัดไป

ขั้นตอนที่ 3: เพิ่มข้อมูลเข้าสู่ระบบ GitHub ไปยังผู้ให้บริการตรวจสอบสิทธิ์

แทนที่ YOUR_PROJECT_ID, YOUR_GITHUB_CLIENT_ID และ YOUR_GITHUB_CLIENT_SECRET ด้วยค่าของคุณ แล้วเรียกใช้คำสั่งนี้

gcloud agent-identity auth-providers update github-oauth-provider \
    --project="YOUR_PROJECT_ID" \
    --location="us-central1" \
    --three-legged-oauth-client-id="YOUR_GITHUB_CLIENT_ID" \
    --three-legged-oauth-client-secret="YOUR_GITHUB_CLIENT_SECRET"

คำสั่งจะแสดงผู้ให้บริการพร้อมกับ clientId ที่มองเห็นได้ แต่จะไม่แสดงข้อมูลลับ

👉 เมื่อทำขั้นตอนนี้เสร็จแล้ว ตอนนี้ Google Cloud Auth Manager ได้รับการกำหนดค่าอย่างสมบูรณ์ด้วยข้อมูลเข้าสู่ระบบแอปพลิเคชัน GitHub OAuth ของคุณ ซึ่งจะตั้งค่า Google Cloud ให้ทำหน้าที่เป็นห้องนิรภัยที่ปลอดภัยซึ่งจัดการความยินยอมและวงจรของโทเค็น

5. เปลี่ยนโทเค็น PAT เป็น Auth Manager

เมื่อกำหนดค่า Auth Manager เรียบร้อยแล้ว ขั้นตอนถัดไปคือการอัปเดตโค้ดเครื่องมือของ Agent แทนที่เนื้อหาของ secure-agent-demo/app/tools.py ด้วยโค้ดต่อไปนี้

👉 แทนที่รหัสโปรเจ็กต์และตำแหน่งในตัวแปร OAUTH_PROVIDER_NAME ด้านล่าง

# app/tools.py

from __future__ import annotations
import os
from google.adk.auth.credential_manager import CredentialManager
from google.adk.integrations.agent_identity import GcpAuthProvider, GcpAuthProviderScheme
from google.adk.tools.mcp_tool import McpToolset
from google.adk.tools.mcp_tool.mcp_session_manager import StreamableHTTPConnectionParams

# 1. Register the GCP Auth Provider in the global Credential Manager
CredentialManager.register_auth_provider(GcpAuthProvider())

# 2. Replace YOUR_PROJECT_ID with your project ID.
OAUTH_PROVIDER_NAME = "projects/YOUR_PROJECT_ID/locations/us-central1/authProviders/github-oauth-provider"

# 3. The frontend callback URL where the user is redirected after authorizing GitHub. Resolved from the environment variable.
OAUTH_CONTINUE_URI = os.environ.get(
    "OAUTH_CONTINUE_URI", 
    "http://localhost:8501/validateUserId"
)

def github_toolset() -> McpToolset:
    """Returns the McpToolset using 3LO credentials retrieved via GCP Auth Manager."""
    auth_scheme = GcpAuthProviderScheme(
        name=OAUTH_PROVIDER_NAME,
        # Required to read private repositories. Auth Manager currently supports a
        # single scope for GitHub.
        scopes=["repo"],
        continue_uri=OAUTH_CONTINUE_URI,
    )
    return McpToolset(
        connection_params=StreamableHTTPConnectionParams(
            url="https://api.githubcopilot.com/mcp/",
            headers={
                "X-MCP-Toolsets": "all",
                "X-MCP-Readonly": "true",
            },
        ),
        auth_scheme=auth_scheme,
    )

ทำความเข้าใจโค้ดของเครื่องมือ

คีย์ที่เลือกคือ auth_scheme การแนบเครื่องมือนี้กับชุดเครื่องมือหมายความว่าเมื่อใดก็ตามที่ Agent เรียกใช้ GitHub ADK จะขอโทเค็นของผู้ใช้รายนั้นจาก Auth Manager ก่อน และหากยังไม่มีโทเค็น ระบบจะแจ้งให้ผู้ใช้ลงชื่อเข้าใช้แทนที่จะดำเนินการไม่สำเร็จ GITHUB_TOKEN ที่ฮาร์ดโค้ดไว้จะหายไปทั้งหมด

6. ทำให้ Agent ใช้งานได้ใน Agent Runtime

เมื่อเราอัปเดตเครื่องมือ MCP ของ GitHub ให้ใช้ Auth Manager แทนแล้ว ขั้นตอนถัดไปคือการติดตั้งใช้งาน Agent ใน Agent Runtime การติดตั้งใช้งานโดยเปิดใช้ข้อมูลระบุตัวตนของ Agent จะจัดสรร SPIFFE ID ที่ไม่ซ้ำกันให้กับ Agent

เริ่มต้นการกำหนดค่าการติดตั้งใช้งานสำหรับโปรเจ็กต์ ตรวจสอบว่าเทอร์มินัลอยู่ในไดเรกทอรีรากของโปรเจ็กต์ secure-agent-demo แล้วเรียกใช้คำสั่งต่อไปนี้

agents-cli scaffold enhance . --deployment-target agent_runtime --prototype --yes

คำสั่งนี้จะตรวจสอบโครงสร้างโปรเจ็กต์เพื่อดูความเข้ากันได้กับ ADK, เตรียมการกำหนดค่าแพ็กเกจคอนเทนเนอร์ที่เกี่ยวข้อง และสร้างไฟล์ agents-cli-manifest.yaml ในรูทของโปรเจ็กต์ที่ป้อนข้อมูลการตั้งค่าการติดตั้งใช้งานเริ่มต้นไว้ล่วงหน้า

👉 เปิดไฟล์ agents-cli-manifest.yaml ที่สร้างขึ้นใหม่ แล้วยืนยันหรืออัปเดตช่อง region เป็น us-central1 เพื่อให้แน่ใจว่าตัวแทนของคุณได้รับการติดตั้งใช้งานในภูมิภาคเดียวกับผู้ให้บริการตรวจสอบสิทธิ์

region: "us-central1"

ทำให้ Agent ใช้งานได้ด้วยข้อมูลระบุตัวตนของ Agent

ทำให้ใช้งานได้ด้วย adk deploy agent_engine ซึ่งจะจัดสรร Agent ด้วยข้อมูลประจำตัวของ Agent ของตนเอง ซึ่งเป็นข้อมูลประจำตัวด้านการเข้ารหัสที่ได้รับการสนับสนุนโดย SPIFFE และไม่ซ้ำกันซึ่งเป็นของการติดตั้งใช้งานนี้ ซึ่ง Agent จะใช้เพื่อตรวจสอบสิทธิ์กับ Auth Manager และบริการอื่นๆ ของ Google Cloud

👉 จากไดเรกทอรี secure-agent-demo ให้แทนที่ YOUR_PROJECT_ID และเรียกใช้คำสั่งต่อไปนี้

# Write a config file inside the `app/` folder instructing Agent Runtime to provision a SPIFFE-backed `AGENT_IDENTITY` for this deployment.
echo '{ "identity_type": "AGENT_IDENTITY" }' > app/.agent_engine_config.json

# Generate the dependency list the build will install
uv export --no-emit-workspace --no-hashes --format requirements.txt \
    --output-file app/requirements.txt

uv run adk deploy agent_engine app \
    --project="YOUR_PROJECT_ID" \
    --region="us-central1"

การติดตั้งใช้งานจะใช้เวลา 2-3 นาทีในการสร้างและอัปโหลดคอนเทนเนอร์ เมื่อเสร็จแล้ว CLI จะพิมพ์ชื่อทรัพยากรที่ติดตั้งใช้งาน จดค่า reasoningEngines/ENGINE_ID ไว้ เนื่องจากคุณต้องใช้ค่านี้เพื่อให้สิทธิ์ Agent และชี้ไคลเอ็นต์ UI ไปที่ค่าดังกล่าว

ให้สิทธิ์ข้อมูลระบุตัวตนของ Agent

เมื่อ Agent ทำงานในระบบคลาวด์แล้ว Agent จะต้องได้รับสิทธิ์เข้าถึงข้อมูลเข้าสู่ระบบที่จัดเก็บไว้ใน Auth Manager โดยค่าเริ่มต้น ข้อมูลประจำตัว SPIFFE ของ Agent จะไม่มีสิทธิ์เข้าถึงทรัพยากรระบบคลาวด์ภายนอก

เรียกใช้คำสั่ง gcloud ต่อไปนี้เพื่อมอบบทบาท roles/agentidentity.user ให้กับข้อมูลประจำตัวของ Agent ในทรัพยากรของผู้ให้บริการตรวจสอบสิทธิ์ ซึ่งจะให้สิทธิ์ที่จำเป็นแก่ Agent ในการขอโทเค็นผู้ใช้จากห้องนิรภัย และไม่มีสิทธิ์อื่นๆ เพิ่มเติม

# Get YOUR_ORG_ID
gcloud projects get-ancestors $(gcloud config get-value project) \
  --filter="type=organization" \
  --format="value(id)"

# Get YOUR_PROJECT_NUMBER
gcloud projects describe $(gcloud config get-value project) \
  --format="value(projectNumber)"

จากนั้นเชื่อมโยงนโยบาย IAM กับผู้ให้บริการตรวจสอบสิทธิ์ (แทนที่ YOUR_PROJECT_ID และ --member Principal) ดังนี้

gcloud agent-identity auth-providers add-iam-policy-binding github-oauth-provider \
    --project="YOUR_PROJECT_ID" \
    --location="us-central1" \
    --role="roles/agentidentity.user" \
    --member="principal://agents.global.org-YOUR_ORG_ID.system.id.goog/resources/aiplatform/projects/YOUR_PROJECT_NUMBER/locations/us-central1/reasoningEngines/YOUR_ENGINE_ID"

👉 คุณยังดูค่า --member="principal://..." แบบเต็มสำหรับ Agent ที่ติดตั้งใช้งานได้จากคอนโซล Google Cloud โดยไปที่คอนโซล Agent Runtime เลือก Agent ที่ติดตั้งใช้งาน ไปที่แท็บข้อมูลประจำตัว แล้วคัดลอกสตริง principal://... แบบเต็มโดยตรง

ตอนนี้ให้มอบบทบาทเดียวกันนี้แก่บัญชีของคุณเองในผู้ให้บริการ ไคลเอ็นต์ UI ที่คุณเรียกใช้ในขั้นตอนถัดไปจะเรียก API การสรุปข้อมูลเข้าสู่ระบบด้วยข้อมูลรับรองเริ่มต้นของแอปพลิเคชัน ดังนั้นหากไม่มีข้อมูลนี้ ขั้นตอนขอความยินยอมจะดำเนินการไม่สำเร็จโดยมีข้อผิดพลาด 403 ใน agentidentity.authProviders.retrieveCredentials:

gcloud agent-identity auth-providers add-iam-policy-binding github-oauth-provider \
    --project="YOUR_PROJECT_ID" \
    --location="us-central1" \
    --role="roles/agentidentity.user" \
    --member="user:YOUR_EMAIL_ADDRESS"

7. ทำความเข้าใจขั้นตอนความยินยอมของ 3LO

เมื่อติดตั้งใช้งาน Agent ใน Agent Runtime ด้วยข้อมูลประจำตัวของ Agent ที่ปลอดภัยแล้ว ขั้นตอนถัดไปคือการจัดเตรียมอินเทอร์เฟซฟรอนต์เอนด์ที่กำหนดเองเพื่อให้ผู้ใช้แชทกับ Agent ได้ ที่สำคัญกว่านั้นคือ Google Cloud Auth Manager ต้องใช้ Callback Handler ของแอปพลิเคชันไคลเอ็นต์เพื่อดำเนินการวนซ้ำการตรวจสอบสิทธิ์ให้เสร็จสมบูรณ์

แม้ว่า Google Cloud Auth Manager จะจัดการข้อมูลเข้าสู่ระบบของผู้ใช้ภายในห้องนิรภัยได้อย่างปลอดภัย แต่ก็ไม่สามารถดำเนินการแลกเปลี่ยนโทเค็น OAuth ให้เสร็จสมบูรณ์ได้ด้วยตนเอง แฮนด์เชค 3LO อาศัยแอปพลิเคชันไคลเอ็นต์เพื่อเชื่อมช่องว่าง ดังนี้

  1. เมื่อผู้ใช้ให้สิทธิ์แอป GitHub แล้ว GitHub จะเปลี่ยนเส้นทางผู้ใช้กลับไปยังredirectUrlของผู้ให้บริการตรวจสอบสิทธิ์ Agent Identity
  2. จากนั้น Auth Manager จะเปลี่ยนเส้นทางป๊อปอัปเบราว์เซอร์ของผู้ใช้กลับไปยัง URL ของ Callback ฝั่งไคลเอ็นต์ (continue_uri)
  3. แอปพลิเคชันไคลเอ็นต์มีหน้าที่รับผิดชอบในการสกัดกั้นการเปลี่ยนเส้นทางนี้ อ่าน Nonce จากคุกกี้ของเบราว์เซอร์ และเรียกใช้ปลายทาง credentials:finalize ของ Google Cloud เพื่อทำการแฮนด์เชคให้เสร็จสมบูรณ์
  4. เมื่อไคลเอ็นต์สรุปการแลกเปลี่ยนแล้ว Google Cloud จะบันทึกโทเค็นไว้ในห้องนิรภัยของผู้ให้บริการตรวจสอบสิทธิ์อย่างปลอดภัย ซึ่งช่วยให้ Agent เรียกใช้เครื่องมือ GitHub ได้

หากไม่มีไคลเอ็นต์ที่กำหนดเองนี้ซึ่งโฮสต์ปลายทาง Callback การแฮนด์เชคจะไม่สมบูรณ์ และห้องนิรภัยจะจัดเก็บข้อมูลเข้าสู่ระบบไม่ได้

ขั้นตอน OAuth 3LO แบบอินเทอร์แอกทีฟครอบคลุมหลายเลเยอร์ วงจรการดำเนินการทั้งหมดของคำขอเครื่องมือมีดังนี้ เราจะอธิบายเรื่องนี้ในคำอธิบายด้านล่างและในขั้นตอนถัดไป

👉 คลิกรูปภาพเพื่อขยาย

ขั้นตอนตามลำดับของ OAuth แบบ 3 Legged

ความรับผิดชอบหลักของลูกค้าในการส่งมอบงาน

  • ส่งต่อคำถามเพื่อขอความยินยอม (ขั้นตอนที่ 5-6): ตัวแทนจะส่ง adk_request_credential ที่มี URL ความยินยอมและ Nonce แบบใช้ครั้งเดียว จากนั้นไคลเอ็นต์จะเปิดป๊อปอัปและจัดเก็บ Nonce เป็นคุกกี้
  • โฮสต์ Callback การเปลี่ยนเส้นทาง (ขั้นตอนที่ 10-11): /validateUserId ซึ่ง Auth Manager จะส่งป๊อปอัปหลังจากได้รับความยินยอม
  • สรุปโทเค็น (ขั้นตอนที่ 12-14): รวมสถานะการตรวจสอบความถูกต้องจากการเปลี่ยนเส้นทางกับ Nonce ที่แคชไว้ แล้วเรียกใช้ credentials:finalize ซึ่งจะจัดเก็บโทเค็นไว้ในห้องนิรภัย

การสร้างไคลเอ็นต์ของคุณเอง

คุณไม่จำเป็นต้องเขียนไคลเอ็นต์นี้สำหรับห้องทดลอง เนื่องจากขั้นตอนถัดไปจะเรียกใช้ไคลเอ็นต์ที่สร้างไว้ล่วงหน้า เมื่อคุณนำไปใช้ในแอปพลิเคชันของคุณเอง คุณจะใช้ข้อมูลอ้างอิง 2 รายการต่อไปนี้

8. เรียกใช้ไคลเอ็นต์ UI ในเครื่อง

ตามที่ติดตามในแผนภาพลำดับขั้นตอนความยินยอมของ 3LO Auth Manager จะเปลี่ยนเส้นทางหน้าต่างเบราว์เซอร์กลับไปยังปลายทาง Callback ฝั่งไคลเอ็นต์ ไคลเอ็นต์ตัวอย่างในที่เก็บ adk-python โฮสต์ปลายทางนั้นที่ /validateUserId ดาวน์โหลดและเรียกใช้ในเครื่องโดยทำตามขั้นตอนต่อไปนี้

ดาวน์โหลดไฟล์ไคลเอ็นต์

ไดเรกทอรี contributing/samples/integrations/gcp_auth/client ใน adk-python มีเนื้อหาหลัก 3 รายการ ได้แก่

  • main.py: แบ็กเอนด์ FastAPI ที่เชื่อมต่อกับ Agent Engine ที่ทำให้ใช้งานได้แล้ว และโฮสต์ปลายทาง Callback /validateUserId เพื่อสรุปโทเค็น OAuth
  • static/: ไฟล์ HTML และ JavaScript สำหรับ UI ของแชทในเบราว์เซอร์
  • requirements.txt: แพ็กเกจ Python ที่จำเป็นสำหรับการเรียกใช้เซิร์ฟเวอร์ไคลเอ็นต์

เนื่องจาก adk-python เป็นที่เก็บขนาดใหญ่ ให้ใช้ฟีเจอร์ sparse checkout ของ Git เพื่อดาวน์โหลดเฉพาะโฟลเดอร์ contributing/samples/integrations/gcp_auth/client ดังนี้

  1. ก่อนอื่น ให้ย้ายไดเรกทอรีขึ้น 1 ระดับออกจาก secure-agent-demo เพื่อโคลนไคลเอ็นต์ไปยังโฟลเดอร์ระดับเดียวกัน ดังนี้
    cd ..
    
  2. เรียกใช้คำสั่งต่อไปนี้เพื่อโคลนข้อมูลเมตาของที่เก็บโดยไม่ต้องดาวน์โหลดไฟล์ทั้งหมด (--no-checkout) จำกัดเส้นทางการชำระเงินไว้ที่ contributing/samples/integrations/gcp_auth/client และชำระเงินเฉพาะโฟลเดอร์นั้น
    git clone --filter=blob:none --no-checkout https://github.com/google/adk-python.git
    cd adk-python
    git sparse-checkout init --cone
    git sparse-checkout set contributing/samples/integrations/gcp_auth/client
    git checkout
    

เรียกใช้ไคลเอ็นต์

  1. จากภายในไดเรกทอรี adk-python ที่คุณเพิ่งป้อน ให้ไปที่โฟลเดอร์ client โดยทำดังนี้
    cd contributing/samples/integrations/gcp_auth/client
    
  2. สร้างและเปิดใช้งานสภาพแวดล้อมเสมือนของ Python จากนั้นติดตั้งทรัพยากร Dependency ของไคลเอ็นต์จาก requirements.txt โดยทำดังนี้
    uv venv --python 3.13 .venv
    source .venv/bin/activate
    uv pip install --python .venv/bin/python -r requirements.txt
    
  3. ตั้งค่าตัวแปรสภาพแวดล้อมที่ชี้ไคลเอ็นต์ไปยังโปรเจ็กต์ที่อยู่ในระบบคลาวด์ Google Cloud, ภูมิภาค (us-central1) และรหัส Agent Engine ที่ติดตั้งใช้งาน (YOUR_ENGINE_ID) จากนั้นเริ่มเซิร์ฟเวอร์ FastAPI ในเครื่องบนพอร์ต 8501 ดังนี้
    export GOOGLE_CLOUD_PROJECT=YOUR_PROJECT_ID
    export GOOGLE_CLOUD_LOCATION=us-central1
    export AGENT_ID=YOUR_ENGINE_ID
    
    .venv/bin/uvicorn main:app --port 8501
    
  4. ยืนยันว่าเซิร์ฟเวอร์เริ่มต้นเรียบร้อยแล้วและกำลังรอรับการเชื่อมต่อที่ http://localhost:8501

9. ทดสอบขั้นตอน OAuth

เมื่อติดตั้งใช้งานบริการทั้งหมด กำหนดค่าการเชื่อมโยง IAM และตั้งค่าตัวแปรสภาพแวดล้อมแล้ว คุณก็พร้อมที่จะทดสอบขั้นตอนการให้สิทธิ์ที่ได้รับมอบสิทธิ์จากผู้ใช้แบบครบวงจรที่ปลอดภัยแล้ว

ขั้นตอน ก: เริ่มการดำเนินการเครื่องมือ

  1. เปิดแท็บเบราว์เซอร์และไปที่ URL ของไคลเอ็นต์: http://localhost:8501
  2. ในแผงด้านซ้ายในส่วนการตั้งค่าการกำหนดค่า ให้ตั้งค่าประเภท Agent เป็น Remote Agent (Vertex AI) (หรือ Remote Agent Engine)
  3. ป้อนรหัสโปรเจ็กต์และตำแหน่ง (us-central1) ของ Google Cloud แล้วคลิกโหลด Agent ระยะไกล ซึ่งจะโหลด Agent ที่ติดตั้งใช้งานในโปรเจ็กต์
  4. เลือก Agent app ที่ติดตั้งใช้งานจากเมนูแบบเลื่อนลงเลือกเครื่องมือ แล้วคลิกบันทึกและใช้การตั้งค่า
  5. ในกล่องแชท ให้พิมพ์คำค้นหาที่กำหนดเป้าหมาย (เช่น การดึงข้อมูลปัญหาหรือที่เก็บข้อมูลล่าสุด) ดังนี้
    Get the last 2 GitHub issues reported against my name
    
    (หรือลองใช้ "List my 3 most recently updated repositories") แล้วกด Enter
  6. สังเกต UI ของแชท: เนื่องจาก Agent ยังไม่มีข้อมูลเข้าสู่ระบบสำหรับเซสชันของผู้ใช้ จึงได้รับคำถามในการตรวจสอบสิทธิ์และแสดงการ์ด "ต้องมีการตรวจสอบสิทธิ์" ในชุดข้อความการสนทนา
  1. หน้าต่างป๊อปอัปของเบราว์เซอร์แยกต่างหากจะเปิดขึ้น โดยเปลี่ยนเส้นทางคุณผ่าน Auth Manager ของ Google Cloud ไปยังหน้าการให้สิทธิ์ OAuth ของ GitHub
  2. ตรวจสอบสิทธิ์ที่ขอ แล้วคลิกให้สิทธิ์
  3. GitHub จะเปลี่ยนเส้นทางกลับไปยัง Google Cloud ซึ่งจะเปลี่ยนเส้นทางป๊อปอัปไปยัง localhost URL Callback /validateUserId ของคุณ
  4. บริการ Callback จะประมวลผลและสรุปการแฮนด์เชคข้อมูลเข้าสู่ระบบ

ขั้นตอน ค: ดำเนินการต่อ

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

ขั้นตอนที่ 4: ตรวจสอบบันทึกของระบบคลาวด์

วิธียืนยันว่าการแลกเปลี่ยนโทเค็นและการสรุปผลได้รับการประมวลผลอย่างปลอดภัย

  1. ไปที่ Logs Explorer ของคอนโซล Google Cloud
  2. ค้นหาบันทึกของเซิร์ฟเวอร์ที่ยืนยันการดึงข้อมูล Nonce และการตรวจสอบที่สำเร็จ โดยทำดังนี้
    INFO:secure-agent-client:Caching consent nonce for session_id: session-xxxxxxx
    INFO:secure-agent-client:Successfully finalized auth provider credentials.
    
  3. ตรวจสอบบันทึกรันไทม์ของ Agent: หรือจะดูบันทึกการดำเนินการโดยตรงในคอนโซลแพลตฟอร์ม Agent ก็ได้ โดยทำดังนี้
    • ไปที่คอนโซล Agent Runtime
    • คลิก Agent ที่ติดตั้งใช้งานจากรายการ
    • เปลี่ยนไปที่แท็บ Playground ซึ่งจะแสดงบันทึกของ Agent แบบเรียลไทม์ในแผงด้านล่าง โดยแสดงลูปการให้เหตุผลของ Agent, รายละเอียดการดำเนินการของเครื่องมือ และวงจรการดึงข้อมูลโทเค็นแบบเรียลไทม์

10. ล้าง

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

# Follow the instructions here to delete the deployed Agent Runtime resource
# https://docs.cloud.google.com/gemini-enterprise-agent-platform/scale/runtime/manage-deployed-agents#console_3

# Delete the auth provider
gcloud agent-identity auth-providers delete github-oauth-provider \
    --project=YOUR_PROJECT_ID --location=us-central1

# Note: deleted providers sit in soft-delete for 30 days, and the name is not
# reusable until roughly a day after that. Pick a fresh name if you repeat this lab.

# Optionally, you could also delete your Google Cloud Project
gcloud projects delete YOUR_PROJECT_ID

# Optionally, delete the GitHub PAT Token and the OAuth app: 
# https://github.com/settings/personal-access-tokens

ล้างไฟล์ในเครื่อง

หรือจะล้างสภาพแวดล้อมในเครื่องให้สมบูรณ์ก็ได้ โดยทำดังนี้

  1. หยุดเซิร์ฟเวอร์ uvicorn ในเครื่องโดยกด Ctrl+C ในเทอร์มินัลที่เซิร์ฟเวอร์ทำงานอยู่
  2. นำไดเรกทอรีโปรเจ็กต์ที่สร้างขึ้นระหว่างห้องทดลองนี้ออก โดยทำดังนี้
# cd to the correct folder
rm -rf secure-agent-demo client adk-python

11. ยินดีด้วย

คุณสร้างและรักษาความปลอดภัยให้กับ Agent ที่ดำเนินการในนามของผู้ใช้ที่ลงชื่อเข้าใช้เรียบร้อยแล้ว

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

  • ข้อมูลประจำตัวของระบบ Agent: วิธีที่ Agent ทำงานภายใต้ข้อมูลประจำตัวของบัญชีของตนเองเพื่อเชื่อมต่อกับโครงสร้างพื้นฐาน GCP อย่างปลอดภัย จัดการบันทึกการตรวจวัดระยะไกล และเรียกใช้ API การสรุปข้อมูลเข้าสู่ระบบ
  • ข้อมูลประจำตัวที่ได้รับมอบสิทธิ์จากผู้ใช้: วิธีที่ Agent ขอสิทธิ์ดำเนินการในนามของผู้ใช้บนแพลตฟอร์มภายนอก (เช่น GitHub) โดยทริกเกอร์ขั้นตอนความยินยอม OAuth แบบ 3 ทาง (3LO)
  • การผสานรวมเครื่องมือที่ปลอดภัย: วิธีเชื่อมต่อ Agent ADK กับเซิร์ฟเวอร์ Model Context Protocol (MCP) โดยใช้ Google Cloud Auth Manager เพื่อดึงโทเค็นของผู้ใช้แบบไดนามิกแทนการใช้ข้อมูลลับที่ฮาร์ดโค้ด
  • การกำหนดค่านโยบาย IAM: วิธีตั้งค่าการเชื่อมโยงสิทธิ์แบบละเอียดเพื่ออนุญาตทั้งข้อมูลประจำตัวของรันไทม์ของ Agent และบัญชีของคุณเองในผู้ให้บริการตรวจสอบสิทธิ์

อ่านเพิ่มเติม