Coba model Gemini 1.5, model multimodal terbaru di Vertex AI, dan lihat model yang dapat Anda bangun dengan jendela konteks hingga 2 juta token. Coba model Gemini 1.5, model multimodal terbaru di Vertex AI, dan lihat model yang dapat Anda bangun dengan jendela konteks hingga 2 juta token.

Halaman ini diterjemahkan oleh Cloud Translation API.

Menggunakan Private Service Connect untuk mengakses prediksi online Vertex AI dari infrastruktur lokal

Host lokal dapat menjangkau endpoint prediksi online Vertex AI melalui internet publik atau secara pribadi melalui arsitektur jaringan hybrid yang menggunakan Private Service Connect (PSC) melalui Cloud VPN atau Cloud Interconnect. Kedua opsi tersebut menawarkan enkripsi SSL/TLS. Namun, opsi pribadi menawarkan performa yang jauh lebih baik dan karenanya direkomendasikan untuk aplikasi penting.

Dalam tutorial ini, Anda menggunakan VPN dengan Ketersediaan Tinggi (HA VPN) untuk mengakses endpoint prediksi online secara publik, melalui Cloud NAT; dan secara pribadi, antara dua jaringan Virtual Private Cloud yang dapat berfungsi sebagai dasar untuk konektivitas pribadi multi-cloud dan lokal.

Tutorial ini ditujukan bagi administrator jaringan perusahaan, data scientist, dan peneliti yang sudah memahami Vertex AI, Virtual Private Cloud (VPC), Google Cloud Console, dan Cloud Shell. Pemahaman tentang Vertex AI Workbench akan membantu, tetapi tidak bersifat wajib.

Diagram arsitektur untuk mengakses
endpoint prediksi online melalui Private Service Connect.

Tujuan

Buat dua jaringan Virtual Private Cloud (VPC), seperti yang ditunjukkan dalam diagram sebelumnya:
- Satu (on-prem-vpc) mewakili jaringan lokal.
- Yang lainnya (aiml-vpc) adalah untuk mem-build dan men-deploy model prediksi online Vertex AI.
Deploy gateway VPN dengan ketersediaan tinggi (HA), tunnel Cloud VPN, dan Cloud Router untuk menghubungkan aiml-vpc dan on-prem-vpc.
Mem-build dan men-deploy model prediksi online Vertex AI.
Buat endpoint Private Service Connect (PSC) untuk meneruskan permintaan prediksi online pribadi ke model yang di-deploy.
Aktifkan mode iklan kustom Cloud Router di aiml-vpc untuk mengumumkan rute untuk endpoint Private Service Connect ke on-prem-vpc.
Buat dua instance VM Compute Engine di on-prem-vpc untuk mewakili aplikasi klien:
- Satu (nat-client) mengirim permintaan prediksi online melalui internet publik (melalui Cloud NAT). Metode akses ini ditunjukkan oleh panah merah dan angka 1 dalam diagram.
- Yang lainnya (private-client) mengirim permintaan prediksi secara pribadi melalui VPN dengan ketersediaan tinggi (HA). Metode akses ini ditunjukkan dengan panah hijau dan angka 2.

Biaya

Dalam dokumen ini, Anda menggunakan komponen Google Cloud yang dapat ditagih berikut:

Untuk membuat perkiraan biaya berdasarkan proyeksi penggunaan Anda, gunakan kalkulator harga. Pengguna baru Google Cloud mungkin memenuhi syarat untuk mendapatkan uji coba gratis.

Setelah menyelesaikan tugas yang dijelaskan dalam dokumen ini, Anda dapat menghindari penagihan berkelanjutan dengan menghapus resource yang Anda buat. Untuk mengetahui informasi selengkapnya, lihat Pembersihan.

Sebelum memulai

Di konsol Google Cloud, buka halaman Pemilih project.

Buka pemilih project
Pilih atau buat project Google Cloud.
Make sure that billing is enabled for your Google Cloud project.
Buka Cloud Shell untuk menjalankan perintah yang tercantum dalam tutorial ini. Cloud Shell adalah lingkungan shell interaktif untuk Google Cloud yang dapat Anda gunakan untuk mengelola project dan resource dari browser web.
Di Cloud Shell, tetapkan project saat ini ke project ID Google Cloud Anda dan simpan project ID yang sama ke dalam variabel shell projectid:
```
  projectid="PROJECT_ID"
  gcloud config set project ${projectid}
```
Ganti PROJECT_ID dengan project ID Anda. Jika perlu, Anda dapat menemukan project ID di konsol Google Cloud. Untuk mengetahui informasi selengkapnya, baca Menemukan project ID.
Grant roles to your user account. Run the following command once for each of the following IAM roles: roles/appengine.appViewer, roles/artifactregistry.admin, roles/compute.instanceAdmin.v1, roles/compute.networkAdmin, roles/compute.securityAdmin, roles/dns.admin, roles/iap.admin, roles/iap.tunnelResourceAccessor, roles/notebooks.admin, roles/oauthconfig.editor, roles/resourcemanager.projectIamAdmin, roles/servicemanagement.quotaAdmin, roles/iam.serviceAccountAdmin, roles/iam.serviceAccountUser, roles/servicedirectory.editor, roles/storage.admin, roles/aiplatform.user
```
gcloud projects add-iam-policy-binding PROJECT_ID --member="user:USER_IDENTIFIER" --role=ROLE
```
- Replace PROJECT_ID with your project ID.
- Replace USER_IDENTIFIER with the identifier for your user account. For example, user:myemail@example.com.
- Replace ROLE with each individual role.

Aktifkan API DNS, Artifact Registry, IAM, Compute Engine, Notebooks, and Vertex AI:

gcloud services enable dns.googleapis.com artifactregistry.googleapis.com iam.googleapis.com compute.googleapis.com notebooks.googleapis.com aiplatform.googleapis.com

Membuat jaringan VPC

Di bagian ini, Anda akan membuat dua jaringan VPC: satu untuk membuat model prediksi online dan men-deploy-nya ke endpoint, yang lainnya untuk akses pribadi ke endpoint tersebut. Di setiap jaringan VPC, Anda akan membuat gateway Cloud Router dan Cloud NAT. Gateway Cloud NAT menyediakan konektivitas keluar untuk instance virtual machine (VM) Compute Engine tanpa alamat IP eksternal.

Buat jaringan VPC untuk endpoint prediksi online (`aiml-vpc`)

Buat jaringan VPC:

gcloud compute networks create aiml-vpc \
    --project=$projectid \
    --subnet-mode=custom

Buat subnet bernama workbench-subnet, dengan rentang IPv4 utama 172.16.10.0/28:

gcloud compute networks subnets create workbench-subnet \
    --project=$projectid \
    --range=172.16.10.0/28 \
    --network=aiml-vpc \
    --region=us-central1 \
    --enable-private-ip-google-access

Buat Cloud Router regional bernama cloud-router-us-central1-aiml-nat:

gcloud compute routers create cloud-router-us-central1-aiml-nat \
    --network aiml-vpc \
    --region us-central1

Tambahkan gateway Cloud NAT ke Cloud Router:

gcloud compute routers nats create cloud-nat-us-central1 \
    --router=cloud-router-us-central1-aiml-nat \
    --auto-allocate-nat-external-ips \
    --nat-all-subnet-ip-ranges \
    --region us-central1

Buat jaringan VPC "on-premises" (`on-prem-vpc`)

Buat jaringan VPC:

gcloud compute networks create on-prem-vpc \
    --project=$projectid \
    --subnet-mode=custom

Buat subnet bernama nat-subnet, dengan rentang IPv4 utama 192.168.10.0/28:

gcloud compute networks subnets create nat-subnet \
    --project=$projectid \
    --range=192.168.10.0/28 \
    --network=on-prem-vpc \
    --region=us-central1

Buat subnet bernama private-ip-subnet, dengan rentang IPv4 utama 192.168.20.0/28:

gcloud compute networks subnets create private-ip-subnet \
    --project=$projectid \
    --range=192.168.20.0/28 \
    --network=on-prem-vpc \
    --region=us-central1

Buat Cloud Router regional bernama cloud-router-us-central1-on-prem-nat:

gcloud compute routers create cloud-router-us-central1-on-prem-nat \
    --network on-prem-vpc \
    --region us-central1

Tambahkan gateway Cloud NAT ke Cloud Router:

gcloud compute routers nats create cloud-nat-us-central1 \
    --router=cloud-router-us-central1-on-prem-nat \
    --auto-allocate-nat-external-ips \
    --nat-all-subnet-ip-ranges \
    --region us-central1

Membuat endpoint Private Service Connect (PSC)

Di bagian ini, Anda akan membuat endpoint Private Service Connect (PSC) yang digunakan instance VM di jaringan on-prem-vpc untuk mengakses endpoint prediksi online melalui Vertex AI API. Endpoint Private Service Connect (PSC) adalah alamat IP internal di jaringan on-prem-vpc yang dapat diakses langsung oleh klien di jaringan tersebut. Endpoint ini dibuat dengan men-deploy aturan penerusan yang mengarahkan traffic jaringan yang cocok dengan alamat IP endpoint PSC ke paket Google API. Alamat IP endpoint PSC (100.100.10.10) akan diiklankan dari Cloud Router aiml-cr-us-central1 sebagai rute yang diiklankan secara kustom ke jaringan on-prem-vpc pada langkah berikutnya.

Mencadangkan alamat IP untuk endpoint PSC:

gcloud compute addresses create psc-ip \
    --global \
    --purpose=PRIVATE_SERVICE_CONNECT \
    --addresses=100.100.10.10 \
    --network=aiml-vpc

Buat endpoint PSC:

gcloud compute forwarding-rules create pscvertex \
    --global \
    --network=aiml-vpc \
    --address=psc-ip \
    --target-google-apis-bundle=all-apis

Cantumkan endpoint PSC yang dikonfigurasi dan pastikan endpoint pscvertex telah dibuat:

gcloud compute forwarding-rules list \
    --filter target="(all-apis OR vpc-sc)" --global

Dapatkan detail endpoint PSC yang dikonfigurasi dan pastikan alamat IP-nya adalah 100.100.10.10:
```
gcloud compute forwarding-rules describe pscvertex \
    --global
```

Mengonfigurasi konektivitas hybrid

Di bagian ini, Anda akan membuat dua gateway VPN dengan ketersediaan tinggi (HA) yang saling terhubung. Setiap gateway berisi Cloud Router dan sepasang tunnel VPN.

Buat gateway VPN dengan ketersediaan tinggi (HA) untuk jaringan VPC aiml-vpc:

gcloud compute vpn-gateways create aiml-vpn-gw \
    --network=aiml-vpc \
    --region=us-central1

Buat gateway VPN dengan ketersediaan tinggi (HA) untuk jaringan VPC on-prem-vpc:

gcloud compute vpn-gateways create on-prem-vpn-gw \
    --network=on-prem-vpc \
    --region=us-central1

Di Konsol Google Cloud, buka halaman VPN.

Buka VPN
Di halaman VPN, klik tab Cloud VPN Gateways.
Dalam daftar gateway VPN, pastikan ada dua gateway dan setiap gateway memiliki dua alamat IP.

Di Cloud Shell, buat Cloud Router untuk jaringan Virtual Private Cloud aiml-vpc:

gcloud compute routers create aiml-cr-us-central1 \
    --region=us-central1 \
    --network=aiml-vpc \
    --asn=65001

Buat Cloud Router untuk jaringan Virtual Private Cloud on-prem-vpc:

gcloud compute routers create on-prem-cr-us-central1 \
    --region=us-central1 \
    --network=on-prem-vpc \
    --asn=65002

Buat tunnel VPN untuk `aiml-vpc`

Buat tunnel VPN bernama aiml-vpc-tunnel0:

gcloud compute vpn-tunnels create aiml-vpc-tunnel0 \
    --peer-gcp-gateway on-prem-vpn-gw \
    --region us-central1 \
    --ike-version 2 \
    --shared-secret [ZzTLxKL8fmRykwNDfCvEFIjmlYLhMucH] \
    --router aiml-cr-us-central1 \
    --vpn-gateway aiml-vpn-gw \
    --interface 0

Buat tunnel VPN bernama aiml-vpc-tunnel1:

gcloud compute vpn-tunnels create aiml-vpc-tunnel1 \
    --peer-gcp-gateway on-prem-vpn-gw \
    --region us-central1 \
    --ike-version 2 \
    --shared-secret [bcyPaboPl8fSkXRmvONGJzWTrc6tRqY5] \
    --router aiml-cr-us-central1 \
    --vpn-gateway aiml-vpn-gw \
    --interface 1

Buat tunnel VPN untuk `on-prem-vpc`

Buat tunnel VPN bernama on-prem-vpc-tunnel0:

gcloud compute vpn-tunnels create on-prem-tunnel0 \
    --peer-gcp-gateway aiml-vpn-gw \
    --region us-central1 \
    --ike-version 2 \
    --shared-secret [ZzTLxKL8fmRykwNDfCvEFIjmlYLhMucH] \
    --router on-prem-cr-us-central1 \
    --vpn-gateway on-prem-vpn-gw \
    --interface 0

Buat tunnel VPN bernama on-prem-vpc-tunnel1:

gcloud compute vpn-tunnels create on-prem-tunnel1 \
    --peer-gcp-gateway aiml-vpn-gw \
    --region us-central1 \
    --ike-version 2 \
    --shared-secret [bcyPaboPl8fSkXRmvONGJzWTrc6tRqY5] \
    --router on-prem-cr-us-central1 \
    --vpn-gateway on-prem-vpn-gw \
    --interface 1

Di Konsol Google Cloud, buka halaman VPN.

Buka VPN
Di halaman VPN, klik tab Cloud VPN Tunnels.
Dalam daftar tunnel VPN, pastikan empat tunnel VPN telah dibuat.

Membuat sesi BGP

Cloud Router menggunakan Border Gateway Protocol (BGP) untuk bertukar rute antara jaringan VPC (dalam hal ini, aiml-vpc) dan jaringan lokal Anda (diwakili oleh on-prem-vpc). Di Cloud Router, Anda mengonfigurasi antarmuka dan peer BGP untuk router lokal. Antarmuka dan konfigurasi peer BGP bersama-sama membentuk sesi BGP. Di bagian ini, Anda akan membuat dua sesi BGP untuk aiml-vpc dan dua untuk on-prem-vpc.

