หน้านี้ได้รับการแปลโดย Cloud Translation API

Gemini CLI ใน GCE ที่มีปลายทาง Private Service Connect

1. ภาพรวม

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

แล้วจะเกิดอะไรขึ้นหากคุณต้องการใช้ Gemini CLI ในเครื่อง Google Compute Engine แต่ต้องการเชื่อมต่อกับ API แบบส่วนตัว ใน Codelab นี้ คุณจะได้ดูวิธีกำหนดค่าปลายทาง Private Service Connect ไปยัง Google API เพื่อกำหนดเส้นทางการเข้าชมไปยังที่อยู่ IP ภายในที่คุณระบุ

การกำหนดค่าจะเป็นการผสมผสานระหว่าง Terraform, gcloud และคอนโซล

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

ตั้งค่าอินสแตนซ์ VM และ Cloud NAT
ติดตั้ง Gemini CLI และตรวจสอบสิทธิ์
กำหนดค่าปลายทาง Private Service Connect เพื่อเชื่อมต่อกับ Googleapis
ยืนยันเส้นทางการเชื่อมต่อไปยัง *.googleais
กำหนดค่ารายการ DNS ด้วยตนเอง

ในแล็บนี้ คุณจะได้สร้างรูปแบบต่อไปนี้

รูปที่ 1

2. การตั้งค่าบริการ Google Cloud

การตั้งค่าสภาพแวดล้อมแบบเรียนรู้ด้วยตนเอง

ลงชื่อเข้าใช้ Google Cloud Console แล้วสร้างโปรเจ็กต์ใหม่หรือใช้โปรเจ็กต์ที่มีอยู่ซ้ำ หากยังไม่มีบัญชี Gmail หรือ Google Workspace คุณต้องสร้างบัญชี

ชื่อโปรเจ็กต์คือชื่อที่แสดงสำหรับผู้เข้าร่วมโปรเจ็กต์นี้ ซึ่งเป็นสตริงอักขระที่ Google APIs ไม่ได้ใช้ คุณอัปเดตได้ทุกเมื่อ
รหัสโปรเจ็กต์จะไม่ซ้ำกันในโปรเจ็กต์ Google Cloud ทั้งหมดและเปลี่ยนแปลงไม่ได้ (เปลี่ยนไม่ได้หลังจากตั้งค่าแล้ว) Cloud Console จะสร้างสตริงที่ไม่ซ้ำกันโดยอัตโนมัติ ซึ่งโดยปกติแล้วคุณไม่จำเป็นต้องสนใจว่าสตริงนั้นคืออะไร ใน Codelab ส่วนใหญ่ คุณจะต้องอ้างอิงรหัสโปรเจ็กต์ (โดยปกติจะระบุเป็น PROJECT_ID) หากไม่ชอบรหัสที่สร้างขึ้น คุณอาจสร้างรหัสแบบสุ่มอีกรหัสหนึ่งได้ หรือคุณอาจลองใช้ชื่อของคุณเองและดูว่ามีชื่อนั้นหรือไม่ คุณจะเปลี่ยนแปลงรหัสนี้หลังจากขั้นตอนนี้ไม่ได้ และรหัสจะคงอยู่ตลอดระยะเวลาของโปรเจ็กต์
โปรดทราบว่ายังมีค่าที่ 3 ซึ่งคือหมายเลขโปรเจ็กต์ที่ API บางตัวใช้ ดูข้อมูลเพิ่มเติมเกี่ยวกับค่าทั้ง 3 นี้ได้ในเอกสารประกอบ

จากนั้นคุณจะต้องเปิดใช้การเรียกเก็บเงินใน Cloud Console เพื่อใช้ทรัพยากร/API ของ Cloud การทำตาม Codelab นี้จะไม่เสียค่าใช้จ่ายมากนัก หรืออาจไม่เสียเลย หากต้องการปิดทรัพยากรเพื่อหลีกเลี่ยงการเรียกเก็บเงินนอกเหนือจากบทแนะนำนี้ คุณสามารถลบทรัพยากรที่สร้างขึ้นหรือลบโปรเจ็กต์ได้ ผู้ใช้ Google Cloud รายใหม่มีสิทธิ์เข้าร่วมโปรแกรมช่วงทดลองใช้ฟรีมูลค่า$300 USD

