Menggunakan Private Service Connect untuk mengakses pipeline pelatihan dari lokal

---

Vertex AI Pipelines adalah layanan terkelola yang membantu Anda mem-build, men-deploy, dan mengelola alur kerja machine learning (ML) menyeluruh di platform Google Cloud. Cloud Run menyediakan lingkungan serverless untuk menjalankan pipeline sehingga Anda tidak perlu khawatir dengan pengelolaan infrastruktur.

Dalam tutorial ini, Anda akan menggunakan Vertex AI Pipelines untuk menjalankan tugas pelatihan kustom dan men-deploy model terlatih di Vertex AI, dalam lingkungan jaringan hibrida.

Seluruh proses ini memerlukan waktu dua hingga tiga jam untuk diselesaikan, termasuk sekitar 50 menit untuk menjalankan pipeline.

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.

Tujuan

• Buat dua jaringan Virtual Private Cloud (VPC):
  • Satu (vertex-networking-vpc) adalah untuk menggunakan Vertex AI Pipelines API untuk membuat dan menghosting template pipeline guna melatih model machine learning dan men-deploynya ke endpoint.
  • Yang lainnya (onprem-dataservice-vpc) mewakili jaringan lokal.
• Hubungkan kedua jaringan VPC sebagai berikut:
  • Deploy gateway VPN dengan ketersediaan tinggi (HA), tunnel Cloud VPN, dan Cloud Router untuk menghubungkan vertex-networking-vpc dan onprem-dataservice-vpc.
  • Buat endpoint Private Service Connect (PSC) untuk meneruskan permintaan pribadi ke Vertex AI Pipelines REST API.
  • Konfigurasikan pemberitahuan rute kustom Cloud Router di vertex-networking-vpc untuk mengumumkan rute untuk endpoint Private Service Connect ke onprem-dataservice-vpc.
• Buat instance Filestore di jaringan VPC onprem-dataservice-vpc dan tambahkan data pelatihan ke dalamnya dalam berbagi NFS.
• Buat aplikasi paket Python untuk tugas pelatihan.
• Buat template tugas Vertex AI Pipelines untuk melakukan hal berikut:
  • Buat dan jalankan tugas pelatihan pada data dari berbagi NFS.
  • Mengimpor model yang telah dilatih dan menguploadnya ke Vertex AI Model Registry.
  • Membuat endpoint Vertex AI untuk prediksi online.
  • Deploy model ke endpoint.
• Upload template pipeline ke repositori Artifact Registry.
• Gunakan Vertex AI Pipelines REST API untuk memicu pipeline yang dijalankan dari host layanan data on-premise (on-prem-dataservice-host).

Biaya

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

• Cloud NAT
• Cloud Storage
• Cloud VPN
• Compute Engine
• Filestore
• Vertex AI
• Virtual Private Cloud

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

1. In the Google Cloud console, go to the project selector page.

   Go to project selector

2. Select or create a Google Cloud project.

3. Make sure that billing is enabled for your Google Cloud project.

4. 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.
5. 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.
6. Jika Anda bukan pemilik project, minta pemilik project untuk memberi Anda peran Project IAM Admin (roles/resourcemanager.projectIamAdmin). Anda harus memiliki peran ini untuk memberikan peran IAM pada langkah berikutnya.

7. Grant roles to your user account. Run the following command once for each of the following IAM roles: roles/artifactregistry.admin, roles/artifactregistry.repoAdmin, roles/compute.instanceAdmin.v1, roles/compute.networkAdmin, roles/compute.securityAdmin, roles/dns.admin, roles/file.editor, roles/logging.viewer, roles/logging.admin, roles/notebooks.admin, roles/iam.serviceAccountAdmin, roles/iam.serviceAccountUser, roles/servicedirectory.editor, roles/servicemanagement.quotaAdmin, roles/serviceusage.serviceUsageAdmin, roles/storage.admin, roles/storage.objectAdmin, roles/aiplatform.admin, roles/aiplatform.user, roles/aiplatform.viewer, roles/iap.admin, roles/iap.tunnelResourceAccessor, roles/resourcemanager.projectIamAdmin

   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:[e-mail].

   • Replace ROLE with each individual role.

8. Enable the DNS, Artifact Registry, IAM, Compute Engine, Cloud Logging, Network Connectivity, Notebooks, Cloud Filestore, Service Networking, Service Usage, and Vertex AI APIs:

   gcloud services enable dns.googleapis.com artifactregistry.googleapis.com iam.googleapis.com compute.googleapis.com logging.googleapis.com networkconnectivity.googleapis.com notebooks.googleapis.com file.googleapis.com servicenetworking.googleapis.com serviceusage.googleapis.com aiplatform.googleapis.com

Membuat jaringan VPC

Di bagian ini, Anda akan membuat dua jaringan VPC: satu untuk mengakses Google API untuk Vertex AI Pipelines, dan satu lagi untuk menyimulasikan jaringan lokal. 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.

1. Di Cloud Shell, jalankan perintah berikut, ganti PROJECT_ID dengan project ID Anda:

   projectid=PROJECT_ID
   gcloud config set project ${projectid}
   

2. Buat jaringan VPC vertex-networking-vpc:

   gcloud compute networks create vertex-networking-vpc \
       --subnet-mode custom
   

3. Di jaringan vertex-networking-vpc, buat subnet bernama pipeline-networking-subnet1, dengan rentang IPv4 utama 10.0.0.0/24:

   gcloud compute networks subnets create pipeline-networking-subnet1 \
       --range=10.0.0.0/24 \
       --network=vertex-networking-vpc \
       --region=us-central1 \
       --enable-private-ip-google-access
   

4. Buat jaringan VPC untuk menyimulasikan jaringan lokal (onprem-dataservice-vpc):

   gcloud compute networks create onprem-dataservice-vpc \
       --subnet-mode custom
   

5. Di jaringan onprem-dataservice-vpc, buat subnet bernama onprem-dataservice-vpc-subnet1, dengan rentang IPv4 utama 172.16.10.0/24:

   gcloud compute networks subnets create onprem-dataservice-vpc-subnet1 \
       --network onprem-dataservice-vpc \
       --range 172.16.10.0/24 \
       --region us-central1 \
       --enable-private-ip-google-access
   

Memastikan jaringan VPC dikonfigurasi dengan benar

1. Di konsol Google Cloud, buka tab Networks in current project di halaman VPC networks.

   Buka jaringan VPC

2. Dalam daftar jaringan VPC, pastikan kedua jaringan telah dibuat: vertex-networking-vpc dan onprem-dataservice-vpc.

3. Klik tab Subnets in current project.

4. Dalam daftar subnet VPC, pastikan subnet pipeline-networking-subnet1 dan onprem-dataservice-vpc-subnet1 telah dibuat.

Mengonfigurasi konektivitas hybrid

Di bagian ini, Anda akan membuat dua gateway VPN dengan ketersediaan tinggi (HA) yang saling terhubung. Satu berada di jaringan VPC vertex-networking-vpc. Yang lainnya berada di jaringan VPC onprem-dataservice-vpc. Setiap gateway berisi Cloud Router dan sepasang tunnel VPN.

Membuat gateway VPN dengan ketersediaan tinggi (HA)

1. Di Cloud Shell, buat gateway VPN dengan ketersediaan tinggi (HA) untuk jaringan VPC vertex-networking-vpc:

   gcloud compute vpn-gateways create vertex-networking-vpn-gw1 \
       --network vertex-networking-vpc \
       --region us-central1
   

2. Buat gateway VPN dengan ketersediaan tinggi (HA) untuk jaringan VPC onprem-dataservice-vpc:

   gcloud compute vpn-gateways create onprem-vpn-gw1 \
       --network onprem-dataservice-vpc \
       --region us-central1
   

3. Di konsol Google Cloud, buka tab Cloud VPN Gateways di halaman VPN.

   Buka VPN

4. Pastikan dua gateway (vertex-networking-vpn-gw1 dan onprem-vpn-gw1) telah dibuat dan setiap gateway memiliki dua alamat IP antarmuka.

