การรักษาความปลอดภัยการติดตั้งใช้งานระดับองค์กรแบบข้ามระบบคลาวด์

1. บทนำ

ใน Codelab นี้ คุณจะติดตั้งใช้งาน Agent เดียว / เครื่องมือหลายอย่างอย่างปลอดภัยโดยใช้ Agent Development Kit (ADK), Agent Engine และ Google Kubernetes Engine คุณจะได้เรียนรู้วิธีที่ AI Agent ซึ่งผู้ใช้เริ่มต้นใน Gemini Enterprise จะไปยังส่วนต่างๆ ของ Google Cloud ได้อย่างปลอดภัย โดยอาศัย GKE Gateway ที่มีส่วนขยายบริการเพื่อปกปิดข้อมูลที่ละเอียดอ่อนที่ส่งจากคำตอบของเครื่องมือ MCP

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

ติดตั้งใช้งาน Agent ผู้ช่วยด้านสินเชื่อจำนอง ADK ใน Agent Engine ด้วยการวัดคุม OpenTelemetry
ติดตั้งใช้งานเซิร์ฟเวอร์ MCP แบ็กเอนด์ใน Google Kubernetes Engine (GKE) ที่อยู่หลังเกตเวย์ภายใน
เชื่อมต่อ Agent Engine กับ VPC ของโปรเจ็กต์โดยใช้อินเทอร์เฟซ PSC และการเพียร์ DNS
เปิดเผย REST API เป็นเครื่องมือ MCP โดยใช้พร็อกซีการค้นพบ MCP ของ Apigee
กำหนดค่า GKE Gateway สำหรับขาออกของ Agent ที่มีการควบคุมด้วยส่วนขยายบริการสำหรับการปกปิดข้อมูลบางส่วนของ DLP และการให้สิทธิ์ MCP
ใช้แนวทาง AI ด้วย Model Armor เพื่อคัดกรองพรอมต์และคำตอบ

สิ่งที่ต้องมี

เว็บเบราว์เซอร์ เช่น Chrome
โปรเจ็กต์ Google Cloud ที่เปิดใช้การเรียกเก็บเงิน
มีความคุ้นเคยพื้นฐานกับ Terraform, Kubernetes และ Python

Codelab นี้มีไว้สำหรับนักพัฒนาซอฟต์แวร์และผู้เชี่ยวชาญด้านความปลอดภัยที่ต้องการทำให้เวิร์กโฟลว์แบบเอเจนต์ใช้งานได้และรักษาความปลอดภัยในสภาพแวดล้อมขององค์กร

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

สร้างโปรเจ็กต์ Google Cloud และเปิดใช้ API ที่จำเป็น

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

บทบาท IAM ที่จำเป็น

Codelab นี้ถือว่าคุณมีบทบาทเจ้าของโปรเจ็กต์สำหรับโปรเจ็กต์ที่อยู่ในระบบคลาวด์ของ Google

เปิดใช้ API

ในคอนโซล Google Cloud ให้คลิกเปิดใช้งาน Cloud Shell: หากคุณไม่เคยใช้ Cloud Shell มาก่อน บานหน้าต่างจะปรากฏขึ้นเพื่อให้คุณเลือกเริ่ม Cloud Shell ในสภาพแวดล้อมที่เชื่อถือได้โดยมีหรือไม่มีการเพิ่มประสิทธิภาพ หากระบบขอให้คุณให้สิทธิ์ Cloud Shell ให้คลิกให้สิทธิ์

ใน Cloud Shell ให้เปิดใช้ API ที่จำเป็นทั้งหมด

gcloud services enable \
compute.googleapis.com \
container.googleapis.com \
dns.googleapis.com \
certificatemanager.googleapis.com \
dlp.googleapis.com \
aiplatform.googleapis.com \
discoveryengine.googleapis.com \
apigee.googleapis.com

ติดตั้งการอ้างอิง

ใน Cloud Shell ให้ตรวจสอบว่าคุณได้ติดตั้งเครื่องมือที่จำเป็นแล้ว โดยปกติแล้ว Terraform, kubectl และ Go จะได้รับการติดตั้งไว้ล่วงหน้า คุณต้องติดตั้ง uv (ตัวจัดการแพ็กเกจ Python) และ Skaffold โดยทำดังนี้

# Install uv
curl -LsSf https://astral.sh/uv/install.sh | sh

# Install Skaffold
curl -Lo skaffold https://storage.googleapis.com/skaffold/releases/latest/skaffold-linux-amd64 && \
sudo install skaffold /usr/local/bin/

ตั้งค่าตัวแปรสภาพแวดล้อม

ตั้งค่าตัวแปรสภาพแวดล้อมต่อไปนี้ซึ่งใช้ตลอดทั้ง Codelab นี้

export PROJECT_ID=$(gcloud config get project)
export REGION=us-central1
export LOCATION=${REGION}