เริ่มต้น Cloud Shell

แม้ว่าคุณจะใช้งาน Google Cloud จากระยะไกลจากแล็ปท็อปได้ แต่ใน Codelab นี้คุณจะใช้ Google Cloud Shell ซึ่งเป็นสภาพแวดล้อมบรรทัดคำสั่งที่ทำงานในระบบคลาวด์

จาก Google Cloud Console ให้คลิกไอคอน Cloud Shell ในแถบเครื่องมือด้านขวาบน

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

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

3. งานที่ 1 ตั้งค่าสภาพแวดล้อมด้วย Terraform

เราจะสร้าง VPC ที่กำหนดเองพร้อมกฎไฟร์วอลล์และเครือข่ายย่อย เปิด Cloud Console แล้วเลือกโปรเจ็กต์ที่จะใช้

เปิด Cloud Shell ที่ด้านบนของคอนโซลทางด้านขวา ตรวจสอบว่าคุณเห็นรหัสโปรเจ็กต์ที่ถูกต้องใน Cloud Shell และยืนยันข้อความแจ้งเพื่ออนุญาตการเข้าถึง
สร้างโฟลเดอร์ชื่อ terraform-build แล้วย้ายไปที่โฟลเดอร์

mkdir terraform-build  && cd terraform-build

สร้างไฟล์ main.tf และ variable.tf

touch main.tf variable.tf

เปลี่ยนไปใช้มุมมองเครื่องมือแก้ไข Cloud Shell เลือกเอดิเตอร์ ตรวจสอบว่าคุณอนุญาตพรอมต์ที่จำเป็นเพื่อให้โหลดอินเทอร์เฟซได้
เมื่อโหลดแล้ว ให้ไปที่ไฟล์ > เปิดโฟลเดอร์ แล้วไปที่ /home/your-user-name/terraform-build แล้วเลือกตกลงเพื่อเปิดโฟลเดอร์ในโปรแกรมแก้ไข
เลือกไฟล์ variable.tf แล้วเพิ่มข้อมูลต่อไปนี้ แทนที่ข้อความ your-project-id-here ด้วยรหัสโปรเจ็กต์จริงของคุณในเครื่องหมายคำพูด

variable "project_id" {
  type = string
  default = "your-project-id-here"
}

variable "network_id" {
  type = string
  default = "gemini-vpc-net"
}

จากนั้นเปิดไฟล์ main.tf เราจะเพิ่มโค้ด Terraform เพื่อดำเนินการต่างๆ ตามที่อธิบายไว้ด้านล่าง

*เปิดใช้ API*	`resource` `"google_project_service"` `"default"`
*สร้าง VPC ชื่อ python-net*	`resource` `"google_compute_network"` `"default"`
*เพิ่มซับเน็ต*	`resource` `"google_compute_subnetwork"` `"default"`
*เพิ่มกฎไฟร์วอลล์ 2 รายการ*	`resource` `"google_compute_firewall"` `"allow_icmp"resource` `"google_compute_firewall"` `"allow_ssh"`

คัดลอกและวางข้อมูลต่อไปนี้ลงในไฟล์ main .tf

resource "google_project_service" "default" {
  for_each = toset([
    "dns.googleapis.com",
    "aiplatform.googleapis.com",
    "servicedirectory.googleapis.com"
  ])

  service            = each.value
  disable_on_destroy = false
}

resource "google_compute_network" "default" {
  project                 = var.project_id
  name                    = var.network_id
  auto_create_subnetworks = false
  mtu                     = 1460
  routing_mode            = "GLOBAL"
}

resource "google_compute_subnetwork" "default" {
  name          = "vm1-subnet"
  ip_cidr_range = "192.168.100.0/24"
  region        = "us-east1"
  stack_type    = "IPV4_ONLY"
  network       = google_compute_network.default.id
}

resource "google_compute_firewall" "allow_icmp" {
  name    = "allow-icmp-${google_compute_network.default.name}"
  network = google_compute_network.default.id
  project = var.project_id

  allow {
    protocol = "icmp"
  }

  source_ranges = ["0.0.0.0/0"]
  target_tags   = ["allow-icmp"]
}

