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

Membuat jaringan VPC

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

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

1. Buat jaringan VPC:

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

2. 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
   

3. 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
   

4. 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
   

Membuat jaringan VPC "lokal" (on-prem-vpc)

1. Buat jaringan VPC:

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

2. 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
   

3. 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
   

4. 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
   

5. 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 aiml-vpc-cloud-router-vpn sebagai iklan router kustom ke jaringan lokal di langkah selanjutnya.

1. Cadangkan alamat IP untuk endpoint PSC:

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

2. Buat endpoint PSC:

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

3. Buat daftar endpoint PSC yang dikonfigurasi dan pastikan endpoint pscvertex telah dibuat:

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

4. 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 (HA VPN) yang terhubung satu sama lain. Setiap gateway berisi Cloud Router dan sepasang tunnel VPN.

1. 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
   

2. 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
   

3. Di Konsol Google Cloud, buka halaman VPN.

   Buka VPN

4. Di halaman VPN, klik tab Cloud VPN Gateways.

5. Dalam daftar gateway VPN, pastikan ada dua gateway dan masing-masing memiliki dua alamat IP.

6. 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
   

7. 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
   

Membuat tunnel VPN untuk aiml-vpc

1. 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
   

2. 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
   

Membuat tunnel VPN untuk on-prem-vpc

1. 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
   

2. 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
   

3. Di Konsol Google Cloud, buka halaman VPN.

   Buka VPN

4. Di halaman VPN, klik tab Cloud VPN Tunnels.

5. Dalam daftar tunnel VPN, pastikan empat tunnel VPN telah dibuat.

Membuat sesi BGP

Cloud Router menggunakan Border Gateway Protocol (BGP) untuk menukar rute antara jaringan VPC Anda (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 Anda. Antarmuka dan konfigurasi peer BGP secara bersama-sama membentuk sesi BGP. Di bagian ini, Anda akan membuat dua sesi BGP untuk aiml-vpc dan dua untuk on-prem-vpc.

Menetapkan sesi BGP untuk aiml-vpc

1. 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
   

2. 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
   

3. 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
   

4. 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
   

Menetapkan sesi BGP untuk on-prem-vpc

1. Buat antarmuka BGP yang 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
   

2. 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
   

3. 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
   

4. 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

1. Di Konsol Google Cloud, buka halaman VPN.

   Buka VPN

2. Di halaman VPN, klik tab Cloud VPN Tunnels.

3. Dalam daftar tunnel VPN, Anda akan melihat bahwa nilai di kolom status sesi BGP untuk masing-masing dari keempat tunnel telah berubah dari Konfigurasi sesi BGP menjadi BGP yang ditetapkan. 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)

1. Di Konsol Google Cloud, buka halaman jaringan VPC.

   Buka VPC networks

2. Dalam daftar jaringan VPC, klik aiml-vpc.

3. Klik tab Routes.

4. Pilih us-central1 (Iowa) di daftar Region lalu klik View.

5. Di kolom Destination IP range, 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)

1. Di Konsol Google Cloud, buka halaman jaringan VPC.

   Buka VPC networks

2. Dalam daftar jaringan VPC, klik on-prem-vpc.

3. Klik tab Routes.

4. Pilih us-central1 (Iowa) di daftar Region lalu klik View.

5. Di kolom Destination IP range, pastikan jaringan VPC on-prem-vpc telah mempelajari rute dari subnet workbench-subnet (172.16.10.0/28) jaringan VPC aiml-vpc.

Buat iklan rute kustom 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 perlu membuat iklan rute kustom dari Cloud Router aiml-cr-us-central untuk Alamat IP endpoint 100.100.10.10 yang akan diiklankan ke lingkungan lokal melalui BGP ke on-prem-vpc.

1. Di konsol Google Cloud, buka halaman Cloud Router.

   Buka Cloud Router

2. Dalam daftar Cloud Router, klik aiml-cr-us-central1.

3. Di halaman detail Router, klik edit Edit.

4. Di bagian Advertised routes untuk Routes, pilih Create custom routes.

5. Klik Add a custom route.

6. Untuk Sumber, pilih Rentang IP kustom.

7. Untuk rentang alamat IP, masukkan 100.100.10.10.

8. Untuk Description, masukkan Private Service Connect Endpoint IP.

9. Klik Done, lalu klik Save.

Memvalidasi bahwa on-prem-vpc telah mempelajari Alamat IP Endpoint PSC melalui VPN dengan ketersediaan tinggi (HA)