สร้างโซน DNS สาธารณะ

Codelab นี้กำหนดให้ต้องมีโซน DNS สาธารณะในโปรเจ็กต์ก่อนที่จะใช้การกำหนดค่า Terraform คุณต้องมีโซนนี้เพื่อการมอบสิทธิ์เนมเซิร์ฟเวอร์ เพื่อให้การตั้งค่าสามารถสร้างระเบียนที่จำเป็นสำหรับ Certificate Manager ได้โดยอัตโนมัติ

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

gcloud dns managed-zones create "inference-gateway-zone" \
    --dns-name="gateway.example.com." \
    --description="Public zone for Inference Gateway" \
    --visibility="public" \
    --project="${PROJECT_ID}"

3. โคลนที่เก็บ GitHub

ในเทอร์มินัลในเครื่อง ให้โคลนcloud-networking-solutionsที่เก็บ
```
git clone https://github.com/googleCloudPlatform/cloud-networking-solutions.git
```
ไปที่ไดเรกทอรีที่เก็บที่ดาวน์โหลดมาโดยใช้คำสั่งต่อไปนี้
```
cd cloud-networking-solutions/demos/service-extensions-gke-gateway
```

4. ติดตั้งใช้งานโครงสร้างพื้นฐานด้วย Terraform

คุณจะใช้ Terraform เพื่อจัดสรรเครือข่ายพื้นฐาน คลัสเตอร์ GKE และการกำหนดค่าข้อมูลประจำตัวที่จำเป็น

ไปที่ไดเรกทอรี terraform ในที่เก็บที่โคลน
```
cd terraform
```
กำหนดค่าแบ็กเอนด์ Terraform สร้างไฟล์ backend.conf สำหรับการกำหนดค่าแบ็กเอนด์บางส่วน แทนที่ ด้วยชื่อ Bucket ที่ไม่ซ้ำกันทั่วโลก
```
cat <<EOF > backend.conf
bucket = "<YOUR_TERRAFORM_STATE_BUCKET>"
prefix = "terraform"
EOF
```

คัดลอกไฟล์ตัวอย่างตัวแปรและอัปเดตด้วยค่าโปรเจ็กต์ของคุณ
```
cp example.tfvars terraform.tfvars
```
แก้ไข terraform.tfvars และแทนที่ค่าตัวยึดตำแหน่ง โดยแทนที่ค่าต่อไปนี้
- project_id: รหัสโปรเจ็กต์ Google Cloud
- organization_id: รหัสองค์กร GCP ที่เป็นตัวเลข
- dns_zone_domain: โดเมนที่คุณควบคุม (เช่น demo.example.com.) ต้องลงท้ายด้วยจุด
ตรวจสอบว่าได้เปิดใช้ค่าสถานะฟีเจอร์ต่อไปนี้แล้ว (ค่าสถานะเหล่านี้ได้รับการกำหนดค่าล่วงหน้าในไฟล์ตัวอย่าง)
- enable_certificate_manager = true
- enable_model_armor = true
- enable_agent_engine = true
- enable_psc_interface = true

เริ่มต้นและใช้การกำหนดค่า Terraform

terraform init -backend-config=backend.conf
terraform plan -out=tfplan
terraform apply "tfplan"

5. ทำให้ภาระงานตัวอย่างใช้งานได้ด้วย Skaffold

จากนั้น ให้ติดตั้งใช้งานเซิร์ฟเวอร์ MCP และบริการประมวลผลภายนอกในคลัสเตอร์ GKE

เชื่อมต่อกับคลัสเตอร์ GKE ที่สร้างโดย Terraform

gcloud container clusters get-credentials gateway-cluster \
    --region=${REGION} \
    --project=${PROJECT_ID}

กลับไปที่รูทของโปรเจ็กต์และกำหนดค่าเทมเพลตไฟล์ Manifest ของ Kubernetes คัดลอกการกำหนดค่าตัวอย่างและตั้งค่ารหัสโปรเจ็กต์และโดเมนฐาน:ตั้งค่า BASE_DOMAIN ให้ตรงกับสภาพแวดล้อมของคุณ BASE_DOMAIN ควรตรงกับตัวแปร dns_zone_domain Terraform (ไม่มีจุดต่อท้าย)
```
export BASE_DOMAIN=example.com
```
สร้างไฟล์ Manifest ของ Kubernetes และ skaffold.yaml จากเทมเพลตโดยทำดังนี้
```
bash k8s/generate.sh
envsubst '${PROJECT_ID}' < skaffold.yaml.tmpl > skaffold.yaml
```
ติดตั้งใช้งานบริการแบ็กเอนด์ทั้งหมด
```
skaffold run -m legacy-dms,income-verification-api,corporate-email,dlp-ext-proc
```
กำหนดค่า Gateway และ HTTPRoute ให้ใช้งานได้โดยทำดังนี้
```
kubectl apply -k k8s/gateway-internal/
```