resource "google_compute_firewall" "allow_ssh" {
  name    = "allow-ssh-${google_compute_network.default.name}"
  network = google_compute_network.default.id
  project = var.project_id

  allow {
    protocol = "tcp"
    ports    = ["22"]
  }

  source_ranges = ["0.0.0.0/0"]
  target_tags   = ["allow-ssh"]
}

กลับไปที่เทอร์มินัล Cloud Shell ตรวจสอบว่าคุณอยู่ในไดเรกทอรี terraform-build cd terraform-build แล้วเรียกใช้คำสั่งต่อไปนี้

terraform init

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

terraform plan

สร้างแผนการดำเนินการ ซึ่งแสดงการดำเนินการที่ Terraform จะใช้เพื่อทำให้โครงสร้างพื้นฐานใช้งานได้

ตอนนี้หากต้องการสร้างทรัพยากร ให้เรียกใช้terraform applyคำสั่งแล้วพิมพ์ yes เพื่อเรียกใช้

4. งานที่ 2 สร้างเกตเวย์ NAT และ VM ด้วย Terraform

เราต้องให้สิทธิ์การเข้าถึงอินเทอร์เน็ตภายนอกขาออก ดังนั้นมาสร้างเกตเวย์ Cloud NAT แล้วแนบกัน

เปิด Cloud Shell ไปที่โฟลเดอร์ terraform-build แล้วสร้างไฟล์ต่อไปนี้ (รวม 3 ไฟล์) เราจะแก้ไขข้อมูลเหล่านี้ในภายหลัง

touch nat-vm.tf psc.tf dns.tf

เปลี่ยนไปที่มุมมองโปรแกรมแก้ไข Cloud Shell แล้วเลือกไฟล์ nat-vm.tf และเพิ่มโค้ด Terraform ต่อไปนี้ การดำเนินการนี้จะสร้างเกตเวย์ NAT และ VM 2 รายการ

Terraform nat-vm.tf

resource "google_compute_router" "default" {
  name    = "outbound-nat"
  region  = "us-east1"
  network = google_compute_network.default.id

 bgp {
  asn = 64514
  }
}

resource "google_compute_router_nat" "default" {
  name                               = "outbound-gw"
  router                             = google_compute_router.default.name
  region                             = google_compute_router.default.region
  nat_ip_allocate_option             = "AUTO_ONLY"
  source_subnetwork_ip_ranges_to_nat = "ALL_SUBNETWORKS_ALL_IP_RANGES"

  log_config {
    enable = true
    filter = "ERRORS_ONLY"
  }
}

resource "google_compute_instance" "vm1" {
  name         = "cli-vm"
  zone         = "us-east1-b"
  machine_type = "n2-standard-2"

  boot_disk {
    initialize_params {
      image = "debian-cloud/debian-12"
    }
  }

  network_interface {
    subnetwork = google_compute_subnetwork.default.id  
    stack_type = "IPV4_ONLY"
  }

  tags = ["allow-ssh", "allow-icmp"]

  metadata_startup_script = <<-EOF
    sudo apt-get update    
  EOF
}

resource "google_compute_instance" "vm2" {
  name         = "monitor-vm"
  zone         = "us-east1-b"
  machine_type = "n2-standard-2"

  boot_disk {
    initialize_params {
      image = "debian-cloud/debian-12"
    }
  }

  network_interface {
    subnetwork = google_compute_subnetwork.default.id   
    stack_type = "IPV4_ONLY"
  }

  tags = ["allow-ssh", "allow-icmp"]

  metadata_startup_script = <<-EOF
    sudo apt-get update
    sudo apt-get install python3 python3-dev python3-venv -y
    sudo apt-get install tcpdump dnsutils -y
  EOF
}

เปลี่ยนไปใช้เทอร์มินัล Cloud Shell ตรวจสอบว่าคุณอยู่ในโฟลเดอร์ terraform-build แล้วเรียกใช้ terraform plan ซึ่งจะแสดงให้เห็นว่าระบบจะเพิ่มรายการ 4 รายการ จากนั้นเรียกใช้ terraform apply แล้วพิมพ์ yes เพื่อสร้าง NAT Gateway และ VM 2 รายการ