1. Di Konsol Google Cloud, buka halaman jaringan VPC.

   Buka VPC networks

2. Dalam daftar jaringan VPC, klik on-prem-vpc.

3. Klik tab Routes.

4. Pilih us-central1 (Iowa) di daftar Region lalu klik View.

5. Di kolom Destination IP range, pastikan bahwa jaringan VPC on-prem-vpc telah mempelajari alamat IP endpoint PSC (100.100.10.10).

Buat iklan rute kustom 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 pemberitahuan rute dari Cloud Router on-prem-cr-us-central1.

1. Di konsol Google Cloud, buka halaman Cloud Router.

   Buka Cloud Router

2. Dalam daftar Cloud Router, klik on-prem-cr-us-central1.

3. Di halaman detail Router, klik edit Edit.

4. Di bagian Advertised routes, untuk Routes, pilih Create custom routes.

5. Jika kotak centang Beriklan semua subnet yang terlihat Cloud Router dicentang, hapus centang tersebut.

6. Klik Add a custom route.

7. Untuk Sumber, pilih Rentang IP kustom.

8. Untuk rentang alamat IP, masukkan 192.168.20.0/28.

9. Untuk Description, masukkan Private Service Connect Endpoint IP subnet (private-ip-subnet).

10. Klik Done, lalu klik Save.

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

1. Di Konsol Google Cloud, buka halaman jaringan VPC.

   Buka VPC networks

2. Dalam daftar jaringan VPC, klik aiml-vpc.

3. Klik tab Routes.

4. Pilih us-central1 (Iowa) di daftar Region lalu klik View.

5. 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 menambahkan 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 nanti Anda buat dalam tutorial ini.

1. Di Cloud Shell, buat akun layanan:

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

2. 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"
   

3. 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 guna menjangkau Vertex AI API, khususnya:

• Instance nat-client menggunakan Cloud NAT untuk me-resolve Vertex AI guna 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 dengan ketersediaan tinggi (HA).

Agar Identity-Aware Proxy (IAP) dapat terhubung ke instance VM, buat aturan firewall yang:

• Berlaku untuk semua instance VM yang ingin Anda sediakan akses 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.

1. 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=http://www.googleapis.com/auth/cloud-platform \
      --no-address \
      --metadata startup-script="#! /bin/bash
         sudo apt-get update
         sudo apt-get install tcpdump dnsutils -y"
   

2. 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=http://www.googleapis.com/auth/cloud-platform \
      --no-address \
      --metadata startup-script="#! /bin/bash
         sudo apt-get update
         sudo apt-get install tcpdump dnsutils -y"
   

3. 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 notebook yang dikelola pengguna

Membuat akun layanan yang dikelola pengguna

Saat Anda membuat instance notebook yang dikelola pengguna Vertex AI Workbench, Google sangat menyarankan agar Anda menentukan akun layanan yang dikelola pengguna, bukan menggunakan akun layanan default Compute Engine. Akun layanan default Compute Engine (dan juga siapa pun yang Anda tentukan sebagai pengguna instance) diberi peran Editor (roles/editor) pada project Google Cloud Anda. Anda dapat menonaktifkan perilaku ini dengan menonaktifkan pemberian peran otomatis untuk akun layanan default.

1. Di Cloud Shell, buat akun layanan bernama user-managed-notebook-sa:

   gcloud iam service-accounts create user-managed-notebook-sa \
      --display-name="user-managed-notebook-sa"
   

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

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

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

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

4. Tetapkan peran IAM Artifact Registry Administrator ke akun layanan:

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

Membuat instance notebook yang dikelola pengguna

Buat instance notebook yang dikelola pengguna, dengan menentukan akun layanan user-managed-notebook-sa.

1. Buat instance notebook yang dikelola pengguna:

   gcloud notebooks 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 \
      --subnet=workbench-subnet \
      --no-public-ip \
      --service-account=user-managed-notebook-sa@$projectid.iam.gserviceaccount.com
   

Membuat dan men-deploy model prediksi online

Menyiapkan lingkungan Anda

1. Di konsol Google Cloud, buka tab User-managed notebooks di halaman Vertex AI Workbench.

   Buka Notebook yang dikelola pengguna

2. Di samping nama instance notebook yang dikelola pengguna, klik Open JupyterLab.

   Instance notebook yang dikelola pengguna akan membuka JupyterLab.

   Di bagian selanjutnya, hingga dan termasuk deployment model, Anda akan bekerja di Jupyterlab, bukan Konsol Google Cloud atau Cloud Shell.