6. ใช้แนวทาง AI ด้วย Model Armor

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

ข้อกำหนดเบื้องต้น: มอบบทบาท IAM

คุณต้องมอบบทบาทที่จำเป็นให้กับบัญชีบริการของ GKE Gateway บัญชีบริการมีรูปแบบเป็น service-GATEWAY_PROJECT_NUMBER@gcp-sa-dep.iam.gserviceaccount.com

เรียกใช้คำสั่งต่อไปนี้เพื่อมอบสิทธิ์ที่จำเป็น

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

# Grant roles in the Gateway project
gcloud projects add-iam-policy-binding $PROJECT_ID \
 --member=serviceAccount:service-${GATEWAY_PROJECT_NUMBER}@gcp-sa-dep.iam.gserviceaccount.com \
 --role=roles/modelarmor.calloutUser

gcloud projects add-iam-policy-binding $PROJECT_ID \
 --member=serviceAccount:service-${GATEWAY_PROJECT_NUMBER}@gcp-sa-dep.iam.gserviceaccount.com \
 --role=roles/serviceusage.serviceUsageConsumer

# Grant role in the project containing Model Armor templates
gcloud projects add-iam-policy-binding $PROJECT_ID \
 --member=serviceAccount:service-${GATEWAY_PROJECT_NUMBER}@gcp-sa-dep.iam.gserviceaccount.com \
 --role=roles/modelarmor.user

สร้างส่วนขยายการให้สิทธิ์ Model Armor

กำหนดส่วนขยายที่ชี้ไปยังบริการ Model Armor ในภูมิภาคของคุณ บันทึกการกำหนดค่านี้เป็น ma-content-authz-extension.yaml

ส่งออกรหัสเทมเพลต Model Armor ที่สร้างโดย Terraform

export MA_TEMPLATE_ID=$(cd terraform && terraform output -raw model_armor_template_id)

cat >ma-content-authz-extension.yaml <<EOF
name: ma-ext
service: modelarmor.$LOCATION.rep.googleapis.com
metadata:
  model_armor_settings: '[
  {
  "response_template_id": "projects/${PROJECT_ID}/locations/$LOCATION/templates/${MA_TEMPLATE_ID}",
  "request_template_id": "projects/${PROJECT_ID}/locations/$LOCATION/templates/${MA_TEMPLATE_ID}"
  }
  ]'
failOpen: true
EOF

gcloud beta service-extensions authz-extensions import ma-ext \
    --source=ma-content-authz-extension.yaml \
    --location=$LOCATION

สร้างนโยบายการให้สิทธิ์ Model Armor

สร้างนโยบายที่เชื่อมโยงส่วนขยาย Model Armor กับ Agent Gateway บันทึกการกำหนดค่านี้เป็น ma-content-authz-policy.yaml

cat >ma-content-authz-policy.yaml <<EOF
name: ma-content-authz-policy
target:
  resources:
  -   "projects/$PROJECT_ID/locations/$LOCATION/gateways/mortgage-gateway"
policyProfile: CONTENT_AUTHZ
action: CUSTOM
customProvider:
  authzExtension:
    resources:
    -   "projects/$PROJECT_ID/locations/$LOCATION/authzExtensions/ma-ext"
EOF

gcloud network-security authz-policies import ma-content-authz-policy \
    --source=ma-content-authz-policy.yaml \
    --location=$LOCATION

7. กำหนดค่า Gemini Enterprise

เปิดใช้ความสามารถในการสังเกต

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

GOOGLE_CLOUD_AGENT_ENGINE_ENABLE_TELEMETRY=true
OTEL_INSTRUMENTATION_GENAI_CAPTURE_MESSAGE_CONTENT=true
OTEL_TRACES_SAMPLER=parentbased_traceidratio

ดูรายละเอียดเกี่ยวกับการกำหนดค่าการติดตามและช่วงใน Gemini Enterprise ได้ที่จัดการการตั้งค่าการสังเกตการณ์

เปิดใช้ Model Armor ใน Gemini Enterprise

ใช้การกรอง Model Armor กับผู้ช่วย Gemini Enterprise เพื่อคัดกรองทั้งพรอมต์ของผู้ใช้และคำตอบของโมเดล แอป Gemini Enterprise ทั่วโลกต้องใช้เทมเพลต Model Armor ในusหลายภูมิภาค ดังนั้น Terraform จึงติดตั้งเทมเพลตแยกต่างหากเพื่อจุดประสงค์นี้

ดึงชื่อเทมเพลตจากเอาต์พุต Terraform

cd terraform
export GE_MA_TEMPLATE_NAME=$(terraform output -raw model_armor_gemini_enterprise_template_name)

ดึงข้อมูลรหัสแอปของอินสแตนซ์ Gemini Enterprise โดยทำดังนี้