5. งาน 3 กำหนดค่า VM ของ CLI และทดสอบ

ไปที่อินสแตนซ์ VM เลือก VM ที่ขึ้นต้นด้วย cli-vm เลือก SSH
เมื่อ SSH แล้ว คุณควรมีสิทธิ์เข้าถึง VM มาสร้างโฟลเดอร์สำหรับใช้เมื่อเรียกใช้ Gemini CLI กัน

mkdir geminicli && cd geminicli

เราต้องใช้ Node.js เพื่อติดตั้ง Gemini CLI ติดตั้ง Node.js โดยใช้คำสั่งต่อไปนี้

curl -fsSL https://deb.nodesource.com/setup_24.x -o nodesource_setup.sh

เรียกใช้สคริปต์

sudo -E bash nodesource_setup.sh

ติดตั้ง Node.js

sudo apt-get install -y nodejs

มาตั้งค่าตัวแปรบางอย่างที่จะช่วยในการใช้ตัวเลือกการตรวจสอบสิทธิ์ Vertex AI เพื่อตรวจสอบสิทธิ์นี้เพื่อทำการทดสอบในภายหลังกันดีกว่า ป. ล.แทนที่ YOUR_PROJECT_ID ด้วย project ID จริงของคุณ

cat <<EOF >> ~/.bashrc 

export GOOGLE_CLOUD_PROJECT="YOUR_PROJECT_ID"
export GOOGLE_CLOUD_LOCATION="us-east1" 
export GOOGLE_GENAI_USE_VERTEXAI=true
EOF

โหลด Bash ซ้ำ

source ~/.bashrc

ตอนนี้มาตรวจสอบสิทธิ์กัน เรียกใช้คำสั่งต่อไปนี้ใน VM แล้วกด y เมื่อได้รับแจ้ง

gcloud auth application-default login

จากนั้นคัดลอก URL ที่ปรากฏโดยเริ่มต้นด้วย https:// เปิดแท็บใหม่ในหน้าต่างเบราว์เซอร์ของห้องทดลอง แล้ววาง URL ยอมรับข้อความแจ้ง
เมื่อเห็นข้อความต่อไปนี้ ให้เลือกคัดลอก กลับไปที่เซสชัน cli-vm ของ VM แล้ววางโค้ดที่คัดลอกไว้สำหรับ Enter authorization code: แล้วกด Enter เพื่อตรวจสอบสิทธิ์

ตอนนี้มาติดตั้ง Gemini CLI กันโดยเรียกใช้คำสั่ง

sudo npm install -g @google/gemini-cli

เมื่อเสร็จแล้ว ให้พิมพ์ gemini เพื่อเปิดอินเทอร์เฟซ เลือกธีมที่ต้องการ และในส่วนเลือกวิธีการตรวจสอบสิทธิ์ ให้เลือก Vertex AI

เมื่อได้รับการตรวจสอบสิทธิ์แล้ว คุณจะเริ่มใช้ Gemini CLI ได้

ตรวจสอบเส้นทางการเข้าชมไปยัง Gemini ผ่าน monitor vm

ไปที่อินสแตนซ์ VM เลือก VM ที่ขึ้นต้นด้วย monitor-vm เลือก SSH
เมื่อ SSH เข้าสู่ monitor-vm คุณควรมีสิทธิ์เข้าถึง
มาใช้คำสั่ง dig เพื่อทดสอบเส้นทางการเชื่อมต่อกับ Gemini API กัน เราจะใช้ us-east1-aiplatform.googleapis.com

dig us-east1-aiplatform.googleapis.com

คุณควรเห็นข้อความที่คล้ายกัน (ที่อยู่จะแตกต่างกัน) โปรดทราบว่าเส้นทางจะผ่านที่อยู่ IP สาธารณะเนื่องจาก API เป็น API สาธารณะ

ห้ามคัดลอก

; <<>> DiG 9.18.33-1~deb12u2-Debian <<>> us-east1-aiplatform.googleapis.com
;; global options: +cmd
;; Got answer:
;; ->>HEADER<<- opcode: QUERY, status: NOERROR, id: 58905
;; flags: qr rd ra; QUERY: 1, ANSWER: 14, AUTHORITY: 0, ADDITIONAL: 1