Membuat Cloud Router dan gateway Cloud NAT

Di setiap dua jaringan VPC, Anda membuat dua Cloud Router: satu untuk digunakan dengan Cloud NAT dan satu untuk mengelola sesi BGP untuk VPN dengan ketersediaan tinggi (HA).

1. Di Cloud Shell, buat Cloud Router untuk jaringan VPC vertex-networking-vpc yang akan digunakan untuk VPN:

   gcloud compute routers create vertex-networking-vpc-router1 \
       --region us-central1 \
       --network vertex-networking-vpc \
       --asn 65001
   

2. Buat Cloud Router untuk jaringan VPC onprem-dataservice-vpc yang akan digunakan untuk VPN:

   gcloud compute routers create onprem-dataservice-vpc-router1 \
       --region us-central1 \
       --network onprem-dataservice-vpc \
       --asn 65002
   

3. Buat Cloud Router untuk jaringan VPC vertex-networking-vpc yang akan digunakan untuk Cloud NAT:

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

4. Konfigurasikan gateway Cloud NAT di Cloud Router:

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

5. Buat Cloud Router untuk jaringan VPC onprem-dataservice-vpc yang akan digunakan untuk Cloud NAT:

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

6. Konfigurasikan gateway Cloud NAT di Cloud Router:

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

7. Di konsol Google Cloud, buka halaman Cloud Function.

   Buka Cloud Router

8. Dalam daftar Cloud Router, pastikan router berikut telah dibuat:

   • cloud-router-us-central1-onprem-nat
   • cloud-router-us-central1-vertex-nat
   • onprem-dataservice-vpc-router1
   • vertex-networking-vpc-router1

   Anda mungkin perlu memuat ulang tab browser konsol Google Cloud untuk melihat nilai baru.

9. Dalam daftar Cloud Router, klik cloud-router-us-central1-vertex-nat.

10. Di halaman Detail router, pastikan gateway Cloud NAT cloud-nat-us-central1 telah dibuat.

11. Klik panah kembali untuk kembali ke halaman Cloud Router.

12. Dalam daftar Cloud Router, klik cloud-router-us-central1-onprem-nat.

13. Di halaman Detail router, pastikan gateway Cloud NAT cloud-nat-us-central1-on-prem telah dibuat.

Buat tunnel VPN

1. Di Cloud Shell, di jaringan vertex-networking-vpc, buat tunnel VPN bernama vertex-networking-vpc-tunnel0:

   gcloud compute vpn-tunnels create vertex-networking-vpc-tunnel0 \
       --peer-gcp-gateway onprem-vpn-gw1 \
       --region us-central1 \
       --ike-version 2 \
       --shared-secret [ZzTLxKL8fmRykwNDfCvEFIjmlYLhMucH] \
       --router vertex-networking-vpc-router1 \
       --vpn-gateway vertex-networking-vpn-gw1 \
       --interface 0
   

2. Di jaringan vertex-networking-vpc, buat tunnel VPN bernama vertex-networking-vpc-tunnel1:

   gcloud compute vpn-tunnels create vertex-networking-vpc-tunnel1 \
       --peer-gcp-gateway onprem-vpn-gw1 \
       --region us-central1 \
       --ike-version 2 \
       --shared-secret [bcyPaboPl8fSkXRmvONGJzWTrc6tRqY5] \
       --router vertex-networking-vpc-router1 \
       --vpn-gateway vertex-networking-vpn-gw1 \
       --interface 1
   

3. Di jaringan onprem-dataservice-vpc, buat tunnel VPN bernama onprem-dataservice-vpc-tunnel0:

   gcloud compute vpn-tunnels create onprem-dataservice-vpc-tunnel0 \
       --peer-gcp-gateway vertex-networking-vpn-gw1 \
       --region us-central1\
       --ike-version 2 \
       --shared-secret [ZzTLxKL8fmRykwNDfCvEFIjmlYLhMucH] \
       --router onprem-dataservice-vpc-router1 \
       --vpn-gateway onprem-vpn-gw1 \
       --interface 0
   

4. Di jaringan onprem-dataservice-vpc, buat tunnel VPN bernama onprem-dataservice-vpc-tunnel1:

   gcloud compute vpn-tunnels create onprem-dataservice-vpc-tunnel1 \
       --peer-gcp-gateway vertex-networking-vpn-gw1 \
       --region us-central1\
       --ike-version 2 \
       --shared-secret [bcyPaboPl8fSkXRmvONGJzWTrc6tRqY5] \
       --router onprem-dataservice-vpc-router1 \
       --vpn-gateway onprem-vpn-gw1 \
       --interface 1
   

5. Di Konsol Google Cloud, buka halaman VPN.

   Buka VPN