ในคอนโซล Google Cloud ให้ไปที่หน้า Gemini Enterprise
คลิกแอปจากเมนูการนำทาง
คัดลอกรหัสของอินสแตนซ์ Gemini Enterprise

ส่งออกรหัสเป็นตัวแปรสภาพแวดล้อม

export APP_ID=<PASTE_APP_ID>

แก้ไข Assistant เพื่อเปิดใช้ Model Armor โดยทำดังนี้

curl -X PATCH \
  -H "Authorization: Bearer $(gcloud auth print-access-token)" \
  -H "Content-Type: application/json" \
  -H "X-Goog-User-Project: ${PROJECT_ID}" \
  "https://global-discoveryengine.googleapis.com/v1/projects/${PROJECT_ID}/locations/global/collections/default_collection/engines/${APP_ID}/assistants/default_assistant?update_mask=customerPolicy" \
  -d '{
    "customerPolicy": {
      "modelArmorConfig": {
        "userPromptTemplate": "'"$GE_MA_TEMPLATE_NAME"'",
        "responseTemplate": "'"$GE_MA_TEMPLATE_NAME"'",
        "failureMode": "FAIL_OPEN"
      }
    }
  }'

ตั้งค่า failureMode เป็น FAIL_OPEN เพื่ออนุญาตคำขอเมื่อ Model Armor ไม่พร้อมใช้งาน หรือตั้งค่าเป็น FAIL_CLOSED เพื่อบล็อกคำขอ

8. ติดตั้งใช้งาน Agent และเพิ่ม Agent ใน Gemini Enterprise

ดูรายละเอียดการให้สิทธิ์

ทำตามขั้นตอนต่อไปนี้เพื่อดูรายละเอียดการให้สิทธิ์

ในคอนโซล Google Cloud ในหน้า API และบริการ ให้ไปที่หน้าข้อมูลเข้าสู่ระบบ
ไปที่ข้อมูลเข้าสู่ระบบ
คลิกสร้างข้อมูลเข้าสู่ระบบ แล้วเลือกรหัสไคลเอ็นต์ OAuth
ในส่วนประเภทแอปพลิเคชัน ให้เลือกเว็บแอปพลิเคชัน
ในส่วน URI การเปลี่ยนเส้นทางที่ได้รับอนุญาต ให้เพิ่ม URI ต่อไปนี้

https://vertexaisearch.cloud.google.com/oauth-redirect
https://vertexaisearch.cloud.google.com/static/oauth/oauth.html

คลิกสร้าง
ส่งออกรหัสไคลเอ็นต์และรหัสลับไคลเอ็นต์เพื่อการติดตั้งใช้งาน

export OAUTH_CLIENT_ID=<Client ID>
export OAUTH_CLIENT_SECRET=<Client Secret>

ติดตั้งใช้งานตัวแทนจำนอง

src/mortgage-agent/deploy_agent.py สคริปต์จะทำให้ Agent ของ ADK ใช้งานได้ใน Agent Engine และจะลงทะเบียนใน Gemini Enterprise หรือไม่ก็ได้ ดูข้อมูลเบื้องต้นเกี่ยวกับขั้นตอนการลงทะเบียน Gemini Enterprise ได้ที่ลงทะเบียนและจัดการตัวแทน A2A

ส่งออกตัวแปรจากการติดตั้งใช้งาน Terraform

export VPC_NAME=$(cd terraform && terraform output -raw vpc_name)
export PSC_ATTACHMENT=$(cd terraform && terraform output -raw psc_interface_network_attachment_id)
export DNS_PEERING_DOMAIN=$(cd terraform && terraform output -raw psc_interface_dns_peering_domain)

ติดตั้งการอ้างอิงและติดตั้งใช้งาน

cd src/mortgage-agent
uv sync

ติดตั้งใช้งาน Agent ใน Vertex Agent Engine และลงทะเบียนใน Gemini Enterprise โดยทำดังนี้

uv run python deploy_agent.py \
    --project=${PROJECT_ID} \
    --dms-mcp-url=https://dms.${DNS_PEERING_DOMAIN%%.}/mcp \
    --income-verification-url=https://income-verification.${DNS_PEERING_DOMAIN%%.} \
    --email-mcp-url=https://email.${DNS_PEERING_DOMAIN%%.}/mcp \
    --network-attachment=projects/${PROJECT_ID}/regions/${REGION}/networkAttachments/${PSC_ATTACHMENT} \
    --dns-peering-domain=${DNS_PEERING_DOMAIN} \
    --dns-peering-target-project=${PROJECT_ID} \
    --dns-peering-target-network=${VPC_NAME} \
    --enable-agent-identity \
    --ge-deploy \
    --app-id=${APP_ID} \
    --oauth-client-id=${OAUTH_CLIENT_ID} \
    --agent-name=mortgage-agent

การอ้างอิงแฟล็ก