Membuat sesi BGP untuk `aiml-vpc`

Di Cloud Shell, buat antarmuka BGP pertama:

gcloud compute routers add-interface aiml-cr-us-central1 \
    --interface-name if-tunnel0-to-onprem \
    --ip-address 169.254.1.1 \
    --mask-length 30 \
    --vpn-tunnel aiml-vpc-tunnel0 \
    --region us-central1

Membuat peer BGP pertama:

gcloud compute routers add-bgp-peer aiml-cr-us-central1 \
    --peer-name bgp-on-premises-tunnel0 \
    --interface if-tunnel1-to-onprem \
    --peer-ip-address 169.254.1.2 \
    --peer-asn 65002 \
    --region us-central1

Buat antarmuka BGP kedua:

gcloud compute routers add-interface aiml-cr-us-central1 \
    --interface-name if-tunnel1-to-onprem \
    --ip-address 169.254.2.1 \
    --mask-length 30 \
    --vpn-tunnel aiml-vpc-tunnel1 \
    --region us-central1

Membuat peer BGP kedua:

gcloud compute routers add-bgp-peer aiml-cr-us-central1 \
    --peer-name bgp-on-premises-tunnel1 \
    --interface if-tunnel2-to-onprem \
    --peer-ip-address 169.254.2.2 \
    --peer-asn 65002 \
    --region us-central1

Membuat sesi BGP untuk `on-prem-vpc`

Buat antarmuka BGP pertama:

gcloud compute routers add-interface on-prem-cr-us-central1 \
    --interface-name if-tunnel0-to-aiml-vpc \
    --ip-address 169.254.1.2 \
    --mask-length 30 \
    --vpn-tunnel on-prem-tunnel0 \
    --region us-central1

Membuat peer BGP pertama:

gcloud compute routers add-bgp-peer on-prem-cr-us-central1 \
    --peer-name bgp-aiml-vpc-tunnel0 \
    --interface if-tunnel1-to-aiml-vpc \
    --peer-ip-address 169.254.1.1 \
    --peer-asn 65001 \
    --region us-central1

Buat antarmuka BGP kedua:

gcloud compute routers add-interface on-prem-cr-us-central1 \
    --interface-name if-tunnel1-to-aiml-vpc \
    --ip-address 169.254.2.2 \
    --mask-length 30 \
    --vpn-tunnel on-prem-tunnel1 \
    --region us-central1

Membuat peer BGP kedua:

gcloud compute routers add-bgp-peer on-prem-cr-us-central1 \
    --peer-name bgp-aiml-vpc-tunnel1 \
    --interface if-tunnel2-to-aiml-vpc \
    --peer-ip-address 169.254.2.1 \
    --peer-asn 65001 \
    --region us-central1

Memvalidasi pembuatan sesi BGP

Di Konsol Google Cloud, buka halaman VPN.

Buka VPN
Di halaman VPN, klik tab Cloud VPN Tunnels.
Dalam daftar tunnel VPN, Anda sekarang akan melihat bahwa nilai di kolom Status sesi BGP untuk setiap empat tunnel telah berubah dari Konfigurasikan sesi BGP menjadi BGP dibuat. Anda mungkin perlu memuat ulang tab browser konsol Google Cloud untuk melihat nilai baru.

Memvalidasi bahwa `aiml-vpc` telah mempelajari rute subnet melalui VPN dengan ketersediaan tinggi (HA)

Di konsol Google Cloud, buka halaman jaringan VPC.

Buka jaringan VPC
Dalam daftar jaringan VPC, klik aiml-vpc.
Klik tab Routes.
Pilih us-central1 (Iowa) dalam daftar Region, lalu klik Lihat.
Di kolom Rentang IP tujuan, pastikan jaringan VPC aiml-vpc telah mempelajari rute dari subnet nat-subnet (192.168.10.0/28) dan private-ip-subnet (192.168.20.0/28) jaringan VPC on-prem-vpc.

Memvalidasi bahwa `on-prem-vpc` telah mempelajari rute subnet melalui VPN dengan ketersediaan tinggi (HA)

Di konsol Google Cloud, buka halaman jaringan VPC.

Buka jaringan VPC
Dalam daftar jaringan VPC, klik on-prem-vpc.
Klik tab Routes.
Pilih us-central1 (Iowa) dalam daftar Region, lalu klik Lihat.
Di kolom Rentang IP tujuan, pastikan jaringan VPC on-prem-vpc telah mempelajari rute dari subnet workbench-subnet jaringan VPC aiml-vpc (172.16.10.0/28).

Membuat rute kustom yang diiklankan untuk `aiml-vpc`

Alamat IP endpoint Private Service Connect tidak otomatis diiklankan oleh Cloud Router aiml-cr-us-central1 karena subnet tidak dikonfigurasi di jaringan VPC.

Oleh karena itu, Anda harus membuat rute khusus yang diberitahukan dari Cloud Router aiml-cr-us-central untuk Alamat IP endpoint 100.100.10.10 yang diiklankan ke lingkungan lokal melalui BGP ke on-prem-vpc.

Di konsol Google Cloud, buka halaman Cloud Function.

Buka Cloud Router
Dalam daftar Cloud Router, klik aiml-cr-us-central1.
Di halaman detail Router, klik Edit.
Di bagian Advertised routes untuk Routes, pilih Create custom routes.
Klik Tambahkan rute kustom.
Untuk Sumber, pilih Rentang IP kustom.
Untuk Rentang alamat IP, masukkan 100.100.10.10.
Untuk Deskripsi, masukkan Private Service Connect Endpoint IP.
Klik Selesai, lalu klik Simpan.

Validasi bahwa `on-prem-vpc` telah mempelajari alamat IP endpoint PSC melalui VPN dengan ketersediaan tinggi (HA)

Di konsol Google Cloud, buka halaman jaringan VPC.

Buka jaringan VPC
Dalam daftar jaringan VPC, klik on-prem-vpc.
Klik tab Routes.
Pilih us-central1 (Iowa) dalam daftar Region, lalu klik Lihat.
Di kolom Rentang IP tujuan, pastikan jaringan VPC on-prem-vpc telah mempelajari alamat IP endpoint PSC (100.100.10.10).

Membuat rute kustom yang diiklankan untuk `on-prem-vpc`

Cloud Router on-prem-vpc mengiklankan semua subnet secara default, tetapi hanya subnet private-ip-subnet yang diperlukan.

Di bagian berikut, perbarui iklan rute dari Cloud Router on-prem-cr-us-central1.

Di konsol Google Cloud, buka halaman Cloud Function.

Buka Cloud Router
Dalam daftar Cloud Router, klik on-prem-cr-us-central1.
Di halaman detail Router, klik Edit.
Di bagian Advertised routes, untuk Routes, pilih Create custom routes.
Jika kotak centang Beriklan semua subnet yang terlihat Cloud Router dicentang, hapus centang tersebut.
Klik Tambahkan rute kustom.
Untuk Sumber, pilih Rentang IP kustom.
Untuk Rentang alamat IP, masukkan 192.168.20.0/28.
Untuk Deskripsi, masukkan Private Service Connect Endpoint IP subnet (private-ip-subnet).
Klik Selesai, lalu klik Simpan.