;; OPT PSEUDOSECTION:
; EDNS: version: 0, flags:; udp: 65494
;; QUESTION SECTION:
;us-east1-aiplatform.googleapis.com. IN A

;; ANSWER SECTION:
us-east1-aiplatform.googleapis.com. 300 IN A    173.194.217.95
us-east1-aiplatform.googleapis.com. 300 IN A    172.217.204.95
us-east1-aiplatform.googleapis.com. 300 IN A    172.217.203.95
us-east1-aiplatform.googleapis.com. 300 IN A    142.250.98.95
us-east1-aiplatform.googleapis.com. 300 IN A    142.251.107.95
us-east1-aiplatform.googleapis.com. 300 IN A    74.125.196.95
us-east1-aiplatform.googleapis.com. 300 IN A    173.194.216.95
us-east1-aiplatform.googleapis.com. 300 IN A    108.177.11.95
us-east1-aiplatform.googleapis.com. 300 IN A    192.178.219.95
us-east1-aiplatform.googleapis.com. 300 IN A    173.194.210.95
us-east1-aiplatform.googleapis.com. 300 IN A    173.194.212.95
us-east1-aiplatform.googleapis.com. 300 IN A    173.194.215.95
us-east1-aiplatform.googleapis.com. 300 IN A    108.177.12.95
us-east1-aiplatform.googleapis.com. 300 IN A    74.125.26.95

ตอนนี้มาpingทดสอบอย่างรวดเร็วเพื่อดูว่าเราเชื่อมต่อกับ Gemini API ได้หรือไม่ คำสั่งนี้จะใช้ 4 pings ไปยัง us-east1-aiplatform.googleapis.com เพื่อให้เราได้รับคำตอบจากที่อยู่สาธารณะของ API

ping -c 4 us-east1-aiplatform.googleapis.com

เราจะกลับมาทดสอบ VM นี้ในภายหลัง ปิดเซสชัน SSH แล้วมาดำเนินการต่อกัน

6. งานที่ 4 สร้างปลายทาง PSC ไปยัง googleapis ด้วย Terraform

หากต้องการเปิดใช้การเชื่อมต่อส่วนตัวกับปลายทาง Vertex API เราจะสร้างปลายทาง Private Service Connect สำหรับ Google API ซึ่งจะช่วยให้เราใช้ที่อยู่ IP ส่วนตัวที่เรากำหนดเพื่อกำหนดเส้นทางการรับส่งข้อมูลไปยัง Google API ที่เราต้องการได้ ซึ่งในกรณีนี้คือ Vertex

เปิด Cloud Shell ในมุมมองเอดิเตอร์หากยังไม่ได้เปิด เราจะสร้างสิ่งต่อไปนี้

สร้าง IP สำหรับปลายทาง PSC 10.10.100.250 (resource "google_compute_global_address" "default")
สร้างปลายทาง PSC ไปยัง Google APIs (resource "google_compute_global_forwarding_rule" "default")

เปิดไฟล์ psc.tf ในโฟลเดอร์ terraform-build เพิ่มโค้ดต่อไปนี้ลงในไฟล์

Terraform psc.tf

resource "google_compute_global_address" "default" {
  name         = "gemini-ip"
  purpose      = "PRIVATE_SERVICE_CONNECT"
  network      = google_compute_network.default.id
  address_type = "INTERNAL"
  address      = "10.10.100.250"
}

resource "google_compute_global_forwarding_rule" "default" {  
  name                  = "pscgemini"
  target                = "all-apis"
  network               = google_compute_network.default.id
  ip_address            = google_compute_global_address.default.id
  load_balancing_scheme = ""
  }

สลับไปที่เทอร์มินัล Cloud Shell และตรวจสอบว่าคุณอยู่ในโฟลเดอร์ terraform-build จากนั้นเรียกใช้ terraform init จากนั้นเรียกใช้ terraform plan ซึ่งจะแสดงให้เห็นว่าระบบจะเพิ่มรายการ 2 รายการ
จากนั้นเรียกใช้ terraform apply แล้วพิมพ์ yes เพื่อสร้างปลายทาง IP และ PSC Google APIs
ยืนยันว่ามีปลายทาง