3. Pilih File > New > Terminal.

4. Di terminal JupyterLab (bukan Cloud Shell), tentukan variabel lingkungan untuk project Anda. Ganti PROJECT_ID dengan project ID Anda:

   PROJECT_ID=PROJECT_ID
   

5. Buat direktori baru bernama cpr-codelab dan cd ke dalamnya (masih di terminal JupyterLab):

   mkdir cpr-codelab
   cd cpr-codelab
   

6. Di folder File Browser, klik dua kali folder cpr-codelab baru.

   Jika folder ini tidak muncul di file browser, refresh tab browser Google Cloud Console, lalu coba lagi.

7. Pilih File > New > Notebook.

8. Dari menu Select Kernel, pilih Python 3, lalu klik Select.

9. Ganti nama file notebook baru Anda sebagai berikut:

   Di folder 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 berikut, Anda membuat model di notebook Jupyterlab dengan membuat sel notebook baru, menempelkan kode ke dalamnya, dan menjalankan sel.

10. Instal dependensi sebagai berikut.

    1. Saat membuka notebook baru, ada sel kode default tempat Anda dapat memasukkan kode. Tampilannya terlihat seperti [ ]: diikuti dengan kolom teks. Kolom teks tersebut adalah tempat Anda menempelkan kode.

       Tempel kode berikut ke dalam sel, lalu klik play_arrow 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.0.0
       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 add Sisipkan sel di bawah, tempelkan kode ke dalam sel, lalu klik play_arrow Jalankan sel yang dipilih dan lanjutkan.

       Gunakan Pip untuk menginstal dependensi dalam 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 artefak model dan pra-pemrosesan:

       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 folder File Browser, struktur direktori cpr-codelab 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:

1. 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)
   

2. 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"
   

3. Membuat bucket Cloud Storage:

   gsutil mb -l us-central1 $BUCKET_NAME
   

4. Muat data dari library seaborn, lalu buat dua data frame, 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'])
   

5. Lihat data pelatihan dan pastikan setiap baris mewakili berlian.

   x_train.head()
   

6. Lihat label yang merupakan harga terkait.

   y_train.head()
   

7. Tentukan transformasi kolom sklearn ke satu hot encode fitur kategoris dan skalakan fitur numerik:

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

8. Tentukan model forest acak:

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

9. Buat pipeline sklearn. Pipeline ini mengambil data input, mengenkode dan menskalakannya, dan meneruskannya ke model.

   my_pipeline = make_pipeline(column_transform, regr)
   

10. Latih model:

    my_pipeline.fit(x_train, y_train)
    

11. 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.

12. Simpan pipeline ke direktori model_artifacts lalu salin ke bucket Cloud Storage Anda:

    joblib.dump(my_pipeline, 'model_artifacts/model.joblib')
    
    !gsutil cp model_artifacts/model.joblib {BUCKET_NAME}/{MODEL_ARTIFACT_DIR}/
    

Menyimpan artefak pra-pemrosesan

1. Buat artefak pra-pemrosesan. Artefak ini akan dimuat ke penampung kustom saat server model dimulai. Artefak prapemrosesan Anda dapat berupa hampir semua bentuk (seperti file acar), 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"}
   

Membangun penampung penayangan kustom menggunakan server model CPR

1. Fitur clarity dalam data pelatihan kami selalu dalam bentuk yang disingkat (yaitu "FL", bukan "Flawless"). Pada waktu penayangan, kita ingin memeriksa apakah data untuk fitur ini juga disingkat. Ini karena model kita mengetahui cara melakukan enkode hot "FL" tetapi tidak dengan "Flawless". Anda akan menulis logika pra-pemrosesan kustom ini nanti. 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)
   
   !gsutil cp model_artifacts/preprocessor.json {BUCKET_NAME}/{MODEL_ARTIFACT_DIR}/
   

   Di folder 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
   

2. Di notebook Anda, 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, prapemrosesan, dan pascapemrosesan, 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)]}
   

3. Gunakan Vertex AI SDK untuk Python guna membuat image menggunakan rutinitas prediksi kustom. Dockerfile telah dibuat dan image dibuat 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"),
   )
   

4. Tulis file pengujian dengan dua sampel untuk prediksi. Salah satu instance memiliki nama kejelasan yang disingkat, tetapi instance yang lain 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)
   

5. Menguji 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()
   

6. Anda dapat melihat hasil prediksi dengan:

   predict_response.content
   

Men-deploy model ke endpoint model prediksi online

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

1. 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
   