Validasi bahwa `aiml-vpc` telah mempelajari rute `private-ip-subnet` dari `on-prem-vpc`

Di konsol Google Cloud, buka halaman jaringan VPC.

Buka jaringan VPC
Dalam daftar jaringan VPC, klik aiml-vpc.
Klik tab Routes.
Pilih us-central1 (Iowa) dalam daftar Region, lalu klik Lihat.
Di kolom Destination IP range, pastikan jaringan VPC aiml-vpc telah mempelajari rute private-ip-subnet (192.168.20.0/28).

Membuat instance VM pengujian

Membuat akun layanan yang dikelola pengguna

Jika Anda memiliki aplikasi yang perlu memanggil Google Cloud API, Google merekomendasikan agar Anda menyertakan akun layanan yang dikelola pengguna ke VM tempat aplikasi atau beban kerja berjalan. Oleh karena itu, di bagian ini, Anda akan membuat akun layanan yang dikelola pengguna untuk diterapkan ke instance VM yang Anda buat nanti dalam tutorial ini.

Di Cloud Shell, buat akun layanan:

gcloud iam service-accounts create gce-vertex-sa \
    --description="service account for vertex" \
    --display-name="gce-vertex-sa"

Tetapkan peran IAM Compute Instance Admin (v1) (roles/compute.instanceAdmin.v1) ke akun layanan:

gcloud projects add-iam-policy-binding $projectid \
    --member="serviceAccount:gce-vertex-sa@$projectid.iam.gserviceaccount.com" \
    --role="roles/compute.instanceAdmin.v1"

Tetapkan peran IAM Vertex AI User (roles/aiplatform.user) ke akun layanan:

gcloud projects add-iam-policy-binding $projectid \
    --member="serviceAccount:gce-vertex-sa@$projectid.iam.gserviceaccount.com" \
    --role="roles/aiplatform.user"

Membuat instance VM pengujian

Pada langkah ini, Anda akan membuat instance VM pengujian untuk memvalidasi berbagai metode untuk menjangkau Vertex AI API, khususnya:

Instance nat-client menggunakan Cloud NAT untuk me-resolve Vertex AI agar dapat mengakses endpoint Prediksi Online melalui internet publik.
Instance private-client menggunakan alamat IP Private Service Connect 100.100.10.10 untuk mengakses endpoint prediksi online melalui VPN HA.

Untuk mengizinkan Identity-Aware Proxy (IAP) terhubung ke instance VM, Anda membuat aturan firewall yang:

Berlaku untuk semua instance VM yang ingin Anda buat dapat diakses melalui IAP.
Mengizinkan traffic TCP melalui port 22 dari rentang IP 35.235.240.0/20. Rentang ini berisi semua alamat IP yang digunakan IAP untuk penerusan TCP.

Buat instance VM nat-client:

gcloud compute instances create nat-client \
    --zone=us-central1-a \
    --image-family=debian-11 \
    --image-project=debian-cloud \
    --subnet=nat-subnet \
    --service-account=gce-vertex-sa@$projectid.iam.gserviceaccount.com \
    --scopes=https://www.googleapis.com/auth/cloud-platform \
    --no-address \
    --metadata startup-script="#! /bin/bash
        sudo apt-get update
        sudo apt-get install tcpdump dnsutils -y"

Buat instance VM private-client:

gcloud compute instances create private-client \
    --zone=us-central1-a \
    --image-family=debian-11 \
    --image-project=debian-cloud \
    --subnet=private-ip-subnet \
    --service-account=gce-vertex-sa@$projectid.iam.gserviceaccount.com \
    --scopes=https://www.googleapis.com/auth/cloud-platform \
    --no-address \
    --metadata startup-script="#! /bin/bash
        sudo apt-get update
        sudo apt-get install tcpdump dnsutils -y"

Buat aturan firewall IAP:

gcloud compute firewall-rules create ssh-iap-on-prem-vpc \
    --network on-prem-vpc \
    --allow tcp:22 \
    --source-ranges=35.235.240.0/20

Membuat instance Vertex AI Workbench

Membuat akun layanan yang dikelola pengguna untuk Vertex AI Workbench

Saat membuat instance Vertex AI Workbench, Google sangat menyarankan agar Anda menentukan akun layanan yang dikelola pengguna, bukan menggunakan akun layanan default Compute Engine. Jika organisasi Anda tidak menerapkan batasan kebijakan organisasi iam.automaticIamGrantsForDefaultServiceAccounts, akun layanan default Compute Engine (dan dengan demikian siapa pun yang Anda tetapkan sebagai pengguna instance) akan diberi peran Editor (roles/editor) di project Google Cloud Anda. Untuk menonaktifkan perilaku ini, lihat Menonaktifkan pemberian peran otomatis untuk akun layanan default.

Di Cloud Shell, buat akun layanan bernama workbench-sa:

gcloud iam service-accounts create workbench-sa \
    --display-name="workbench-sa"

Tetapkan peran IAM Storage Admin (roles/storage.admin) ke akun layanan:

gcloud projects add-iam-policy-binding $projectid \
    --member="serviceAccount:workbench-sa@$projectid.iam.gserviceaccount.com" \
    --role="roles/storage.admin"

Tetapkan peran IAM Vertex AI User (roles/aiplatform.user) ke akun layanan:

gcloud projects add-iam-policy-binding $projectid \
     --member="serviceAccount:workbench-sa@$projectid.iam.gserviceaccount.com" \
     --role="roles/aiplatform.user"

Tetapkan peran IAM Administrator Artifact Registry ke akun layanan:

gcloud projects add-iam-policy-binding $projectid \
    --member="serviceAccount:workbench-sa@$projectid.iam.gserviceaccount.com" \
    --role="roles/artifactregistry.admin"

Membuat instance Vertex AI Workbench

Di Cloud Shell, buat instance Vertex AI Workbench, dengan menentukan akun layanan workbench-sa:

gcloud workbench instances create workbench-tutorial \
  --vm-image-project=deeplearning-platform-release \
  --vm-image-family=common-cpu-notebooks \
  --machine-type=n1-standard-4 \
  --location=us-central1-a \
  --subnet-region=us-central1 \
  --shielded-secure-boot=True \
  --subnet=workbench-subnet \
  --disable-public-ip \
  --service-account-email=workbench-sa@$projectid.iam.gserviceaccount.com

Membuat dan men-deploy model prediksi online

Menyiapkan lingkungan Anda

Di konsol Google Cloud, buka tab Instances di halaman Vertex AI Workbench.

Buka Vertex AI Workbench
Di samping nama instance Vertex AI Workbench (workbench-tutorial), klik Open JupyterLab.

Instance Vertex AI Workbench akan membuka JupyterLab.