ธง	ค่าเริ่มต้น	คำอธิบาย
`--project`	`$PROJECT_ID`	รหัสโปรเจ็กต์ GCP
`--dms-mcp-url`	(ต้องระบุ)	URL ของเซิร์ฟเวอร์ DMS MCP
`--income-verification-url`	(ต้องระบุ)	URL ฐานของ Income Verification API; `/mcp` จะต่อท้ายโดยอัตโนมัติ
`--email-mcp-url`	(ต้องระบุ)	อีเมล URL ของเซิร์ฟเวอร์ MCP
`--region`	`$REGION`	ภูมิภาค GCP
`--staging-bucket`	`gs://PROJECT-staging`	Bucket ของ GCS สำหรับการทดสอบ
`--display-name`	`Mortgage Assistant Agent`	ชื่อที่แสดงของเอเจนต์ที่ติดตั้งใช้งาน
`--update`	(ไม่บังคับ)	อัปเดต Agent ที่มีอยู่โดยตรง (ส่งชื่อทรัพยากรแบบเต็ม)
`--network-attachment`	(ไม่บังคับ)	การเชื่อมต่อเครือข่ายสำหรับอินเทอร์เฟซ PSC (เส้นทางแบบเต็มหรือชื่อ)
`--dns-peering-domain`	(ไม่บังคับ)	โดเมน DNS สำหรับการเพียร์ DNS ของ PSC-I (ต้องลงท้ายด้วยจุด)
`--dns-peering-target-project`	(ไม่บังคับ)	โปรเจ็กต์ที่โฮสต์เครือข่าย VPC เป้าหมายสำหรับการเพียร์ DNS
`--dns-peering-target-network`	(ไม่บังคับ)	ชื่อเครือข่าย VPC สำหรับการเพียร์ DNS
`--enable-agent-identity`	`false`	เปิดใช้ข้อมูลเข้าสู่ระบบที่มีสิทธิ์น้อยที่สุดต่อตัวแทน
`--ge-deploy`	`false`	ลงทะเบียน Agent ใน Gemini Enterprise หลังจากติดตั้งใช้งาน
`--app-id`	(ไม่บังคับ)	รหัสเครื่องยนต์ Gemini Enterprise (ต้องระบุเมื่อใช้ `--ge-deploy`)
`--oauth-client-id`	`$OAUTH_CLIENT_ID`	รหัสไคลเอ็นต์ OAuth2 (ต้องระบุเมื่อใช้ `--ge-deploy`)
`--oauth-client-secret`	`$OAUTH_CLIENT_SECRET`	รหัสลับไคลเอ็นต์ OAuth2 (ต้องระบุเมื่อใช้ `--ge-deploy`)
`--model`	`gemini-3.1-flash-lite-preview`	ชื่อโมเดล Gemini สำหรับ Agent
`--agent-name`	`mortgage-agent`	การให้สิทธิ์ Gemini Enterprise และชื่อเอเจนต์
`--ge-deploy-only`	(ไม่บังคับ)	ลงทะเบียนเครื่องมือการให้เหตุผลที่มีอยู่แล้วใน Gemini Enterprise โดยไม่ต้องติดตั้งใช้งานใหม่ (ส่งชื่อทรัพยากรแบบเต็ม)

เพิ่มผู้ใช้ที่มีสิทธิ์

หากต้องการเพิ่มผู้ใช้ที่มีสิทธิ์ไปยังเอเจนต์ ADK โดยใช้คอนโซล Google Cloud โปรดดูเพิ่มหรือแก้ไขผู้ใช้และสิทธิ์ของผู้ใช้

9. ทดสอบ Agent

เมื่อติดตั้งใช้งานและกำหนดค่าเอเจนต์, GKE Gateway และบริการแบ็กเอนด์ทั้งหมดแล้ว ให้ทดสอบโฟลว์ตั้งแต่ต้นจนจบเพื่อยืนยันว่านโยบายความปลอดภัยทำงานได้ตามที่คาดไว้ คุณจะโต้ตอบกับ "mortgage-agent" ภายในอินเทอร์เฟซของ Gemini Enterprise

การเข้าถึง Agent

ไปที่หน้า Gemini Enterprise ในคอนโซล Google Cloud
เลือกแอป Gemini Enterprise ที่คุณกำหนดค่าไว้ก่อนหน้านี้ ซึ่งมีการลงทะเบียน "mortgage-agent"
ในแท็บภาพรวม ให้ไปที่ URL ที่แสดงในส่วน "เว็บแอป Gemini Enterprise พร้อมใช้งานแล้ว"
เลือกแท็บเอเจนต์จากเมนูทางด้านซ้ายที่ชื่อว่าแกลเลอรีเอเจนต์
ตอนนี้คุณควรจะแชทกับ "ตัวแทนผู้ช่วยด้านสินเชื่อที่อยู่อาศัย" ได้แล้ว