2. Kirim gambar.

   local_model.push_image()
   

3. Upload model.

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

4. Deploy model:

   endpoint = model.deploy(machine_type="n1-standard-2")
   

   Tunggu hingga model di-deploy sebelum Anda melanjutkan ke langkah berikutnya. Proses deployment diperkirakan akan memerlukan waktu setidaknya 10 hingga 15 menit.

5. 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]])
   

Memvalidasi akses internet publik ke Vertex AI API

Di bagian ini, Anda akan login ke instance VM nat-client dalam 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.

1. Di Cloud Shell (Tab One), jalankan perintah berikut, dengan mengganti PROJECT_ID dengan project ID Anda:

   projectid=PROJECT_ID
   gcloud config set project ${projectid}
   

2. Login ke instance VM nat-client menggunakan IAP:

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

3. Jalankan perintah dig:

   dig us-central1-aiplatform.googleapis.com
   

4. Dari VM nat-client (Tab One), jalankan perintah berikut untuk memvalidasi resolusi DNS saat Anda mengirim permintaan prediksi online ke endpoint.

    sudo tcpdump -i any port 53 -n
   

5. Buka sesi Cloud Shell baru (Tab Dua) dengan mengklik add buka tab baru di Cloud Shell.

6. Pada sesi Cloud Shell baru (Tab Dua), jalankan perintah berikut, dengan mengganti PROJECT_ID dengan project ID Anda:

   projectid=PROJECT_ID
   gcloud config set project ${projectid}
   

7. Login ke instance VM nat-client:

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

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

   sudo vim instances.json
   

9. Tambahkan string data berikut ke file tersebut:

   {"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]]}
   

10. 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.

11. Temukan ID endpoint prediksi online untuk endpoint PC:

    1. Di konsol Google Cloud, di bagian Vertex AI, buka tab Endpoint di halaman Prediksi online.

       Buka Endpoint

    2. Cari baris endpoint yang Anda buat, yang bernama diamonds-cpr_endpoint.

    3. Temukan ID endpoint 19 digit di kolom ID, lalu salin ID tersebut.

12. Di Cloud Shell, dari VM nat-client (Tab Two), 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
    

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

    curl -X POST -H "Authorization: Bearer $(gcloud auth print-access-token)" -H "Content-Type: application/json" http://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 One) 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 Anda memvalidasi konektivitas ke Vertex AI API dengan menjalankan perintah dig terhadap domain Vertex AI (us-central1-aiplatform.googleapis.com).

1. Buka sesi Cloud Shell baru (Tab Tiga) dengan mengklik add buka tab baru di Cloud Shell. Ini adalah Tab Tiga.

2. Pada sesi Cloud Shell baru (Tab Tiga), jalankan perintah berikut, dengan mengganti PROJECT_ID dengan project ID Anda:

   projectid=PROJECT_ID
   gcloud config set project ${projectid}
   

3. Login ke instance VM private-client menggunakan IAP:

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

4. Jalankan perintah dig:

   dig us-central1-aiplatform.googleapis.com
   

5. 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
   

6. Dari VM private-client (Tab Three), lakukan ping ke endpoint Vertex AI dan Control+C untuk keluar saat Anda melihat output:

   ping us-central1-aiplatform.googleapis.com
   

   Perintah ping akan menampilkan output berikut yang berisi alamat IP endpoint PC:

   PING us-central1-aiplatform.googleapis.com (100.100.10.10) 56(84) bytes of data.
   

7. Dari VM private-client (Tab Three), 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
   

8. Buka sesi Cloud Shell baru (Tab Four) dengan mengklik add buka tab baru di Cloud Shell.

9. Pada sesi Cloud Shell baru (Tab Four), jalankan perintah berikut, dengan mengganti PROJECT_ID dengan project ID Anda:

   projectid=PROJECT_ID
   gcloud config set project ${projectid}
   

10. Di Tab Empat, login ke instance private-client:

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

11. Dari VM private-client (Tab Four), dengan 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]]}
    

12. Dari VM private-client (Tab Four), jalankan perintah berikut, ganti PROJECT_ID dengan nama project Anda dan ENDPOINT_ID dengan ID endpoint PSC:

    projectid=PROJECT_ID
    echo $projectid
    ENDPOINT_ID=ENDPOINT_ID
    

13. Dari VM private-client (Tab Four), 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" http://us-central1-aiplatform.googleapis.com/v1/projects/${projectid}/locations/us-central1/endpoints/${ENDPOINT_ID}:predict -d @instances.json
    

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

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