Di bagian lain dalam bagian ini, hingga dan termasuk deployment model, Anda akan bekerja di Jupyterlab, bukan konsol Google Cloud atau Cloud Shell.
Pilih File > New > Terminal.
Di terminal JupyterLab (bukan Cloud Shell), tentukan variabel lingkungan untuk project Anda. Ganti PROJECT_ID dengan project ID Anda:
```
PROJECT_ID=PROJECT_ID
```
Buat direktori baru bernama cpr-codelab dan cd ke dalamnya (masih di terminal JupyterLab):
```
mkdir cpr-codelab
cd cpr-codelab
```
Di File Browser, klik dua kali folder cpr-codelab baru.

Jika folder ini tidak muncul di browser file, muat ulang tab browser konsol Google Cloud, lalu coba lagi.
Pilih File > New > Notebook.
Dari menu Select Kernel, pilih Python [conda env:base] * (Local), lalu klik Select.
Ganti nama file notebook baru Anda sebagai berikut:

Di File Browser, klik kanan ikon file Untitled.ipynb dan masukkan task.ipynb.

Direktori cpr-codelab Anda sekarang akan terlihat seperti ini:
```
+ cpr-codelab/
   + task.ipynb
```
Pada langkah-langkah berikut, Anda akan membuat model di notebook Jupyterlab dengan membuat sel notebook baru, menempelkan kode ke dalamnya, dan menjalankan sel.
Instal dependensi sebagai berikut.
1. Saat membuka notebook baru, ada sel kode default tempat Anda dapat memasukkan kode. Tampilannya seperti [ ]: diikuti dengan kolom teks. Kolom teks tersebut adalah tempat Anda menempelkan kode.
  
  Tempelkan kode berikut ke dalam sel, lalu klik Jalankan sel yang dipilih dan lanjutkan untuk membuat file requirements.txt yang akan digunakan sebagai input untuk langkah berikut:
```
%%writefile requirements.txt
fastapi
uvicorn==0.17.6
joblib~=1.1.1
numpy>=1.17.3, <1.24.0
scikit-learn>=1.2.2
pandas
google-cloud-storage>=2.2.1,<3.0.0dev
google-cloud-aiplatform[prediction]>=1.18.2
```
2. Pada langkah ini dan setiap langkah berikutnya, tambahkan sel kode dengan mengklik Insert a cell below, tempelkan kode ke dalam sel, lalu klik Run the selected cells and advance.
  
  Gunakan Pip untuk menginstal dependensi di instance notebook:
```
!pip install -U --user -r requirements.txt
```
3. Setelah penginstalan selesai, pilih Kernel > Restart kernel untuk memulai ulang kernel dan memastikan library tersedia untuk diimpor.
4. Tempel kode berikut ke dalam sel notebook baru untuk membuat direktori guna menyimpan model dan artefak prapemrosesan:
```
USER_SRC_DIR = "src_dir"
!mkdir $USER_SRC_DIR
!mkdir model_artifacts
# copy the requirements to the source dir
!cp requirements.txt $USER_SRC_DIR/requirements.txt
```
Di File Browser, struktur direktori cpr-codelab Anda sekarang akan terlihat seperti ini:
```
+ cpr-codelab/
  + model_artifacts/
  + src_dir/
     + requirements.txt
  + requirements.txt
  + task.ipynb
```

Melatih model

Lanjutkan menambahkan sel kode ke notebook task.ipynb, lalu tempelkan dan jalankan kode berikut di setiap sel baru:

Impor library:

import seaborn as sns
import numpy as np
import pandas as pd

from sklearn import preprocessing
from sklearn.ensemble import RandomForestRegressor
from sklearn.pipeline import make_pipeline
from sklearn.compose import make_column_transformer

import joblib
import logging

# set logging to see the docker container logs
logging.basicConfig(level=logging.INFO)

Tentukan variabel berikut, dengan mengganti PROJECT_ID dengan project ID Anda:

REGION = "us-central1"
MODEL_ARTIFACT_DIR = "sklearn-model-artifacts"
REPOSITORY = "diamonds"
IMAGE = "sklearn-image"
MODEL_DISPLAY_NAME = "diamonds-cpr"
PROJECT_ID = "PROJECT_ID"
BUCKET_NAME = "gs://PROJECT_ID-cpr-bucket"

Membuat bucket Cloud Storage:

!gcloud storage buckets create $BUCKET_NAME --location=us-central1

Muat data dari library seaborn, lalu buat dua frame data, satu dengan fitur dan satu lagi dengan label:

data = sns.load_dataset('diamonds', cache=True, data_home=None)

label = 'price'

y_train = data['price']
x_train = data.drop(columns=['price'])

Lihat data pelatihan dan pastikan setiap baris mewakili berlian.
```
x_train.head()
```
Lihat label, yang merupakan harga yang sesuai.
```
y_train.head()
```

Tentukan transformasi kolom sklearn untuk encode one hot fitur kategoris dan menskalakan fitur numerik:

column_transform = make_column_transformer(
   (preprocessing.OneHotEncoder(), [1,2,3]),
   (preprocessing.StandardScaler(), [0,4,5,6,7,8]))

Tentukan model random forest:

regr = RandomForestRegressor(max_depth=10, random_state=0)

Buat pipeline sklearn. Pipeline ini mengambil data input, mengenkode dan menskalakannya, lalu meneruskannya ke model.
```
my_pipeline = make_pipeline(column_transform, regr)
```
Latih model:
```
my_pipeline.fit(x_train, y_train)
```
Panggil metode prediksi pada model, dengan meneruskan sampel pengujian.
```
my_pipeline.predict([[0.23, 'Ideal', 'E', 'SI2', 61.5, 55.0, 3.95, 3.98, 2.43]])
```
Anda mungkin melihat peringatan seperti "X does not have valid feature names, but", tetapi Anda dapat mengabaikannya.

Simpan pipeline ke direktori model_artifacts dan salin ke bucket Cloud Storage Anda:

joblib.dump(my_pipeline, 'model_artifacts/model.joblib')

!gcloud storage cp model_artifacts/model.joblib {BUCKET_NAME}/{MODEL_ARTIFACT_DIR}/

Menyimpan artefak prapemrosesan

Membuat artefak prapemrosesan. Artefak ini akan dimuat ke dalam penampung kustom saat server model dimulai. Artefak prapemrosesan Anda dapat berupa hampir semua bentuk (seperti file pickle), tetapi dalam hal ini, Anda akan menulis kamus ke file JSON:
```
clarity_dict={"Flawless": "FL",
   "Internally Flawless": "IF",
   "Very Very Slightly Included": "VVS1",
   "Very Slightly Included": "VS2",
   "Slightly Included": "S12",
   "Included": "I3"}
```

Mem-build penampung penayangan kustom menggunakan server model CPR

Fitur clarity dalam data pelatihan kami selalu dalam bentuk singkatan (yaitu "FL", bukan "Flawless"). Pada waktu penayangan, kita ingin memeriksa apakah data untuk fitur ini juga disingkat. Hal ini karena model kita mengetahui cara melakukan encoding "FL" secara hot, tetapi tidak untuk "Flawless". Anda akan menulis logika prapemrosesan kustom ini nanti. Namun, untuk saat ini, cukup simpan tabel pencarian ini ke file JSON, lalu tulis ke bucket Cloud Storage Anda:
```
import json
with open("model_artifacts/preprocessor.json", "w") as f:
   json.dump(clarity_dict, f)

!gcloud storage cp model_artifacts/preprocessor.json {BUCKET_NAME}/{MODEL_ARTIFACT_DIR}/
```
Di File Browser, struktur direktori Anda sekarang akan terlihat seperti ini:
```
+ cpr-codelab/
   + model_artifacts/
      + model.joblib
      + preprocessor.json
   + src_dir/
      + requirements.txt
   + requirements.txt
   + task.ipynb
```