กรณีทดสอบที่ 1: "เส้นทางที่ราบรื่น" - สรุปข้อมูลด้วยการปกปิดข้อมูล PII บางส่วน

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

ส่งพรอมต์ต่อไปนี้ไปยังตัวแทนผู้ช่วยด้านการจำนอง

I'm reviewing the Sterling family's current application. Can you summarize their 2024 and 2025 tax returns and verify if their total household income meets our 2026 debt-to-income requirements?

สิ่งที่เกิดขึ้นเบื้องหลัง
- เอเจนต์ใน Gemini Enterprise จะสร้างคำขอไปยังเครื่องมือที่จำเป็น (เช่น ระบบจัดการเอกสาร (DMS) สำหรับแบบแสดงรายการภาษี, API การยืนยันรายได้)
- Model Armor จะตรวจสอบเพย์โหลดของคำขอและการตอบกลับเพื่อหาภัยคุกคาม
- "นโยบายการให้สิทธิ์ตามเนื้อหา" ที่คุณกำหนดค่าจะทริกเกอร์ส่วนขยาย DLP ที่กำหนดเอง (dlp-content-authz-ext) ส่วนขยายนี้จะตรวจสอบข้อมูลที่ดึงมาจากระบบแบ็กเอนด์
- บริการ DLP จะปกปิดข้อมูลส่วนบุคคลที่ระบุตัวบุคคลนั้นได้ (PII) เช่น หมายเลขประกันสังคม (SSN) จากข้อมูลแบบแสดงรายการภาษีก่อนที่จะส่งถึงตัวแทน
ผลลัพธ์ที่คาดไว้: ตัวแทนจะแสดงผลสรุปแบบแสดงรายการภาษีและสถานะการยืนยันรายได้ ที่สำคัญคือให้ตรวจสอบข้อมูลสรุปที่ตัวแทนให้ คุณควรสังเกตว่าข้อมูลที่ละเอียดอ่อน เช่น หมายเลขประจำตัวผู้เสียภาษี (SSN) จะถูกแทนที่ด้วยตัวยึดตำแหน่ง (เช่น [REDACTED]) ซึ่งเป็นการยืนยันการดำเนินการตามนโยบาย DLP ผ่านเกตเวย์

ความสามารถในการสังเกตและการตรวจสอบ

ตลอดการทดสอบเหล่านี้ แพลตฟอร์มตัวแทนและบริการที่เกี่ยวข้องจะรวบรวมข้อมูลการวัดและส่งข้อมูลต่อไปนี้

Cloud Logging: บันทึกโดยละเอียดจาก GKE Gateway, ภาระงาน GKE และบริการอื่นๆ จะแสดงเส้นทางการตรวจสอบคำขอ การประเมินนโยบาย และผลลัพธ์
Cloud Trace: การวัดคุม OpenTelemetry ที่กำหนดค่าไว้ใน Agent และบริการแบ็กเอนด์ช่วยให้คุณเห็นภาพโฟลว์การเรียกทั้งหมดตั้งแต่ Gemini Enterprise ผ่าน GKE Gateway ไปจนถึงเครื่องมือแบ็กเอนด์ ซึ่งมีประโยชน์อย่างยิ่งในการแก้ไขข้อบกพร่องและทำความเข้าใจวงจรคำขอ

ดูการติดตามสำหรับเซสชันของคุณ

ในคอนโซล Google Cloud ให้ไปที่หน้า Vertex AI Agent Engine
ไปที่ Agent Engine อินสแตนซ์ Agent Engine ที่เป็นส่วนหนึ่งของโปรเจ็กต์ที่เลือกจะปรากฏในรายการ คุณใช้ช่องตัวกรองเพื่อกรองรายการตามคอลัมน์ที่ระบุได้
คลิกชื่ออินสแตนซ์ Agent Engine
คลิกแท็บร่องรอย
คุณเลือกมุมมองเซสชันหรือมุมมองช่วงได้
คลิกเซสชันหรือ Span เพื่อตรวจสอบรายละเอียดการติดตาม รวมถึงกราฟแบบมีทิศทางและไม่มีวงจร (DAG) ของ Span อินพุตและเอาต์พุต และแอตทริบิวต์ข้อมูลเมตา

10. ไม่บังคับ: การแปลงรหัส REST API เป็น MCP ด้วย Apigee

แม้ว่าบริการยืนยันรายได้ของเราจะรองรับ Model Context Protocol โดยกำเนิด แต่ระบบเดิมขององค์กรจำนวนมากก็มีเพียง RESTful API ในขั้นตอนนี้ (ไม่บังคับ) คุณจะใช้พร็อกซีการค้นหา MCP ของ Apigee เพื่อแปลงรหัสปลายทาง REST ของบริการยืนยันรายได้เป็นเครื่องมือ MCP ซึ่งจะช่วยให้คุณใช้นโยบายการกำกับดูแล การจำกัดอัตราคำขอ และความปลอดภัยขั้นสูงของ Apigee กับเครื่องมือเดิมได้