gcloud compute addresses list --filter="name=( 'gemini-ip' ...)"

gcloud compute forwarding-rules describe pscgemini --global

7. งานที่ 5 สร้างรายการ DNS ด้วยตนเองไปยัง googleapis ด้วย Terraform

คุณสร้างรายการ DNS ด้วยตนเองเพื่อชี้ไปยังปลายทาง PSC โดยใช้ DNS ส่วนตัวได้ ซึ่งจะส่งผลต่อเครือข่ายทั้งหมดที่คุณกำหนดให้กับอุปกรณ์

ไปที่บริการเครือข่ายแล้วเลือก Cloud DNS
ในโซน คุณควรเห็นโซนที่สร้างขึ้นโดยอัตโนมัติสำหรับ Private Service Connect สำหรับ Google API โดยมีไดเรกทอรีบริการประเภทโซน ซึ่งใช้เพื่อเชื่อมต่อกับปลายทาง PSC ได้โดยใช้รูปแบบ **SERVICE-ENDPOINT.p.googleapis.com ตัวอย่าง: aiplatform-pscgemini.p.googleapis.com
ในกรณีนี้ เราต้องการสร้างรายการ DNS ส่วนตัวด้วยตนเอง การกำหนดค่าจะเป็นดังนี้

สร้างโซน DNS ส่วนตัวชื่อ "googleapis-private" สำหรับ "googleapis.com" และจำกัดให้ใช้ได้เฉพาะในเครือข่าย "python-net"
เพิ่มระเบียน A เพื่อแมป "googleapis.com" กับที่อยู่ IP "10.10.100.250"
เพิ่มระเบียน CNAME เพื่อเปลี่ยนเส้นทางโดเมนย่อยทั้งหมดของ "googleapis.com" (เช่น www.googleapis.com) ไปยัง "googleapis.com"

เปิด Cloud Shell ในมุมมองเอดิเตอร์หากยังไม่ได้เปิด เปิดไฟล์ dns.tf ในโฟลเดอร์ terraform-build เพิ่มโค้ดต่อไปนี้ลงในไฟล์

Terraform dns.tf

resource "google_dns_managed_zone" "private_zone" {
  name        = "googleapis-private"
  dns_name    = "googleapis.com."  
  visibility  = "private"
  project     = var.project_id     

  private_visibility_config {
    networks {
      network_url = google_compute_network.default.id  
    }
  }
}

resource "google_dns_record_set" "a_record" {
  name    = "googleapis.com."  
  type    = "A"
  ttl     = 300
  managed_zone = google_dns_managed_zone.private_zone.name
  project = var.project_id    

  rrdatas = ["10.10.100.250"]
}

resource "google_dns_record_set" "cname_record" {
 name    = "*.googleapis.com."
 type    = "CNAME"
 ttl     = 300
 managed_zone = google_dns_managed_zone.private_zone.name
 project = var.project_id    

 rrdatas = ["googleapis.com."]  
}

สลับไปที่เทอร์มินัล Cloud Shell และตรวจสอบว่าคุณอยู่ในโฟลเดอร์ terraform-build จากนั้นเรียกใช้ terraform plan ซึ่งจะแสดงรายการที่จะเพิ่ม
จากนั้นเรียกใช้ terraform apply แล้วพิมพ์ yes เพื่อสร้างรายการ DNS ส่วนตัว
คุณควรเห็นการตั้งค่าที่มีระเบียน A และ CNAME ดังนี้

จากนั้นเราจะยืนยันการเชื่อมต่อกับการเปลี่ยนแปลงเหล่านี้ใน monitor-vm

8. งานที่ 7 ยืนยันการเชื่อมต่ออุปกรณ์ปลายทางผ่านที่อยู่ IP

มาเชื่อมต่อโดยใช้ปลายทางส่วนตัวเพื่อเชื่อมต่อกับ Gemini กัน