Di notebook, tempel dan jalankan kode berikut untuk membuat subclass SklearnPredictor dan menulisnya ke file Python di src_dir/. Perhatikan bahwa dalam contoh ini, kita hanya menyesuaikan metode pemuatan, praproses, dan pascaproses, bukan metode prediksi.

%%writefile $USER_SRC_DIR/predictor.py

import joblib
import numpy as np
import json

from google.cloud import storage
from google.cloud.aiplatform.prediction.sklearn.predictor import SklearnPredictor

class CprPredictor(SklearnPredictor):

 def __init__(self):
     return

 def load(self, artifacts_uri: str) -> None:
     """Loads the sklearn pipeline and preprocessing artifact."""

     super().load(artifacts_uri)

     # open preprocessing artifact
     with open("preprocessor.json", "rb") as f:
         self._preprocessor = json.load(f)

 def preprocess(self, prediction_input: np.ndarray) -> np.ndarray:
     """Performs preprocessing by checking if clarity feature is in abbreviated form."""

     inputs = super().preprocess(prediction_input)

     for sample in inputs:
         if sample[3] not in self._preprocessor.values():
             sample[3] = self._preprocessor[sample[3]]
     return inputs

 def postprocess(self, prediction_results: np.ndarray) -> dict:
     """Performs postprocessing by rounding predictions and converting to str."""

     return {"predictions": [f"${value}" for value in np.round(prediction_results)]}

Gunakan Vertex AI SDK untuk Python guna mem-build gambar menggunakan rutinitas prediksi kustom. Dockerfile akan dibuat dan image akan di-build untuk Anda.

from google.cloud import aiplatform

aiplatform.init(project=PROJECT_ID, location=REGION)

import os

from google.cloud.aiplatform.prediction import LocalModel

from src_dir.predictor import CprPredictor  # Should be path of variable $USER_SRC_DIR

local_model = LocalModel.build_cpr_model(
   USER_SRC_DIR,
   f"{REGION}-docker.pkg.dev/{PROJECT_ID}/{REPOSITORY}/{IMAGE}",
   predictor=CprPredictor,
   requirements_path=os.path.join(USER_SRC_DIR, "requirements.txt"),
)

Tulis file pengujian dengan dua sampel untuk prediksi. Salah satu instance memiliki nama kejelasan singkat, tetapi instance lainnya perlu dikonversi terlebih dahulu.

import json

sample = {"instances": [
   [0.23, 'Ideal', 'E', 'VS2', 61.5, 55.0, 3.95, 3.98, 2.43],
   [0.29, 'Premium', 'J', 'Internally Flawless', 52.5, 49.0, 4.00, 2.13, 3.11]]}

with open('instances.json', 'w') as fp:
   json.dump(sample, fp)

Uji container secara lokal dengan men-deploy model lokal.

with local_model.deploy_to_local_endpoint(
   artifact_uri = 'model_artifacts/', # local path to artifacts
) as local_endpoint:
   predict_response = local_endpoint.predict(
      request_file='instances.json',
      headers={"Content-Type": "application/json"},
   )

   health_check_response = local_endpoint.run_health_check()

Anda dapat melihat hasil prediksi dengan:
```
predict_response.content
```
Outputnya akan terlihat seperti berikut:
```
b'{"predictions": ["$479.0", "$586.0"]}'
```

Men-deploy model ke endpoint model prediksi online

Setelah menguji penampung secara lokal, sekarang saatnya mengirim image ke Artifact Registry dan mengupload model ke Vertex AI Model Registry.

Mengonfigurasi Docker untuk mengakses Artifact Registry.

!gcloud artifacts repositories create {REPOSITORY} \
    --repository-format=docker \
    --location=us-central1 \
    --description="Docker repository"

!gcloud auth configure-docker {REGION}-docker.pkg.dev --quiet

Kirim gambar.
```
local_model.push_image()
```

Upload model.

model = aiplatform.Model.upload(local_model = local_model,
                                display_name=MODEL_DISPLAY_NAME,
                                artifact_uri=f"{BUCKET_NAME}/{MODEL_ARTIFACT_DIR}",)

Men-deploy model:
```
endpoint = model.deploy(machine_type="n1-standard-2")
```
Tunggu hingga model di-deploy sebelum Anda melanjutkan ke langkah berikutnya. Deployment memerlukan waktu sekitar 10 hingga 15 menit.

Uji model yang di-deploy dengan mendapatkan prediksi:

endpoint.predict(instances=[[0.23, 'Ideal', 'E', 'VS2', 61.5, 55.0, 3.95, 3.98, 2.43]])

Outputnya akan terlihat seperti berikut:

Prediction(predictions=['$479.0'], deployed_model_id='3171115779319922688', metadata=None, model_version_id='1', model_resource_name='projects/721032480027/locations/us-central1/models/8554949231515795456', explanations=None)

Memvalidasi akses internet publik ke Vertex AI API

Di bagian ini, Anda akan login ke instance VM nat-client di satu tab sesi Cloud Shell dan menggunakan tab sesi lain untuk memvalidasi konektivitas ke Vertex AI API dengan menjalankan perintah dig dan tcpdump terhadap domain us-central1-aiplatform.googleapis.com.

Di Cloud Shell (Tab Satu), jalankan perintah berikut, dengan mengganti PROJECT_ID dengan project ID Anda:
```
projectid=PROJECT_ID
gcloud config set project ${projectid}
```

gcloud compute ssh nat-client \
    --project=$projectid \
    --zone=us-central1-a \
    --tunnel-through-iap

Jalankan perintah dig:

dig us-central1-aiplatform.googleapis.com

Dari VM nat-client (Tab Satu), jalankan perintah berikut untuk memvalidasi resolusi DNS saat Anda mengirim permintaan prediksi online ke endpoint.
```
sudo tcpdump -i any port 53 -n
```
Buka sesi Cloud Shell baru (Tab Dua) dengan mengklik buka tab baru di Cloud Shell.
Dalam sesi Cloud Shell baru (Tab Dua), jalankan perintah berikut, dan ganti PROJECT_ID dengan project ID Anda:
```
projectid=PROJECT_ID
gcloud config set project ${projectid}
```

gcloud compute ssh --zone "us-central1-a" "nat-client" --project "$projectid"

Dari VM nat-client (Tab Dua), gunakan editor teks seperti vim atau nano untuk membuat file instances.json. Anda harus menambahkan sudo di awal agar memiliki izin untuk menulis ke file, misalnya:
```
sudo vim instances.json
```

Tambahkan string data berikut ke file:

{"instances": [
   [0.23, 'Ideal', 'E', 'VS2', 61.5, 55.0, 3.95, 3.98, 2.43],
   [0.29, 'Premium', 'J', 'Internally Flawless', 52.5, 49.0, 4.00, 2.13, 3.11]]}