ดูข้อมูลเพิ่มเติมได้ที่ภาพรวมของ Apigee MCP

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

ก่อนดำเนินการต่อ โปรดตรวจสอบว่าคุณได้จัดสรรและกำหนดค่า Apigee API Hub แล้ว ทำตามขั้นตอนในเอกสารประกอบของ Provision API Hub เพื่อตั้งค่าและแนบอินสแตนซ์ Apigee

ขั้นตอนที่ 1: สร้างการเชื่อมต่อบริการสำหรับ Apigee

หากต้องการอนุญาตให้ Apigee เข้าถึงบริการภายในที่ทำงานใน GKE คุณต้องสร้างไฟล์แนบบริการ

ค้นหากฎการส่งต่อของ GKE Gateway ภายใน

export RULE_URI=$(gcloud compute forwarding-rules list \
  --filter="loadBalancingScheme=INTERNAL_MANAGED AND target~targetHttpsProxies" \
  --format="value(selfLink.segment(6), region.basename(), name)" | \
  awk '{print "projects/" $1 "/regions/" $2 "/forwardingRules/" $3}')

สร้างไฟล์แนบบริการโดยใช้คำสั่งต่อไปนี้

gcloud compute service-attachments create internal-gke-gateway-apigee \
    --region=${REGION} \
    --target-service=$RULE_URI \
    --connection-preference=ACCEPT_AUTOMATIC \
    --nat-subnets=gateway-psc-subnet

ขั้นตอนที่ 2: เปิดใช้ Apigee ด้วย Terraform

ตอนนี้ให้อัปเดตการกำหนดค่าโครงสร้างพื้นฐานเพื่อจัดสรรองค์กรและอินสแตนซ์ Apigee

ไปที่ไดเรกทอรี terraform
```
cd terraform
```
แก้ไข terraform.tfvars และตั้งค่า enable_apigee = true
ใช้การเปลี่ยนแปลง
```
terraform apply
```

ขั้นตอนที่ 3: กำหนดข้อกำหนด OpenAPI

Apigee ใช้คำจำกัดความ OpenAPI (OAS) มาตรฐานเพื่อค้นหาและแปลงรหัสเครื่องมือ สร้างไฟล์ชื่อ income-verification-oas.yaml ที่มีเนื้อหาต่อไปนี้

openapi: 3.0.0
info:
  title: Income Verification API
  description: Verify applicant income through third-party employer records.
  version: 1.0.0
servers:
  -   url: https://income-verification.internal.${DNS_PEERING_DOMAIN%%.}/api
paths:
  /income-verification/verify:
    post:
      summary: Verify applicant income
      operationId: verifyApplicant
      requestBody:
        required: true
        content:
          application/json:
            schema:
              type: object
              properties:
                first_name:
                  type: string
                last_name:
                  type: string
      responses:
        '200':
          description: Successful verification
          content:
            application/json:
              schema:
                type: object

ขั้นตอนที่ 4: ติดตั้งใช้งานพร็อกซีการค้นหา Apigee MCP

พร็อกซีการค้นหา MCP เป็นพร็อกซี Apigee เฉพาะที่ทำหน้าที่เป็นเซิร์ฟเวอร์ MCP

ใน UI ของ Apigee ให้ไปที่พัฒนา > พร็อกซี API
คลิกสร้างใหม่ แล้วเลือกพร็อกซีการค้นหา MCP
ตั้งชื่อพร็อกซี income-verification-discovery
ในส่วนข้อกำหนด OpenAPI ให้อัปโหลดไฟล์ income-verification-oas.yaml ที่สร้างไว้
ตั้งค่ากลุ่มสภาพแวดล้อมเป็นกลุ่มที่เกตเวย์ภายในเข้าถึงได้
คลิกทำให้ใช้งานได้

(ไม่บังคับ) เพิ่มนโยบายความปลอดภัย

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

ขั้นตอนที่ 5: ยืนยันสิทธิ์เข้าถึงเครื่องมือที่แปลงรหัส

เมื่อติดตั้งใช้งานแล้ว Apigee จะแปลงรหัสปลายทาง POST /verify เป็นเครื่องมือ MCP verifyApplicant โดยอัตโนมัติ

แสดงรายการเครื่องมือที่พร้อมใช้งานผ่านปลายทาง Apigee MCP

curl -X POST https://api.internal.${DNS_PEERING_DOMAIN%%.}/income-verification-discovery/mcp \
  -H "Content-Type: application/json" \
  -d '{
    "jsonrpc": "2.0",
    "id": 1,
    "method": "tools/list",
    "params": {}
  }'