ไปที่อินสแตนซ์ VM monitor-vm เลือก SSH และ SSH เข้าสู่ VM
ตรวจสอบเส้นทางการเชื่อมต่อกับ us-east1-aiplatform.googleapis.com โดยใช้คำสั่ง ping ซึ่งจะปิงที่อยู่ IP ใน DNS ส่วนตัว ระเบียน A สำหรับ googleapis IP นี้เป็นปลายทาง PSC และการ Ping จะไม่สำเร็จ

ping -c 2 us-east1-aiplatform.googleapis.com

ตรวจสอบเส้นทางการเชื่อมต่อด้วย ping โดยใช้รายการ DNS ที่สร้างขึ้นโดยอัตโนมัติสำหรับ PSC Google APIs ที่มี aiplatform-pscvertexgemini.p.googleapis.com ซึ่งจะชี้ไปยังที่อยู่ IP ของปลายทาง PSC และการ Ping จะไม่สำเร็จ

ping -c 2 aiplatform-pscgemini.p.googleapis.com

ตรวจสอบเส้นทางการเชื่อมต่อกับ us-east1-aiplatform.googleapis.com โดยใช้คำสั่ง dig ควรเป็นที่อยู่ IP ของปลายทาง PSC (10.10.100.250)

dig us-east1-aiplatform.googleapis.com

เมื่อเสร็จแล้ว คุณจะปิดเซสชัน SSH ของ monitor-vm ได้
ตอนนี้เราเรียกใช้ TCP dump ใน cli-vm ได้แล้ว เราจะต้องเปิดเซสชัน SSH 2 เซสชันไปยัง VM เดียวกัน เซสชันหนึ่งจะเรียกใช้คำสั่ง tcpdump ส่วนอีกเซสชันหนึ่งจะใช้ Gemini CLI
SSH เข้าสู่เซสชันแรกใน cli-vm
พิมพ์คำสั่งต่อไปนี้เพื่อดูการเชื่อมต่อใน tcpdump

sudo tcpdump -i any port 53 -n or host us-east1-aiplatform.googleapis.com

ตอนนี้ให้ SSH เข้าสู่เซสชันถัดไปใน cli-vm
เปิดใช้งาน Gemini CLI โดยพิมพ์ gemini
ถามคำถามต่อไปนี้ว่า "ท้องฟ้าสีอะไร" เพื่อสร้างการเรียกใช้ Gemini API

กด Enter เพื่อเรียกใช้และดูผลลัพธ์
เปลี่ยนกลับไปที่เซสชันแรกใน cli-vm คุณควรเห็นผลลัพธ์ของ tcpdump คุณจะเห็นว่าที่อยู่ IP ของ VM ใช้ที่อยู่ IP ของปลายทาง PSC เพื่อเชื่อมต่อกับ Gemini API

ปิดเซสชัน SSH ทั้งหมดไปยังอินสแตนซ์ VM

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

ไปที่ Cloud Shell ตรวจสอบว่าคุณอยู่ในไดเรกทอรี terraform-build cd terraform-build แล้วเรียกใช้คำสั่งต่อไปนี้ terraform destroy และพิมพ์ yes ระบบจะนำทรัพยากรทั้งหมดที่คุณสร้างในโปรเจ็กต์ด้วย Terraform ออก

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

ยินดีด้วย คุณเชื่อมต่อกับ Gemini CLI ได้สำเร็จโดยใช้ทั้งที่อยู่ API สาธารณะและแบบส่วนตัวโดยใช้ปลายทาง Private Service Connect สำหรับ Google API ฟังก์ชันนี้สามารถขยายการเชื่อมต่อ API ส่วนตัวไปยังสภาพแวดล้อมภายในองค์กร/ระบบคลาวด์อื่นๆ ที่เชื่อมต่อผ่าน (Interconnect, Cross-Cloud Interconnect และ VPC)

ขั้นตอนถัดไป / ดูข้อมูลเพิ่มเติม

คุณอ่านข้อมูลเพิ่มเติมเกี่ยวกับการเชื่อมต่อเครือข่าย Vertex AI และดูที่รีโป Gemini CLI ได้

ทำแล็บถัดไป

ทำภารกิจต่อด้วย Google Cloud และดูแล็บอื่นๆ ของ Google Cloud เหล่านี้