Simpan file sebagai berikut:
- Jika Anda menggunakan vim, tekan tombol Esc, lalu ketik :wq untuk menyimpan file dan keluar.
- Jika Anda menggunakan nano, ketik Control+O dan tekan Enter untuk menyimpan file, lalu ketik Control+X untuk keluar.
Temukan ID endpoint prediksi online untuk endpoint PSC:
1. Di konsol Google Cloud, di bagian Vertex AI, buka tab Endpoints di halaman Online prediction.
  
  Buka Endpoint
2. Temukan baris endpoint yang Anda buat, yang bernama diamonds-cpr_endpoint.
3. Temukan ID endpoint 19 digit di kolom ID dan salin.
Di Cloud Shell, dari VM nat-client (Tab Dua), jalankan perintah berikut, dengan mengganti PROJECT_ID dengan project ID Anda dan ENDPOINT_ID dengan ID endpoint PSC:
```
projectid=PROJECT_ID
gcloud config set project ${projectid}
ENDPOINT_ID=ENDPOINT_ID
```

Dari VM nat-client (Tab Dua), jalankan perintah berikut untuk mengirim permintaan prediksi online:

curl -X POST -H "Authorization: Bearer $(gcloud auth print-access-token)" -H "Content-Type: application/json" https://us-central1-aiplatform.googleapis.com/v1/projects/${projectid}/locations/us-central1/endpoints/${ENDPOINT_ID}:predict -d @instances.json

Setelah menjalankan prediksi, Anda akan melihat bahwa hasil tcpdump (Tab Satu) menampilkan instance VM nat-client (192.168.10.2) yang menjalankan kueri Cloud DNS ke server DNS lokal (169.254.169.254) untuk domain Vertex AI API (us-central1-aiplatform.googleapis.com). Kueri DNS menampilkan Alamat IP Virtual (VIP) publik untuk Vertex AI API.

Memvalidasi akses pribadi ke Vertex AI API

Di bagian ini, Anda akan login ke instance VM private-client menggunakan Identity-Aware Proxy dalam sesi Cloud Shell baru (Tab Tiga), lalu memvalidasi konektivitas ke Vertex AI API dengan menjalankan perintah dig terhadap domain Vertex AI (us-central1-aiplatform.googleapis.com).

Buka sesi Cloud Shell baru (Tab Tiga) dengan mengklik buka tab baru di Cloud Shell. Ini adalah Tab Tiga.
Dalam sesi Cloud Shell baru (Tab Tiga), jalankan perintah berikut, dan ganti PROJECT_ID dengan project ID Anda:
```
projectid=PROJECT_ID
gcloud config set project ${projectid}
```

gcloud compute ssh private-client \
    --project=$projectid \
    --zone=us-central1-a \
    --tunnel-through-iap

Jalankan perintah dig:

dig us-central1-aiplatform.googleapis.com

Di instance VM private-client (Tab Tiga), gunakan editor teks seperti vim atau nano untuk menambahkan baris berikut ke file /etc/hosts:

100.100.10.10 us-central1-aiplatform.googleapis.com

Baris ini menetapkan alamat IP endpoint PSC (100.100.10.10) ke nama domain yang sepenuhnya memenuhi syarat untuk Vertex AI Google API (us-central1-aiplatform.googleapis.com). File yang diedit akan terlihat seperti ini:

127.0.0.1       localhost
::1             localhost ip6-localhost ip6-loopback
ff02::1         ip6-allnodes
ff02::2         ip6-allrouters

100.100.10.10 us-central1-aiplatform.googleapis.com # Added by you
192.168.20.2 private-client.c.$projectid.internal private-client  # Added by Google
169.254.169.254 metadata.google.internal  # Added by Google

Dari VM private-client (Tab Tiga), lakukan ping ke endpoint Vertex AI dan Control+C untuk keluar saat Anda melihat output:
```
ping us-central1-aiplatform.googleapis.com
```
Perintah ping menampilkan output berikut yang berisi alamat IP endpoint PSC:
```
PING us-central1-aiplatform.googleapis.com (100.100.10.10) 56(84) bytes of data.
```
Dari VM private-client (Tab Tiga), gunakan tcpdump untuk menjalankan perintah berikut guna memvalidasi resolusi DNS dan jalur data IP saat Anda mengirim permintaan prediksi online ke endpoint:
```
 sudo tcpdump -i any port 53 -n or host 100.100.10.10
```
Buka sesi Cloud Shell baru (Tab Empat) dengan mengklik buka tab baru di Cloud Shell.
Dalam sesi Cloud Shell baru (Tab Empat), jalankan perintah berikut, ganti PROJECT_ID dengan project ID Anda:
```
projectid=PROJECT_ID
gcloud config set project ${projectid}
```

Di Tab Empat, login ke instance private-client:

gcloud compute ssh \
    --zone "us-central1-a" "private-client" \
    --project "$projectid"

Dari VM private-client (Tab Empat), menggunakan editor teks seperti vim atau nano, buat file instances.json yang berisi string data berikut:

{"instances": [
   [0.23, 'Ideal', 'E', 'VS2', 61.5, 55.0, 3.95, 3.98, 2.43],
   [0.29, 'Premium', 'J', 'Internally Flawless', 52.5, 49.0, 4.00, 2.13, 3.11]]}

Dari VM private-client (Tab Empat), jalankan perintah berikut, dengan mengganti PROJECT_ID dengan nama project Anda dan ENDPOINT_ID dengan ID endpoint PSC:
```
projectid=PROJECT_ID
echo $projectid
ENDPOINT_ID=ENDPOINT_ID
```

Dari VM private-client (Tab Empat), jalankan perintah berikut untuk mengirim permintaan prediksi online:

curl -v -X POST -H "Authorization: Bearer $(gcloud auth print-access-token)" -H "Content-Type: application/json" https://us-central1-aiplatform.googleapis.com/v1/projects/${projectid}/locations/us-central1/endpoints/${ENDPOINT_ID}:predict -d @instances.json

Dari VM private-client di Cloud Shell (Tab Tiga), pastikan alamat IP endpoint PSC (100.100.10.10) digunakan untuk mengakses Vertex AI API.

Dari terminal private-client tcpdump di Tab Tiga Cloud Shell, Anda dapat melihat bahwa pencarian DNS ke us-central1-aiplatform.googleapis.com tidak diperlukan, karena baris yang Anda tambahkan ke file /etc/hosts lebih diprioritaskan, dan alamat IP PSC 100.100.10.10 digunakan di jalur data.

Pembersihan

Agar akun Google Cloud Anda tidak dikenai biaya untuk resource yang digunakan dalam tutorial ini, hapus project yang berisi resource tersebut, atau simpan project dan hapus setiap resource.

Anda dapat menghapus setiap resource dalam project dengan cara berikut:

Hapus instance Vertex AI Workbench sebagai berikut:
1. Di konsol Google Cloud, di bagian Vertex AI, buka tab Instances di halaman Workbench.
  
  Buka Vertex AI Workbench