คุณควรเห็นverifyApplicantเครื่องมือในการตอบกลับ ซึ่งแปลงรหัสจากข้อกำหนด REST ตอนนี้คุณสามารถเรียกใช้เครื่องมือนี้ผ่าน Apigee ได้แล้ว และ Apigee จะจัดการการแปลเป็นบริการ REST พื้นฐานพร้อมทั้งใช้นโยบายความปลอดภัยที่คุณกำหนดค่าไว้

ขั้นตอนที่ 6: อัปเดตตัวแทนจำนองให้ใช้ Apigee

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

ระบุ URL ของ Apigee MCP: อุปกรณ์ปลายทางควรเป็นไปตามรูปแบบ https://api.internal.${DNS_PEERING_DOMAIN%%.}/income-verification-discovery/mcp

เรียกใช้สคริปต์การติดตั้งใช้งานอีกครั้ง: ใช้แฟล็ก --update พร้อมกับ --income-verification-url ใหม่ ซึ่งจะอัปเดต Agent ที่มีอยู่ใน Agent Engine โดยไม่ต้องลบออกทั้งหมด

cd src/mortgage-agent

# Update the agent to route income verification through Apigee
uv run python deploy_agent.py \
    --project=${PROJECT_ID} \
    --update \
    --agent-name=mortgage-agent \
    --dms-mcp-url=https://dms.${DNS_PEERING_DOMAIN%%.}/mcp \
    --income-verification-url=https://api.internal.${DNS_PEERING_DOMAIN%%.}/income-verification-discovery/mcp \
    --email-mcp-url=https://email.${DNS_PEERING_DOMAIN%%.}/mcp \
    --network-attachment=projects/${PROJECT_ID}/regions/${REGION}/networkAttachments/${PSC_ATTACHMENT} \
    --dns-peering-domain=${DNS_PEERING_DOMAIN} \
    --dns-peering-target-project=${PROJECT_ID} \
    --dns-peering-target-network=${VPC_NAME} \
    --ge-deploy \
    --app-id=${APP_ID} \
    --oauth-client-id=${OAUTH_CLIENT_ID}

ยืนยันการเปลี่ยนแปลง: กลับไปที่อินเทอร์เฟซ Gemini Enterprise แล้วขอให้เอเจนต์ยืนยันรายได้ของผู้สมัคร
```
"Can you verify the joint income for the Sterlings using the verification service?"
```
ในแท็บการแก้ไขข้อบกพร่องของ Apigee คุณควรเห็นคำขอ JSON-RPC ขาเข้าจาก GKE Gateway ที่แปลงเป็นคำขอ REST POST มาตรฐานไปยังบริการ GKE ในแบ็กเอนด์

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

โปรดลบทรัพยากรที่สร้างขึ้นใน Codelab นี้เมื่อเสร็จสิ้นเพื่อหลีกเลี่ยงการเรียกเก็บเงินกับบัญชี Google Cloud

ลบ Service Attachment หากสร้างด้วยตนเองโดยทำดังนี้
```
gcloud compute service-attachments delete internal-gke-gateway \
    --region=${REGION} --quiet
```
ไปที่ไดเรกทอรี terraform แล้วทำลายทรัพยากรทั้งหมดโดยใช้คำสั่งต่อไปนี้
```
cd terraform
terraform destroy
```
หากต้องการ ให้ลบโปรเจ็กต์ Google Cloud ทั้งหมดโดยทำดังนี้
```
gcloud projects delete ${PROJECT_ID}
```

12. ขอแสดงความยินดี

คุณทำ Codelab นี้เสร็จแล้วและได้เรียนรู้วิธีรักษาความปลอดภัยในการติดตั้งใช้งาน Agentic Enterprise แบบข้ามระบบคลาวด์

สิ่งที่คุณครอบคลุม

ติดตั้งใช้งาน Agent ผู้ช่วยด้านสินเชื่อที่อยู่อาศัย ADK ใน Agent Engine ด้วยการวัดคุม OpenTelemetry
ติดตั้งใช้งานเซิร์ฟเวอร์ MCP แบ็กเอนด์กับ GKE ที่อยู่หลังเกตเวย์ภายใน
เชื่อมต่อ Agent Engine กับ VPC ของโปรเจ็กต์โดยใช้อินเทอร์เฟซ PSC และการเพียร์ DNS
กำหนดค่า GKE Gateway สำหรับขาออกของ Agent ที่มีการควบคุมด้วยการปกปิดข้อมูล DLP และการให้สิทธิ์ MCP
การป้องกัน AI ที่นำไปใช้ได้จริงด้วย Model Armor สำหรับการคัดกรองพรอมต์และคำตอบ
แปลงรหัส REST API เป็น MCP โดยใช้ Apigee MCP Discovery Proxy (ไม่บังคับ)

ขั้นตอนถัดไป

สำรวจ Model Armor
อ่านเกี่ยวกับ Agent Engine
สำรวจ Gemini Enterprise