6. 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, vertex-networking-vpc) dan jaringan lokal (diwakili oleh onprem-dataservice-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 vertex-networking-vpc dan dua untuk onprem-dataservice-vpc.

Setelah Anda mengonfigurasi antarmuka dan peer BGP di antara router, antarmuka dan peer BGP tersebut akan otomatis mulai bertukar rute.

Membuat sesi BGP untuk vertex-networking-vpc

1. Di Cloud Shell, di jaringan vertex-networking-vpc, buat antarmuka BGP untuk vertex-networking-vpc-tunnel0:

   gcloud compute routers add-interface vertex-networking-vpc-router1 \
       --interface-name if-tunnel0-to-onprem \
       --ip-address 169.254.0.1 \
       --mask-length 30 \
       --vpn-tunnel vertex-networking-vpc-tunnel0 \
       --region us-central1
   

2. Di jaringan vertex-networking-vpc, buat peer BGP untuk bgp-onprem-tunnel0:

   gcloud compute routers add-bgp-peer vertex-networking-vpc-router1 \
       --peer-name bgp-onprem-tunnel0 \
       --interface if-tunnel0-to-onprem \
       --peer-ip-address 169.254.0.2 \
       --peer-asn 65002 \
       --region us-central1
   

3. Di jaringan vertex-networking-vpc, buat antarmuka BGP untuk vertex-networking-vpc-tunnel1:

   gcloud compute routers add-interface vertex-networking-vpc-router1 \
       --interface-name if-tunnel1-to-onprem \
       --ip-address 169.254.1.1 \
       --mask-length 30 \
       --vpn-tunnel vertex-networking-vpc-tunnel1 \
       --region us-central1
   

4. Di jaringan vertex-networking-vpc, buat peer BGP untuk bgp-onprem-tunnel1:

   gcloud compute routers add-bgp-peer vertex-networking-vpc-router1 \
       --peer-name bgp-onprem-tunnel1 \
       --interface if-tunnel1-to-onprem \
       --peer-ip-address 169.254.1.2 \
       --peer-asn 65002 \
       --region us-central1
   

Membuat sesi BGP untuk onprem-dataservice-vpc

1. Di jaringan onprem-dataservice-vpc, buat antarmuka BGP untuk onprem-dataservice-vpc-tunnel0:

   gcloud compute routers add-interface onprem-dataservice-vpc-router1 \
       --interface-name if-tunnel0-to-vertex-networking-vpc \
       --ip-address 169.254.0.2 \
       --mask-length 30 \
       --vpn-tunnel onprem-dataservice-vpc-tunnel0 \
       --region us-central1
   

2. Di jaringan onprem-dataservice-vpc, buat peer BGP untuk bgp-vertex-networking-vpc-tunnel0:

   gcloud compute routers add-bgp-peer onprem-dataservice-vpc-router1 \
       --peer-name bgp-vertex-networking-vpc-tunnel0 \
       --interface if-tunnel0-to-vertex-networking-vpc \
       --peer-ip-address 169.254.0.1 \
       --peer-asn 65001 \
       --region us-central1
   

3. Di jaringan onprem-dataservice-vpc, buat antarmuka BGP untuk onprem-dataservice-vpc-tunnel1:

   gcloud compute routers add-interface onprem-dataservice-vpc-router1  \
       --interface-name if-tunnel1-to-vertex-networking-vpc \
       --ip-address 169.254.1.2 \
       --mask-length 30 \
       --vpn-tunnel onprem-dataservice-vpc-tunnel1 \
       --region us-central1
   

4. Di jaringan onprem-dataservice-vpc, buat peer BGP untuk bgp-vertex-networking-vpc-tunnel1:

   gcloud compute routers add-bgp-peer onprem-dataservice-vpc-router1 \
       --peer-name bgp-vertex-networking-vpc-tunnel1 \
       --interface if-tunnel1-to-vertex-networking-vpc \
       --peer-ip-address 169.254.1.1 \
       --peer-asn 65001 \
       --region us-central1
   

Memvalidasi pembuatan sesi BGP

1. Di Konsol Google Cloud, buka halaman VPN.

   Buka VPN

2. Dalam daftar tunnel VPN, pastikan nilai di kolom BGP session status untuk setiap tunnel telah berubah dari Configure BGP session menjadi BGP established. Anda mungkin perlu memuat ulang tab browser konsol Google Cloud untuk melihat nilai baru.

Memvalidasi rute yang dipelajari onprem-dataservice-vpc

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

   Buka jaringan VPC

2. Dalam daftar jaringan VPC, klik onprem-dataservice-vpc.

3. Klik tab Routes.

4. Pilih us-central1 (Iowa) dalam daftar Region, lalu klik Lihat.

5. Di kolom Rentang IP tujuan, pastikan rentang IP subnet pipeline-networking-subnet1 (10.0.0.0/24) muncul dua kali.

   Anda mungkin perlu memuat ulang tab browser konsol Google Cloud untuk melihat kedua entri tersebut.

Memvalidasi rute yang dipelajari vertex-networking-vpc

1. Klik panah kembali untuk kembali ke halaman VPC networks.

2. Dalam daftar jaringan VPC, klik vertex-networking-vpc.

3. Klik tab Routes.

4. Pilih us-central1 (Iowa) dalam daftar Region, lalu klik Lihat.

5. Di kolom Destination IP range, pastikan rentang IP subnet onprem-dataservice-vpc-subnet1 (172.16.10.0/24) muncul dua kali.

Membuat endpoint Private Service Connect untuk Google API

Di bagian ini, Anda akan membuat endpoint Private Service Connect untuk Google API yang akan Anda gunakan untuk mengakses Vertex AI Pipelines REST API dari jaringan lokal.

1. Di Cloud Shell, reservasi alamat IP endpoint konsumen yang akan digunakan untuk mengakses Google API:

   gcloud compute addresses create psc-googleapi-ip \
       --global \
       --purpose=PRIVATE_SERVICE_CONNECT \
       --addresses=192.168.0.1 \
       --network=vertex-networking-vpc
   

2. Buat aturan penerusan untuk menghubungkan endpoint ke Google API dan layanan Google.

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

Membuat pemberitahuan rute kustom untuk vertex-networking-vpc

Di bagian ini, Anda akan membuat pemberitahuan rute kustom untuk vertex-networking-vpc-router1 (Cloud Router untuk vertex-networking-vpc) guna mengiklankan alamat IP endpoint PSC ke jaringan VPC onprem-dataservice-vpc.

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

   Buka Cloud Router

2. Dalam daftar Cloud Router, klik vertex-networking-vpc-router1.

3. Di halaman detail Router, klik Edit.

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

5. Centang kotak Beriklan semua subnet yang terlihat oleh Cloud Router untuk terus mengiklankan subnet yang tersedia untuk Cloud Router. Mengaktifkan opsi ini akan meniru perilaku Cloud Router dalam mode iklan default.

6. Klik Tambahkan rute kustom.

7. Untuk Sumber, pilih Rentang IP kustom.

8. Untuk Rentang alamat IP, masukkan alamat IP berikut:

   192.168.0.1
   

9. Untuk Deskripsi, masukkan teks berikut:

   Custom route to advertise Private Service Connect endpoint IP address
   

10. Klik Selesai, lalu klik Simpan.

Memvalidasi bahwa onprem-dataservice-vpc telah mempelajari rute yang diiklankan

1. Di Konsol Google Cloud, buka halaman Routes.

   Buka Rute

2. Pada tab Effective routes, lakukan hal berikut:

   1. Untuk Network, pilih onprem-dataservice-vpc.
   2. Untuk Region, pilih us-central1 (Iowa).
   3. Klik View.

   4. Dalam daftar rute, pastikan ada dua entri yang namanya dimulai dengan onprem-dataservice-vpc-router1-bgp-vertex-networking-vpc-tunnel0 dan dua yang dimulai dengan onprem-dataservice-vpc-router1-bgp-vertex-networking-vpc-tunnel1.

      Jika entri ini tidak langsung muncul, tunggu beberapa menit, lalu muat ulang tab browser konsol Google Cloud.

   5. Pastikan dua entri memiliki Rentang IP tujuan 192.168.0.1/32 dan dua entri memiliki Rentang IP tujuan 10.0.0.0/24.

Membuat VM dalam instance di onprem-dataservice-vpc

Di bagian ini, Anda akan membuat instance VM yang menyimulasikan host layanan data on-premise. Dengan mengikuti praktik terbaik Compute Engine dan IAM, VM ini menggunakan akun layanan yang dikelola pengguna, bukan akun layanan default Compute Engine.

Membuat akun layanan yang dikelola pengguna untuk instance VM

1. Di Cloud Shell, jalankan perintah berikut, ganti PROJECT_ID dengan project ID Anda:

   projectid=PROJECT_ID
   gcloud config set project ${projectid}
   

2. Buat akun layanan bernama onprem-user-managed-sa:

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

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

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

4. Tetapkan peran Vertex AI Viewer (roles/aiplatform.viewer):

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

5. Tetapkan peran Filestore Editor (roles/file.editor):

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

6. Tetapkan peran Service Account Admin (roles/iam.serviceAccountAdmin):

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

7. Tetapkan peran Service Account User (roles/iam.serviceAccountUser):

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

8. Tetapkan peran Pembaca Artifact Registry (roles/artifactregistry.reader):

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

9. Tetapkan peran Storage Object Admin (roles/storage.objectAdmin):

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

10. Tetapkan peran Logging Admin (roles/logging.admin):

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

Membuat instance VM on-prem-dataservice-host

Instance VM yang Anda buat tidak memiliki alamat IP eksternal dan tidak mengizinkan akses langsung melalui internet. Untuk mengaktifkan akses administratif ke VM, Anda menggunakan penerusan TCP Identity-Aware Proxy (IAP).

1. Di Cloud Shell, buat instance VM on-prem-dataservice-host:

   gcloud compute instances create on-prem-dataservice-host \
       --zone=us-central1-a \
       --image-family=debian-11 \
       --image-project=debian-cloud \
       --subnet=onprem-dataservice-vpc-subnet1 \
       --scopes=https://www.googleapis.com/auth/cloud-platform \
       --no-address \
       --shielded-secure-boot \
       --service-account=onprem-user-managed-sa@$projectid.iam.gserviceaccount.com \
       --metadata startup-script="#! /bin/bash
   sudo apt-get update
   sudo apt-get install tcpdump dnsutils -y"
   
   

2. Buat aturan firewall untuk mengizinkan IAP terhubung ke instance VM Anda:

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

Perbarui file /etc/hosts agar mengarah ke endpoint PSC

Di bagian ini, Anda akan menambahkan baris ke file /etc/hosts yang menyebabkan permintaan yang dikirim ke endpoint layanan publik (us-central1-aiplatform.googleapis.com) dialihkan ke endpoint PSC (192.168.0.1).

1. Di Cloud Shell, login ke instance VM on-prem-dataservice-host menggunakan IAP:

   gcloud compute ssh on-prem-dataservice-host \
     --zone=us-central1-a \
     --tunnel-through-iap
   

2. Di instance VM on-prem-dataservice-host, gunakan editor teks seperti vim atau nano untuk membuka file /etc/hosts, misalnya:

   sudo vim /etc/hosts
   

3. Tambahkan baris berikut ke file:

   192.168.0.1 us-central1-aiplatform.googleapis.com
   

   Baris ini menetapkan alamat IP endpoint PSC (192.168.0.1) 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
   
   192.168.0.1 us-central1-aiplatform.googleapis.com  # Added by you
   172.16.10.6 on-prem-dataservice-host.us-central1-a.c.PROJECT_ID.internal on-prem-dataservice-host  # Added by Google
   169.254.169.254 metadata.google.internal  # Added by Google
   

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

5. Kirim ping ke endpoint Vertex AI API sebagai berikut:

   ping us-central1-aiplatform.googleapis.com
   

   Perintah ping akan menampilkan output berikut. 192.168.0.1 adalah alamat IP endpoint PSC:

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

6. Ketik Control+C untuk keluar dari ping.

7. Ketik exit untuk keluar dari instance VM on-prem-dataservice-host dan kembali ke perintah Cloud Shell.

Mengonfigurasi jaringan untuk instance Filestore

Di bagian ini, Anda akan mengaktifkan akses layanan pribadi untuk jaringan VPC, sebagai persiapan untuk membuat instance Filestore dan memasangnya sebagai berbagi Network File System (NFS). Untuk memahami apa yang Anda lakukan di bagian ini dan bagian berikutnya, lihat Memasang berbagi NFS untuk pelatihan kustom dan Menyiapkan Peering Jaringan VPC.

Mengaktifkan akses layanan pribadi di jaringan VPC

Di bagian ini, Anda akan membuat koneksi Jaringan Layanan dan menggunakannya untuk mengaktifkan akses layanan pribadi ke jaringan VPC onprem-dataservice-vpc melalui Peering Jaringan VPC.

1. Di Cloud Shell, tetapkan rentang alamat IP yang dicadangkan menggunakan gcloud compute addresses create:

   gcloud compute addresses create filestore-subnet \
      --global \
      --purpose=VPC_PEERING \
      --addresses=10.243.208.0 \
      --prefix-length=24 \
      --description="filestore subnet" \
      --network=onprem-dataservice-vpc
   

2. Buat koneksi peering antara jaringan VPC onprem-dataservice-vpc dan Jaringan Layanan Google, menggunakan gcloud services vpc-peerings connect:

   gcloud services vpc-peerings connect \
       --service=servicenetworking.googleapis.com \
       --ranges=filestore-subnet \
       --network=onprem-dataservice-vpc
   

3. Perbarui Peering Jaringan VPC untuk mengaktifkan impor dan ekspor rute kustom yang dipelajari:

   gcloud compute networks peerings update servicenetworking-googleapis-com \
       --network=onprem-dataservice-vpc \
       --import-custom-routes \
       --export-custom-routes
   

4. Di konsol Google Cloud, buka halaman VPC network peering.

   Buka VPC network peering

5. Dalam daftar peering VPC, pastikan ada entri untuk peering antara servicenetworking.googleapis.com dan jaringan VPC onprem-dataservice-vpc.

Membuat pemberitahuan rute kustom untuk filestore-subnet

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

   Buka Cloud Router

2. Dalam daftar Cloud Router, klik onprem-dataservice-vpc-router1.

3. Di halaman detail Router, klik Edit.

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

5. Centang kotak Beriklan semua subnet yang terlihat oleh Cloud Router untuk terus mengiklankan subnet yang tersedia untuk Cloud Router. Mengaktifkan opsi ini akan meniru perilaku Cloud Router dalam mode iklan default.

6. Klik Tambahkan rute kustom.

7. Untuk Sumber, pilih Rentang IP kustom.

8. Untuk Rentang alamat IP, masukkan rentang alamat IP berikut:

   10.243.208.0/24
   

9. Untuk Deskripsi, masukkan teks berikut:

   Filestore reserved IP address range
   

10. Klik Selesai, lalu klik Simpan.

Membuat instance Filestore di jaringan onprem-dataservice-vpc

Setelah mengaktifkan akses layanan pribadi untuk jaringan VPC, Anda dapat membuat instance Filestore dan memasang instance sebagai berbagi NFS untuk tugas pelatihan kustom. Hal ini memungkinkan tugas pelatihan Anda mengakses file jarak jauh seolah-olah file tersebut bersifat lokal, sehingga memungkinkan throughput tinggi dan latensi rendah.

Membuat instance Filestore

1. Di konsol Google Cloud, buka halaman Filestore Instances.

   Buka Instance Filestore

2. Klik Create instance dan konfigurasikan instance sebagai berikut:

   • Tetapkan Instance ID ke hal berikut:

     image-data-instance
     

   • Tetapkan Instance type ke Basic.

   • Tetapkan Storage type ke HDD.

   • Tetapkan Allocate capacity ke 1 TiB.

   • Tetapkan Region ke us-central1 dan Zone ke us-central1-c.

   • Tetapkan VPC network ke onprem-dataservice-vpc.

   • Tetapkan Rentang IP yang dialokasikan ke Gunakan rentang IP yang dialokasikan yang ada, lalu pilih filestore-subnet.

   • Tetapkan File share name ke hal berikut:

     vol1
     

   • Tetapkan Access controls ke Grant access to all clients on the VPC network.

3. Klik Create.

4. Catat alamat IP untuk instance Filestore baru Anda. Anda mungkin perlu memuat ulang tab browser konsol Google Cloud untuk melihat instance baru.

Memasang berbagi file Filestore

1. Di Cloud Shell, jalankan perintah berikut, ganti PROJECT_ID dengan project ID Anda:

   projectid=PROJECT_ID
   gcloud config set project ${projectid}
   

2. Login ke instance VM on-prem-dataservice-host:

   gcloud compute ssh on-prem-dataservice-host \
       --zone=us-central1-a \
       --tunnel-through-iap
   

3. Instal paket NFS di instance VM:

   sudo apt-get update -y
   sudo apt-get -y install nfs-common
   

4. Buat direktori pemasangan untuk berbagi file Filestore:

   sudo mkdir -p /mnt/nfs
   

   Catatan: Pastikan nama folder titik pemasangan di dalam /mnt/ adalah nfs. Hal ini karena berbagi file NFS dipasang di /mnt/nfs/ di dalam tugas pelatihan kustom.

5. Pasang file share, ganti FILESTORE_INSTANCE_IP dengan alamat IP untuk instance Filestore Anda:

   sudo mount FILESTORE_INSTANCE_IP:/vol1 /mnt/nfs
   

   Jika waktu tunggu koneksi habis, periksa untuk memastikan Anda memberikan alamat IP instance Filestore yang benar.

6. Validasi bahwa pemasangan NFS berhasil dengan menjalankan perintah berikut:

   df -h
   

   Pastikan berbagi file /mnt/nfs muncul dalam hasil:

   Filesystem           Size  Used Avail Use% Mounted on
   udev                 1.8G     0  1.8G   0% /dev
   tmpfs                368M  396K  368M   1% /run
   /dev/sda1            9.7G  1.9G  7.3G  21% /
   tmpfs                1.8G     0  1.8G   0% /dev/shm
   tmpfs                5.0M     0  5.0M   0% /run/lock
   /dev/sda15           124M   11M  114M   9% /boot/efi
   tmpfs                368M     0  368M   0% /run/user
   10.243.208.2:/vol1  1007G     0  956G   0% /mnt/nfs
   

7. Buat berbagi file dapat diakses dengan mengubah izin:

   sudo chmod go+rw /mnt/nfs
   

   Catatan: Di lingkungan produksi, sebaiknya tetapkan izin yang lebih terperinci. Untuk informasi selengkapnya, lihat Mengonfigurasi akses di berbagi file.

Mendownload set data ke berbagi file

1. Di instance VM on-prem-dataservice-host, download set data ke file yang dibagikan:

   gcloud storage cp gs://cloud-samples-data/vertex-ai/dataset-management/datasets/fungi_dataset /mnt/nfs/ --recursive
   

   Download memerlukan waktu beberapa menit.

2. Pastikan set data berhasil disalin dengan menjalankan perintah berikut:

   sudo du -sh /mnt/nfs
   

   Berikut adalah output yang diinginkan:

   104M    /mnt/nfs
   

3. Ketik exit untuk keluar dari instance VM on-prem-dataservice-host dan kembali ke perintah Cloud Shell.

Membuat bucket staging untuk pipeline

Vertex AI Pipelines menyimpan artefak operasi pipeline Anda menggunakan Cloud Storage. Sebelum menjalankan pipeline, Anda harus membuat bucket Cloud Storage untuk staging operasi pipeline.

Di Cloud Shell, buat bucket Cloud Storage:

gcloud storage buckets create gs://pipelines-staging-bucket-$projectid --location=us-central1

Membuat akun layanan yang dikelola pengguna untuk Vertex AI Workbench

1. Di Cloud Shell, buat akun layanan:

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

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

3. Tetapkan peran Administrator Artifact Registry (artifactregistry.admin):

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

4. Tetapkan peran Storage Admin (storage.admin):

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

Membuat aplikasi pelatihan Python

Di bagian ini, Anda akan membuat instance Vertex AI Workbench dan menggunakannya untuk membuat paket aplikasi pelatihan kustom Python.

Membuat instance Vertex AI Workbench

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

   Buka Vertex AI Workbench

2. Klik  Buat baru, lalu klik Opsi lanjutan.

   Halaman New instance akan terbuka.

3. Di halaman New instance, di bagian Details, berikan informasi berikut untuk instance baru Anda, lalu klik Continue:

   • Nama: Masukkan kode berikut, ganti PROJECT_ID dengan project ID:

     pipeline-tutorial-PROJECT_ID
     

   • Region: Pilih us-central1.

   • Zona: Pilih us-central1-a.

   • Hapus centang pada kotak Aktifkan Sesi Interaktif Dataproc Serverless.

4. Di bagian Environment, klik Continue.

5. Di bagian Jenis mesin, berikan informasi berikut, lalu klik Lanjutkan:

   • Machine type: Pilih N1, lalu pilih n1-standard-4 dari menu Machine type.

   • Shielded VM: Pilih kotak centang berikut:

     • Secure Boot
     • Virtual Trusted Platform Module (vTPM)
     • Integrity monitoring

6. Di bagian Disk, pastikan Kunci enkripsi yang dikelola Google dipilih, lalu klik Lanjutkan:

7. Di bagian Networking, berikan hal berikut, lalu klik Lanjutkan:

   • Networking: Pilih Network dalam project ini dan selesaikan langkah-langkah berikut:

     1. Di kolom Network, pilih vertex-networking-vpc.

     2. Di kolom Subnetwork, pilih pipeline-networking-subnet1.

     3. Hapus centang pada kotak Tetapkan alamat IP eksternal. Dengan tidak menetapkan alamat IP eksternal, Anda dapat mencegah instance menerima komunikasi yang tidak diminta dari internet atau jaringan VPC lainnya.

     4. Centang kotak Izinkan akses proxy.

8. Di bagian IAM dan keamanan, berikan hal berikut, lalu klik Lanjutkan:

   • IAM dan keamanan: Untuk memberikan akses kepada satu pengguna ke antarmuka JupyterLab instance, selesaikan langkah-langkah berikut:

     1. Pilih Service account.
     2. Hapus centang pada kotak Gunakan akun layanan default Compute Engine. Langkah ini penting, karena akun layanan default Compute Engine (dan dengan demikian satu pengguna yang baru saja Anda tentukan) dapat memiliki peran Editor (roles/editor) pada project Anda.

     3. Di kolom Email akun layanan, masukkan kode berikut, dengan mengganti PROJECT_ID dengan project ID:

        workbench-sa@PROJECT_ID.iam.gserviceaccount.com
        

        (Ini adalah alamat email akun layanan khusus yang Anda buat sebelumnya.) Akun layanan ini memiliki izin terbatas.

        Untuk mempelajari lebih lanjut cara memberikan akses, lihat Mengelola akses ke antarmuka JupyterLab instance Vertex AI Workbench.

   • Opsi keamanan: Hapus centang pada kotak berikut:

     • Akses root ke instance

     Centang kotak berikut:

     • nbconvert: nbconvert memungkinkan pengguna mengekspor dan mendownload file notebook sebagai jenis file berbeda, seperti HTML, PDF, atau LaTeX. Setelan ini diperlukan oleh beberapa notebook di repositori GitHub Google Cloud Generative AI.

     Hapus centang pada kotak berikut:

     • Mendownload file

     Pilih kotak centang berikut, kecuali jika Anda berada di lingkungan produksi:

     • Akses terminal: Ini memungkinkan akses terminal ke instance Anda dari dalam antarmuka pengguna JupyterLab.

9. Di bagian System health, hapus centang pada Environment auto-upgrade dan berikan hal berikut:

   • Di Pelaporan, centang kotak berikut:

     • Melaporkan kondisi sistem
     • Melaporkan metrik kustom ke Cloud Monitoring
     • Menginstal Cloud Monitoring
     • Melaporkan status DNS untuk domain Google yang diperlukan

10. Klik Create dan tunggu beberapa menit hingga instance Vertex AI Workbench dibuat.

Menjalankan aplikasi pelatihan di instance Vertex AI Workbench

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

   Buka Vertex AI Workbench

2. Di samping nama instance Vertex AI Workbench (pipeline-tutorial-PROJECT_ID), dengan PROJECT_ID adalah project ID, klik Open JupyterLab.

   Instance Vertex AI Workbench akan terbuka di JupyterLab.

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:

   projectid=PROJECT_ID
   

5. Buat direktori induk untuk aplikasi pelatihan (masih di terminal JupyterLab):

   mkdir fungi_training_package
   mkdir fungi_training_package/trainer
   

6. Di  File Browser, klik dua kali folder fungi_training_package, lalu klik dua kali folder trainer.

7. Di  File Browser, klik kanan daftar file kosong (di bawah judul Name) dan pilih New file.

8. Klik kanan file baru, lalu pilih Ganti nama file.

9. Ganti nama file dari untitled.txt menjadi task.py.

10. Klik dua kali file task.py untuk membukanya.

11. Salin kode berikut ke task.py:

    # Import the libraries
    import tensorflow as tf
    from tensorflow.python.client import device_lib
    import argparse
    import os
    import sys
    # add parser arguments
    parser = argparse.ArgumentParser()
    parser.add_argument('--data-dir', dest='dataset_dir', type=str, 
                     help='Dir to access dataset.')
    parser.add_argument('--model-dir', dest='model_dir', default=os.getenv("AIP_MODEL_DIR"), type=str,
                     help='Dir to save the model.')
    parser.add_argument('--epochs', dest='epochs', default=10, type=int,
                     help='Number of epochs.')
    parser.add_argument('--batch-size', dest='batch_size', default=32, type=int,
                     help='Number of images per batch.')
    parser.add_argument('--distribute', dest='distribute', default='single', type=str, 
                     help='distributed training strategy.')
    args = parser.parse_args()
    # print the tf version and config
    print('Python Version = {}'.format(sys.version))
    print('TensorFlow Version = {}'.format(tf.__version__))
    print('TF_CONFIG = {}'.format(os.environ.get('TF_CONFIG', 'Not found')))
    print('DEVICES', device_lib.list_local_devices())
    
    # Single Machine, single compute device
    if args.distribute == 'single':
        if tf.test.is_gpu_available():
            strategy = tf.distribute.OneDeviceStrategy(device="/gpu:0")
        else:
            strategy = tf.distribute.OneDeviceStrategy(device="/cpu:0")
    # Single Machine, multiple compute device
    elif args.distribute == 'mirror':
        strategy = tf.distribute.MirroredStrategy()
    # Multiple Machine, multiple compute device
    elif args.distribute == 'multi':
        strategy = tf.distribute.experimental.MultiWorkerMirroredStrategy()
    
    # Multi-worker configuration
    print('num_replicas_in_sync = {}'.format(strategy.num_replicas_in_sync))
    
    # Preparing dataset
    BUFFER_SIZE = 1000
    IMG_HEIGHT = 224
    IMG_WIDTH = 224
    
    def make_datasets_batched(dataset_path, global_batch_size):
        # Configure the training data generator
        train_data_dir = os.path.join(dataset_path,"train/")
        train_ds = tf.keras.utils.image_dataset_from_directory(
                             train_data_dir,
                             seed=36,
                             image_size=(IMG_HEIGHT, IMG_WIDTH),
                             batch_size=global_batch_size
                   )
        # Configure the validation data generator
        val_data_dir = os.path.join(dataset_path,"valid/")
        val_ds = tf.keras.utils.image_dataset_from_directory(
                           val_data_dir,
                           seed=36,
                           image_size=(IMG_HEIGHT, IMG_WIDTH),
                           batch_size=global_batch_size
                 )
        # get the number of classes in the data
        num_classes = len(train_ds.class_names)
    
        # Configure the dataset for performance
        AUTOTUNE = tf.data.AUTOTUNE
        train_ds = train_ds.cache().shuffle(BUFFER_SIZE).prefetch(buffer_size=AUTOTUNE)
        val_ds = val_ds.cache().prefetch(buffer_size=AUTOTUNE)
        return train_ds, val_ds, num_classes
    
    # Build the Keras model
    def build_and_compile_cnn_model(num_classes):
        # build a CNN model
        model = tf.keras.models.Sequential([
          tf.keras.layers.Rescaling(1./255, input_shape=(IMG_HEIGHT, IMG_WIDTH, 3)),
          tf.keras.layers.Conv2D(16, 3, padding='same', activation='relu'),
          tf.keras.layers.MaxPooling2D(),
          tf.keras.layers.Conv2D(32, 3, padding='same', activation='relu'),
          tf.keras.layers.MaxPooling2D(),
          tf.keras.layers.Conv2D(64, 3, padding='same', activation='relu'),
          tf.keras.layers.MaxPooling2D(),
          tf.keras.layers.Flatten(),
          tf.keras.layers.Dense(128, activation='relu'),
          tf.keras.layers.Dense(num_classes)
        ])
        # compile the CNN model
        model.compile(optimizer='adam',
                   loss=tf.keras.losses.SparseCategoricalCrossentropy(from_logits=True),
                   metrics=['accuracy'])
        return model
    
    # Get the strategy data
    NUM_WORKERS = strategy.num_replicas_in_sync
    # Here the batch size scales up by number of workers
    GLOBAL_BATCH_SIZE = args.batch_size * NUM_WORKERS
    
    # Create dataset generator objects
    train_ds, val_ds, num_classes = make_datasets_batched(args.dataset_dir, GLOBAL_BATCH_SIZE)
    # Compile the model
    with strategy.scope():
        # Creation of dataset, and model building/compiling need to be within
        # `strategy.scope()`.
        model = build_and_compile_cnn_model(num_classes)
    # fit the model on the data
    history = model.fit(train_ds, validation_data=val_ds, epochs=args.epochs)
    # save the model to the output dir
    model.save(args.model_dir)
    

12. Pilih File > Save Python file.

13. Di terminal JupyterLab, buat file __init__.py di setiap subdirektori untuk menjadikannya sebuah paket:

    touch fungi_training_package/__init__.py
    touch fungi_training_package/trainer/__init__.py
    

14. Di  File Browser, klik dua kali folder fungi_training_package.

15. Pilih File > New > Python file.

16. Klik kanan file baru, lalu pilih Ganti nama file.

17. Ganti nama file dari untitled.py menjadi setup.py.

18. Klik dua kali file setup.py untuk membukanya.

19. Salin kode berikut ke setup.py:

    from setuptools import find_packages
    from setuptools import setup
    setup(
       name='trainer',
       version='0.1',
       packages=find_packages(),
       include_package_data=True,
       description='Training application package for fungi-classification.'
    )
    

20. Pilih File > Save Python file.

21. Di terminal, buka direktori fungi_training_package:

    cd fungi_training_package
    

22. Gunakan perintah sdist untuk membuat distribusi sumber aplikasi pelatihan:

    python setup.py sdist --formats=gztar
    

23. Buka direktori induk:

    cd ..
    

24. Pastikan Anda berada di direktori yang benar:

    pwd
    

    Outputnya akan terlihat seperti ini:

    /home/jupyter
    

25. Salin paket Python ke bucket staging:

    gcloud storage cp fungi_training_package/dist/trainer-0.1.tar.gz gs://pipelines-staging-bucket-$projectid/training_package/
    

26. Pastikan bucket staging berisi paket:

    gcloud storage ls gs://pipelines-staging-bucket-$projectid/training_package
    

    Output-nya adalah:

    gs://pipelines-staging-bucket-PROJECT_ID/training_package/trainer-0.1.tar.gz
    

Membuat koneksi Jaringan Layanan untuk Vertex AI Pipelines

Di bagian ini, Anda akan membuat koneksi Jaringan Layanan yang digunakan untuk membuat layanan produsen yang terhubung ke jaringan VPC vertex-networking-vpc melalui VPC Network Peering. Untuk mengetahui informasi selengkapnya, lihat Peering Jaringan VPC.

1. Di Cloud Shell, jalankan perintah berikut, ganti PROJECT_ID dengan project ID Anda:

   projectid=PROJECT_ID
   gcloud config set project ${projectid}
   

2. Tetapkan rentang alamat IP yang dicadangkan menggunakan gcloud compute addresses create:

   gcloud compute addresses create vertex-pipeline-subnet \
       --global \
       --purpose=VPC_PEERING \
       --addresses=192.168.10.0 \
       --prefix-length=24 \
       --description="pipeline subnet" \
       --network=vertex-networking-vpc
   

3. Buat koneksi peering antara jaringan VPC vertex-networking-vpc dan Jaringan Layanan Google, menggunakan gcloud services vpc-peerings connect:

   gcloud services vpc-peerings connect \
       --service=servicenetworking.googleapis.com \
       --ranges=vertex-pipeline-subnet \
       --network=vertex-networking-vpc
   

4. Perbarui koneksi peering VPC untuk mengaktifkan impor dan ekspor rute kustom yang dipelajari:

   gcloud compute networks peerings update servicenetworking-googleapis-com \
       --network=vertex-networking-vpc \
       --import-custom-routes \
       --export-custom-routes
   

Mengiklankan subnet pipeline dari Cloud Router pipeline-networking

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

   Buka Cloud Router

2. Dalam daftar Cloud Router, klik vertex-networking-vpc-router1.

3. Di halaman detail Router, klik Edit.

4. Klik Tambahkan rute kustom.

5. Untuk Sumber, pilih Rentang IP kustom.

6. Untuk Rentang alamat IP, masukkan rentang alamat IP berikut:

   192.168.10.0/24
   

7. Untuk Deskripsi, masukkan teks berikut:

   Vertex AI Pipelines reserved subnet
   

8. Klik Selesai, lalu klik Simpan.

Membuat template pipeline dan menguploadnya ke Artifact Registry

Di bagian ini, Anda akan membuat dan mengupload template pipeline Kubeflow Pipelines (KFP). Template ini berisi definisi alur kerja yang dapat digunakan kembali beberapa kali, oleh satu pengguna atau oleh beberapa pengguna.

Menentukan dan mengompilasi pipeline

1. Di Jupyterlab, di  File Browser, klik dua kali folder tingkat teratas.

2. Pilih File > New > Notebook.

3. Dari menu Select Kernel, pilih Python 3 (ipykernel), lalu klik Select.

4. Di sel notebook baru, jalankan perintah berikut untuk memastikan Anda memiliki pip versi terbaru:

   !python -m pip install --upgrade pip
   

5. Jalankan perintah berikut untuk menginstal Google Cloud Pipeline Components SDK dari Python Package Index (PyPI):

   !pip install --upgrade google-cloud-pipeline-components
   

6. Setelah penginstalan selesai, pilih Kernel > Restart kernel untuk memulai ulang kernel dan memastikan library tersedia untuk diimpor.

7. Jalankan kode berikut di sel notebook baru untuk menentukan pipeline:

   from kfp import dsl
   # define the train-deploy pipeline
   @dsl.pipeline(name="custom-image-classification-pipeline")
   def custom_image_classification_pipeline(
    project: str,
    training_job_display_name: str,
    worker_pool_specs: list,
    base_output_dir: str,
    model_artifact_uri: str,
    prediction_container_uri: str,
    model_display_name: str,
    endpoint_display_name: str,
    network: str = '',
    location: str="us-central1",
    serving_machine_type: str="n1-standard-4",
    serving_min_replica_count: int=1,
    serving_max_replica_count: int=1
    ):
    from google_cloud_pipeline_components.types import artifact_types
    from google_cloud_pipeline_components.v1.custom_job import CustomTrainingJobOp
    from google_cloud_pipeline_components.v1.model import ModelUploadOp
    from google_cloud_pipeline_components.v1.endpoint import (EndpointCreateOp,
                                                              ModelDeployOp)
    from kfp.dsl import importer
   
    # Train the model task
    custom_job_task = CustomTrainingJobOp(
         project=project,
         display_name=training_job_display_name,
         worker_pool_specs=worker_pool_specs,
         base_output_directory=base_output_dir,
         location=location,
         network=network
         )
   
    # Import the model task
    import_unmanaged_model_task = importer(
         artifact_uri=model_artifact_uri,
         artifact_class=artifact_types.UnmanagedContainerModel,
         metadata={
            "containerSpec": {
               "imageUri": prediction_container_uri,
               },
            },
            ).after(custom_job_task)
    # Model upload task
    model_upload_op = ModelUploadOp(
         project=project,
         display_name=model_display_name,
         unmanaged_container_model=import_unmanaged_model_task.outputs["artifact"],
         )
    model_upload_op.after(import_unmanaged_model_task)
    # Create Endpoint task
    endpoint_create_op = EndpointCreateOp(
         project=project,
         display_name=endpoint_display_name,
         )
    # Deploy the model to the endpoint
    ModelDeployOp(
         endpoint=endpoint_create_op.outputs["endpoint"],
         model=model_upload_op.outputs["model"],
         dedicated_resources_machine_type=serving_machine_type,
         dedicated_resources_min_replica_count=serving_min_replica_count,
         dedicated_resources_max_replica_count=serving_max_replica_count,
         )
   

8. Jalankan kode berikut di sel notebook baru untuk mengompilasi definisi pipeline:

   from kfp import compiler 
   PIPELINE_FILE = "pipeline_config.yaml"
   compiler.Compiler().compile(
       pipeline_func=custom_image_classification_pipeline,
       package_path=PIPELINE_FILE,
   )
   

   Di  File Browser, file bernama pipeline_config.yaml akan muncul dalam daftar file.

Membuat repositori Artifact Registry

1. Jalankan kode berikut di sel notebook baru untuk membuat repositori artefak jenis KFP:

   REPO_NAME="fungi-repo"
   REGION="us-central1"
   !gcloud artifacts repositories create $REPO_NAME --location=$REGION --repository-format=KFP
   

Mengupload template pipeline ke Artifact Registry

Di bagian ini, Anda akan mengonfigurasi klien registry Kubeflow Pipelines SDK dan mengupload template pipeline yang dikompilasi ke Artifact Registry dari notebook JupyterLab.

1. Di notebook JupyterLab, jalankan kode berikut untuk mengupload template pipeline, dengan mengganti PROJECT_ID dengan project ID Anda:

   PROJECT_ID = "PROJECT_ID"
   from kfp.registry import RegistryClient
   host = f"https://{REGION}-kfp.pkg.dev/{PROJECT_ID}/{REPO_NAME}"
   client = RegistryClient(host=host)
   TEMPLATE_NAME, VERSION_NAME = client.upload_pipeline(
      file_name=PIPELINE_FILE,
      tags=["v1", "latest"],
      extra_headers={"description":"This is an example pipeline template."})
   

2. Di konsol Google Cloud, untuk memverifikasi bahwa template Anda telah diupload, buka template Vertex AI Pipelines.

   Buka Pipeline

3. Untuk membuka panel Pilih repositori, klik Pilih repositori.

4. Di daftar repositori, klik repositori yang Anda buat (fungi-repo), lalu klik Pilih.

5. Pastikan pipeline Anda (custom-image-classification-pipeline) muncul dalam daftar.

Memicu operasi pipeline dari lokal

Di bagian ini, setelah template pipeline dan paket pelatihan siap, Anda akan menggunakan cURL untuk memicu pipeline yang dijalankan dari aplikasi lokal.

Berikan parameter pipeline

1. Di notebook JupyterLab, jalankan perintah berikut untuk memverifikasi nama template pipeline:

   print (TEMPLATE_NAME)
   

   Nama template yang ditampilkan adalah:

   custom-image-classification-pipeline
   

2. Jalankan perintah berikut untuk mendapatkan versi template pipeline:

   print (VERSION_NAME)
   

   Nama versi template pipeline yang ditampilkan akan terlihat seperti ini:

   sha256:41eea21e0d890460b6e6333c8070d7d23d314afd9c7314c165efd41cddff86c7
   

   Catat seluruh string nama versi.

3. Di Cloud Shell, jalankan perintah berikut, ganti PROJECT_ID dengan project ID Anda:

   projectid=PROJECT_ID
   gcloud config set project ${projectid}
   

4. Login ke instance VM on-prem-dataservice-host:

   gcloud compute ssh on-prem-dataservice-host \
       --zone=us-central1-a \
       --tunnel-through-iap
   

5. Di instance VM on-prem-dataservice-host, gunakan editor teks seperti vim atau nano untuk membuat file request_body.json, misalnya:

   sudo vim request_body.json
   

6. Tambahkan teks berikut ke file request_body.json:

   {
   "displayName": "fungi-image-pipeline-job",
   "serviceAccount": "onprem-user-managed-sa@PROJECT_ID.iam.gserviceaccount.com",
   "runtimeConfig":{
   "gcsOutputDirectory":"gs://pipelines-staging-bucket-PROJECT_ID/pipeline_root/",
   "parameterValues": {
      "project": "PROJECT_ID",
      "training_job_display_name": "fungi-image-training-job",
      "worker_pool_specs": [{
         "machine_spec": {
            "machine_type": "n1-standard-4"
         },
         "replica_count": 1,
         "python_package_spec":{
            "executor_image_uri":"us-docker.pkg.dev/vertex-ai/training/tf-cpu.2-8.py310:latest", 
            "package_uris": ["gs://pipelines-staging-bucket-PROJECT_ID/training_package/trainer-0.1.tar.gz"],
            "python_module": "trainer.task",
            "args": ["--data-dir","/mnt/nfs/fungi_dataset/", "--epochs", "10"],
            "env": [{"name": "AIP_MODEL_DIR", "value": "gs://pipelines-staging-bucket-PROJECT_ID/model/"}]
         },
         "nfs_mounts": [{
            "server": "FILESTORE_INSTANCE_IP",
            "path": "/vol1",
            "mount_point": "/mnt/nfs/"
         }]
      }],
      "base_output_dir":"gs://pipelines-staging-bucket-PROJECT_ID",
      "model_artifact_uri":"gs://pipelines-staging-bucket-PROJECT_ID/model/",
      "prediction_container_uri":"us-docker.pkg.dev/vertex-ai/prediction/tf2-cpu.2-8:latest",
      "model_display_name":"fungi-image-model",
      "endpoint_display_name":"fungi-image-endpoint",
      "location": "us-central1",
      "serving_machine_type":"n1-standard-4",
      "network":"projects/PROJECT_NUMBER/global/networks/vertex-networking-vpc"
        }
   },
   "templateUri": "https://us-central1-kfp.pkg.dev/PROJECT_ID/fungi-repo/custom-image-classification-pipeline/latest",
   "templateMetadata": {
      "version":"VERSION_NAME"
   }
   }
   

   Ganti nilai berikut:

   • PROJECT_ID: project ID Anda
   • PROJECT_NUMBER: nomor project. ID ini berbeda dengan ID project. Anda dapat menemukan nomor project di halaman Project Settings untuk project di konsol Google Cloud.
   • FILESTORE_INSTANCE_IP: alamat IP instance Filestore, misalnya, 10.243.208.2. Anda dapat menemukannya di halaman Instance Filestore untuk instance Anda.
   • VERSION_NAME: nama versi template pipeline (sha256:...) yang Anda catat di langkah 2.

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

Mengirimkan operasi pipeline dari template Anda

1. Di instance VM on-prem-dataservice-host, jalankan perintah berikut, dengan mengganti PROJECT_ID dengan project ID Anda:

   curl -v -X POST \
   -H "Authorization: Bearer $(gcloud auth print-access-token)" \
   -H "Content-Type: application/json; charset=utf-8" \
   -d @request_body.json \
   https://us-central1-aiplatform.googleapis.com/v1/projects/PROJECT_ID/locations/us-central1/pipelineJobs
   

   Output yang Anda lihat panjang, tetapi hal utama yang perlu Anda cari adalah baris berikut, yang menunjukkan bahwa layanan sedang bersiap untuk menjalankan pipeline:

   "state": "PIPELINE_STATE_PENDING"
   

   Seluruh operasi pipeline memerlukan waktu sekitar 45 hingga 50 menit.

2. Di konsol Google Cloud, di bagian Vertex AI, buka tab Runs di halaman Pipelines.

   Buka Run

3. Klik nama proses pipeline Anda (custom-image-classification-pipeline).

   Halaman pipeline akan muncul dan menampilkan grafik runtime pipeline. Ringkasan pipeline muncul di panel Analisis proses pipeline.

   Untuk mendapatkan bantuan dalam memahami informasi yang ditampilkan dalam grafik runtime, termasuk cara melihat log dan menggunakan Vertex ML Metadata untuk mempelajari lebih lanjut artefak pipeline Anda, lihat Memvisualisasikan dan menganalisis hasil pipeline.

Pembersihan

Agar tidak dikenai biaya pada akun Google Cloud Anda 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:

1. Hapus semua operasi pipeline sebagai berikut:

   1. Di konsol Google Cloud, di bagian Vertex AI, buka tab Runs di halaman Pipelines.

      Buka Run

   2. Pilih pipeline run yang akan dihapus, lalu klik Delete.

2. Hapus template pipeline sebagai berikut:

   1. Di bagian Vertex AI, buka tab Your templates di halaman Pipelines.

      Buka Pipeline

   2. Di samping template pipeline custom-image-classification-pipeline, klik Tindakan, lalu pilih Hapus.

3. Hapus repositori dari Artifact Registry sebagai berikut:

   1. Di halaman Artifact Registry, buka tab Repositori.

      Buka Repositori

   2. Pilih repositori fungi-repo, lalu klik Delete.

4. Batalkan deployment model dari endpoint sebagai berikut:

   1. Di bagian Vertex AI, buka tab Endpoints di halaman Online predictions.

      Buka Endpoint

   2. Klik fungi-image-endpoint untuk membuka halaman detail endpoint.

   3. Di baris untuk model Anda, fungi-image-model, klik Actions, lalu pilih Undeploy model from endpoint.

   4. Pada dialog Batalkan deployment model dari endpoint, klik Batalkan deployment.

5. Hapus endpoint sebagai berikut:

   1. Di bagian Vertex AI, buka tab Endpoints di halaman Online predictions.

      Buka Endpoint

   2. Pilih fungi-image-endpoint, lalu klik Hapus.

6. Hapus model sebagai berikut:

   1. Buka halaman Model Registry.

      Buka Model

   2. Di baris untuk model Anda, fungi-image-model, klik Tindakan, lalu pilih Hapus model.

7. Hapus bucket staging sebagai berikut:

   1. Buka halaman Cloud Storage.

      Buka Cloud Storage

   2. Pilih pipelines-staging-bucket-PROJECT_ID, dengan PROJECT_ID adalah project ID, lalu klik Delete.

8. Hapus instance Vertex AI Workbench sebagai berikut:

   1. Di bagian Vertex AI, buka tab Instances di halaman Workbench.

      Buka Vertex AI Workbench

   2. Pilih instance pipeline-tutorial-PROJECT_ID Vertex AI Workbench, dengan PROJECT_ID adalah ID project, lalu klik Delete.

9. Hapus instance VM Compute Engine sebagai berikut:

   1. Buka halaman Compute Engine.

      Buka Compute Engine

   2. Pilih instance VM on-prem-dataservice-host, lalu klik Hapus.

10. Hapus tunnel VPN sebagai berikut:

    1. Buka halaman VPN.

       Buka VPN

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

    3. Dalam daftar tunnel VPN, pilih empat tunnel VPN yang Anda buat dalam tutorial ini, lalu klik Hapus.

11. Hapus gateway VPN dengan ketersediaan tinggi (HA) sebagai berikut:

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

       Buka Gateway VPN Cloud

    2. Dalam daftar gateway VPN, klik onprem-vpn-gw1.

    3. Di halaman Detail gateway Cloud VPN, klik Hapus VPN Gateway.

    4. Klik panah kembali jika perlu untuk kembali ke daftar gateway VPN, lalu klik vertex-networking-vpn-gw1.

    5. Di halaman Detail gateway Cloud VPN, klik Hapus VPN Gateway.

12. Hapus Cloud Router sebagai berikut:

    1. Buka halaman Cloud Router.

       Buka Cloud Router

    2. Dalam daftar Cloud Router, pilih empat router yang Anda buat dalam tutorial ini.

    3. Untuk menghapus router, klik Hapus.

       Tindakan ini juga akan menghapus dua gateway Cloud NAT yang terhubung ke Cloud Router.

13. Hapus koneksi Jaringan Layanan ke jaringan VPC vertex-networking-vpc dan onprem-dataservice-vpc sebagai berikut:

    1. Buka halaman VPC Network Peering.

       Buka Peering Jaringan VPC

    2. Pilih servicenetworking-googleapis-com.

    3. Untuk menghapus koneksi, klik Hapus.

14. Hapus aturan penerusan pscvertex untuk jaringan VPC vertex-networking-vpc sebagai berikut:

    1. Buka tab Frontends di halaman Load balancing.

       Buka Frontend

    2. Dalam daftar aturan penerusan, klik pscvertex.

    3. Di halaman Detail aturan penerusan global, klik Hapus.

15. Hapus instance Filestore sebagai berikut:

    1. Buka halaman Filestore.

       Buka Filestore

    2. Pilih instance image-data-instance.

    3. Untuk menghapus instance, klik Tindakan, lalu klik Hapus instance.

16. Hapus jaringan VPC sebagai berikut:

    1. Buka halaman VPC networks.

       Buka jaringan VPC

    2. Dalam daftar jaringan VPC, klik onprem-dataservice-vpc.

    3. Di halaman VPC network details, klik Delete VPC Network.

       Menghapus setiap jaringan juga akan menghapus subjaringan, rute, dan aturan firewall-nya.

    4. Dalam daftar jaringan VPC, klik vertex-networking-vpc.

    5. Di halaman VPC network details, klik Delete VPC Network.

17. Hapus akun layanan workbench-sa dan onprem-user-managed-sa sebagai berikut:

    1. Buka halaman Akun layanan.

       Buka halaman Service accounts

    2. Pilih akun layanan onprem-user-managed-sa dan workbench-sa, lalu klik Hapus.

Langkah selanjutnya

• Pelajari cara menggunakan Vertex AI Pipelines untuk mengatur proses pembuatan dan deployment model machine learning Anda.

• Pelajari set data deFungi.