2. Pilih workbench-tutorial instance Vertex AI Workbench dan klik Delete.
Hapus image container sebagai berikut:
1. Di konsol Google Cloud, buka halaman Artifact Registry.
  
  Buka Artifact Registry
2. Pilih penampung Docker diamonds, lalu klik Delete.
Hapus bucket penyimpanan sebagai berikut:
1. Di konsol Google Cloud, buka halaman Cloud Storage.
  
  Buka Cloud Storage
2. Pilih bucket penyimpanan Anda, lalu klik Hapus.
Batalkan deployment model dari endpoint sebagai berikut:
1. Di konsol Google Cloud, di bagian Vertex AI, buka halaman Endpoints.
  
  Buka Endpoint
2. Klik diamonds-cpr_endpoint untuk membuka halaman detail endpoint.
3. Di baris untuk model Anda, diamonds-cpr, klik Batalkan deployment model .
4. Pada dialog Batalkan deployment model dari endpoint, klik Batalkan deployment.
Hapus model sebagai berikut:
1. Di konsol Google Cloud, di bagian Vertex AI, buka halaman Model Registry.
  
  Buka Model Registry
2. Pilih model diamonds-cpr.
3. Untuk menghapus model, klik Actions, lalu klik Delete model.
Hapus endpoint prediksi online sebagai berikut:
1. Di konsol Google Cloud, di bagian Vertex AI, buka halaman Online prediction.
  
  Buka Prediksi online
2. Pilih endpoint diamonds-cpr_endpoint.
3. Untuk menghapus endpoint, klik Tindakan, lalu klik Hapus endpoint.

Di Cloud Shell, hapus resource yang tersisa dengan menjalankan perintah berikut.

Buka Cloud Shell

projectid=PROJECT_ID
gcloud config set project ${projectid}

gcloud compute forwarding-rules delete pscvertex \
    --global \
    --quiet

gcloud compute addresses delete psc-ip \
    --global \
    --quiet

gcloud compute networks subnets delete workbench-subnet \
    --region=us-central1 \
    --quiet

gcloud compute vpn-tunnels delete aiml-vpc-tunnel0 aiml-vpc-tunnel1 on-prem-tunnel0 on-prem-tunnel1 \
    --region=us-central1 \
    --quiet

gcloud compute vpn-gateways delete aiml-vpn-gw on-prem-vpn-gw \
    --region=us-central1 \
    --quiet

gcloud compute routers nats delete cloud-nat-us-central1 \
    --router=cloud-router-us-central1-aiml-nat \
    --region=us-central1 \
    --quiet

gcloud compute routers delete aiml-cr-us-central1 cloud-router-us-central1-aiml-nat \
    --region=us-central1 \
    --quiet

gcloud compute routers delete cloud-router-us-central1-on-prem-nat on-prem-cr-us-central1 \
    --region=us-central1 \
    --quiet

gcloud compute instances delete nat-client private-client \
    --zone=us-central1-a \
    --quiet

gcloud compute firewall-rules delete ssh-iap-on-prem-vpc \
    --quiet

gcloud compute networks subnets delete nat-subnet  private-ip-subnet \
    --region=us-central1 \
    --quiet

gcloud compute networks delete on-prem-vpc \
    --quiet

gcloud compute networks delete aiml-vpc \
    --quiet

gcloud iam service-accounts delete gce-vertex-sa@$projectid.iam.gserviceaccount.com \
    --quiet

gcloud iam service-accounts delete workbench-sa@$projectid.iam.gserviceaccount.com \
    --quiet

Langkah selanjutnya

Pelajari opsi jaringan perusahaan untuk mengakses endpoint dan layanan Vertex AI
Pelajari cara kerja Private Service Connect dan alasannya menawarkan manfaat performa yang signifikan.
Pelajari cara menggunakan Kontrol Layanan VPC untuk membuat perimeter yang aman guna mengizinkan atau menolak akses ke Vertex AI dan Google API lainnya di endpoint prediksi online Anda.
Pelajari cara dan alasan menggunakan zona penerusan DNS, bukan memperbarui file /etc/hosts dalam skala besar dan lingkungan produksi.

Menggunakan Private Service Connect untuk mengakses prediksi online Vertex AI dari infrastruktur lokal

Tujuan

Biaya

Sebelum memulai

Membuat jaringan VPC

Buat jaringan VPC untuk endpoint prediksi online (aiml-vpc)

Buat jaringan VPC "on-premises" (on-prem-vpc)

Membuat endpoint Private Service Connect (PSC)

Mengonfigurasi konektivitas hybrid

Buat tunnel VPN untuk aiml-vpc

Buat tunnel VPN untuk on-prem-vpc

Membuat sesi BGP

Membuat sesi BGP untuk aiml-vpc

Membuat sesi BGP untuk on-prem-vpc

Memvalidasi pembuatan sesi BGP

Memvalidasi bahwa aiml-vpc telah mempelajari rute subnet melalui VPN dengan ketersediaan tinggi (HA)

Memvalidasi bahwa on-prem-vpc telah mempelajari rute subnet melalui VPN dengan ketersediaan tinggi (HA)

Membuat rute kustom yang diiklankan untuk aiml-vpc

Validasi bahwa on-prem-vpc telah mempelajari alamat IP endpoint PSC melalui VPN dengan ketersediaan tinggi (HA)

Membuat rute kustom yang diiklankan untuk on-prem-vpc

Validasi bahwa aiml-vpc telah mempelajari rute private-ip-subnet dari on-prem-vpc

Membuat instance VM pengujian

Membuat akun layanan yang dikelola pengguna

Membuat instance VM pengujian

Membuat instance Vertex AI Workbench

Membuat akun layanan yang dikelola pengguna untuk Vertex AI Workbench

Membuat instance Vertex AI Workbench

Membuat dan men-deploy model prediksi online

Menyiapkan lingkungan Anda

Melatih model

Menyimpan artefak prapemrosesan

Mem-build penampung penayangan kustom menggunakan server model CPR

Men-deploy model ke endpoint model prediksi online

Memvalidasi akses internet publik ke Vertex AI API

Memvalidasi akses pribadi ke Vertex AI API

Pembersihan

Langkah selanjutnya

Buat jaringan VPC untuk endpoint prediksi online (`aiml-vpc`)

Buat jaringan VPC "on-premises" (`on-prem-vpc`)

Buat tunnel VPN untuk `aiml-vpc`

Buat tunnel VPN untuk `on-prem-vpc`

Membuat sesi BGP untuk `aiml-vpc`

Membuat sesi BGP untuk `on-prem-vpc`

Memvalidasi bahwa `aiml-vpc` telah mempelajari rute subnet melalui VPN dengan ketersediaan tinggi (HA)

Memvalidasi bahwa `on-prem-vpc` telah mempelajari rute subnet melalui VPN dengan ketersediaan tinggi (HA)

Membuat rute kustom yang diiklankan untuk `aiml-vpc`

Validasi bahwa `on-prem-vpc` telah mempelajari alamat IP endpoint PSC melalui VPN dengan ketersediaan tinggi (HA)

Membuat rute kustom yang diiklankan untuk `on-prem-vpc`

Validasi bahwa `aiml-vpc` telah mempelajari rute `private-ip-subnet` dari `on-prem-vpc`