Men-deploy workload machine learning batch

Autopilot Standard

---

Tutorial ini menunjukkan cara menggunakan Google Kubernetes Engine (GKE) untuk mengelola workload batch yang fault-tolerant, sekaligus menekan biaya Anda agar tetap rendah. Ikuti tutorial ini untuk mempelajari cara menggunakan Job dan Spot Pod yang hemat biaya, serta cara mengonfigurasi antrean tugas Redis dalam cluster di GKE.

Latar belakang

Workload batch adalah proses yang biasanya dirancang untuk memiliki titik awal dan penyelesaian. Sebaiknya pertimbangkan workload batch di GKE jika arsitektur Anda melibatkan penyerapan, pemrosesan, dan output data, alih-alih menggunakan data mentah. Bidang seperti machine learning, kecerdasan buatan, dan komputasi berperforma tinggi (HPC) memiliki berbagai jenis workload batch, seperti pelatihan model offline, prediksi batch, analisis data, simulasi sistem fisik, dan pemrosesan video.

Dengan mendesain workload batch dalam container, Anda dapat memanfaatkan kelebihan GKE berikut:

• Standar terbuka, komunitas yang luas, dan layanan terkelola.
• Efisiensi biaya dari orkestrasi infrastruktur dan workload yang efektif serta resource komputasi khusus.
• Isolasi dan portabilitas containerization, yang memungkinkan penggunaan cloud sebagai kapasitas tambahan dengan tetap menjaga keamanan data.
• Ketersediaan kapasitas burst, yang diikuti dengan penurunan skala cluster GKE secara cepat.

Tujuan

Tutorial ini ditujukan untuk engineer atau data scientist machine learning yang ingin mempelajari cara menjalankan workload batch machine learning di GKE, dengan arsitektur yang hemat biaya dan skalabel berikut:

Tutorial ini membahas langkah-langkah berikut:

1. Membuat cluster GKE Autopilot. Sebagai alternatif, Anda dapat menggunakan cluster GKE Standard untuk tutorial ini.
2. Buat volume NFS Filestore.
3. Membuat antrean tugas Redis dalam cluster.
4. Mentransfer set data ke volume NFS dan memasukkannya ke dalam antrean untuk digunakan oleh workload.
5. Menjalankan contoh workload machine learning batch di cluster GKE.

Biaya

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

• Compute Engine
• GKE Autopilot
• Filestore

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

---

Jika ingin mengikuti panduan langkah demi langkah untuk tugas ini langsung di Konsol Google Cloud, klik Pandu saya:

Pandu saya

---

Sebelum memulai

1. Sign in to your Google Cloud account. If you're new to Google Cloud, create an account to evaluate how our products perform in real-world scenarios. New customers also get $300 in free credits to run, test, and deploy workloads.

2. In the Google Cloud console, on the project selector page, select or create a Google Cloud project.

   Note: If you don't plan to keep the resources that you create in this procedure, create a project instead of selecting an existing project. After you finish these steps, you can delete the project, removing all resources associated with the project.

   Go to project selector

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

4. Enable the Compute Engine, GKE, and Filestore APIs.

   Enable the APIs

5. In the Google Cloud console, on the project selector page, select or create a Google Cloud project.

   Note: If you don't plan to keep the resources that you create in this procedure, create a project instead of selecting an existing project. After you finish these steps, you can delete the project, removing all resources associated with the project.

   Go to project selector

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

7. Enable the Compute Engine, GKE, and Filestore APIs.

   Enable the APIs

8. In the Google Cloud console, activate Cloud Shell.

   Activate Cloud Shell

   At the bottom of the Google Cloud console, a Cloud Shell session starts and displays a command-line prompt. Cloud Shell is a shell environment with the Google Cloud CLI already installed and with values already set for your current project. It can take a few seconds for the session to initialize.

Menyiapkan lingkungan

1. Clone contoh repositori yang digunakan dalam tutorial ini:

   git clone https://github.com/GoogleCloudPlatform/kubernetes-engine-samples
   cd kubernetes-engine-samples/batch/aiml-workloads
   

2. Buat cluster GKE Autopilot:

   gcloud container clusters create-auto batch-aiml \
       --region=us-central1
   

   Langkah ini dapat memerlukan waktu hingga 5 menit.

Menyiapkan penyimpanan set data dengan Network File System (NFS)

Workload machine learning memerlukan solusi penyimpanan untuk file set data dan output. Di bagian ini, Anda akan membuat instance Filestore dan memberikan akses ke instance tersebut dengan menggunakan PersistentVolume dan PersistentVolumeClaim.

Untuk mempelajari lebih lanjut, lihat cara mendesain strategi penyimpanan yang optimal dan cara mengakses instance Filestore dari cluster GKE.

Membuat instance Filestore

1. Buat instance Filestore:

   gcloud filestore instances create batch-aiml-filestore \
       --zone=us-central1-b \
       --tier=BASIC_HDD \
       --file-share=name="NFSVol",capacity=1TB \
       --network=name="default"
   

   Perintah ini menentukan opsi berikut:

   • tier: Tingkat layanan untuk instance Filestore. Contoh ini menggunakan paket dasar. Untuk mempelajari opsi lainnya, lihat Tingkat layanan.

   • network=name: Nama jaringan Virtual Private Cloud (VPC) untuk instance Filestore. Cluster GKE harus berada di jaringan VPC yang sama dengan instance Filestore.

   • capacity: Ukuran volume yang diinginkan. Tentukan nilai penyimpanan di salah satu unit yang didukung yang dijelaskan dalam Jumlah resource.

   Catatan: Langkah ini dapat memerlukan waktu hingga 5 menit.

2. Pastikan instance Filestore telah di-deploy:

   gcloud filestore instances list \
       --project=PROJECT_ID \
       --zone=us-central1-b
   

   Ganti PROJECT_ID dengan project ID Google Cloud Anda.

   Output akan mirip dengan yang berikut ini:

   INSTANCE_NAME: batch-aiml-filestore
   LOCATION: us-central1-b
   TIER: BASIC_HDD
   CAPACITY_GB: 1024
   FILE_SHARE_NAME: NFSVol
   IP_ADDRESS: 203.0.113.54
   STATE: READY
   CREATE_TIME: 2022-03-15T18:23:51
   

3. Catat nilai di kolom IP_ADDRESS untuk digunakan di bagian berikut.

Membuat PersistentVolume

Spesifikasi PersistentVolume Kubernetes memungkinkan cluster GKE untuk terhubung ke instance Filestore.

1. Update file kubernetes-manifests/persistent-volume.yaml dengan alamat IP instance Filestore:

   sed -i "\
     s/<FILESTORE_IP_ADDRESS>/IP_ADDRESS/g" \
     kubernetes-manifests/persistent-volume.yaml
   

   Ganti IP_ADDRESS dengan alamat IP yang Anda catat saat membuat instance Filestore di bagian sebelumnya.

2. Deploy PersistentVolume:

   kubectl apply -f kubernetes-manifests/persistent-volume.yaml
   

Membuat PersistentVolumeClaim

PersistentVolumeClaim Kubernetes memungkinkan Job dan Pod Kubernetes mengakses resource penyimpanan PersistentVolume.

Deploy PersistentVolumeClaim:

kubectl apply -f kubernetes-manifests/persistent-volume-claim.yaml

Menggunakan PersistentVolumeClaim

Dengan menyiapkan PersistentVolume dan PersistentVolumeClaim di cluster GKE, Anda dapat mengonfigurasi server Redis dan tugas batch untuk menggunakan PersistentVolumeClaim. Ini akan muncul sebagai volume penyimpanan yang dapat dipasang.

Periksa file kubernetes-manifests/redis-pod.yaml dan kubernetes-manifests/workload.yaml. Konfigurasi manifes mirip dengan yang berikut ini:

  spec:
  …
  containers:
  - name: workload
    image: "us-central1-docker.pkg.dev/gke-batch-aiml/batch-aiml-docker-repo/workload"
    volumeMounts:
    - mountPath: /mnt/fileserver
      name: workload-pvc
  volumes:
  - name: workload-pvc
    persistentVolumeClaim:
      claimName: fileserver-claim
      readOnly: false

Dalam manifes ini:

• spec.volumes menentukan PersistentVolumeClaim yang akan digunakan.
• spec.containers.volumeMounts menentukan jalur file lokal tempat Pod dapat mengakses fileshare Filestore.

Menyiapkan antrean tugas Redis

workload memproses data dalam beberapa batch untuk melatih model deteksi penipuan secara iteratif. Untuk mengelola set data yang saat ini sedang diproses atau masih dalam antrean, Anda dapat men-deploy server Redis ke dalam cluster GKE.

Untuk tutorial ini, Anda akan memulai satu instance Redis. Untuk men-deploy Redis secara skalabel dan redundan, lihat Membuat aplikasi web multi-tingkat dengan Redis dan PHP.

1. Deploy spesifikasi server Redis.

   kubectl apply -f kubernetes-manifests/redis-pod.yaml
   

2. Verifikasi bahwa Pod sedang berjalan:

   kubectl get pods
   

   Output akan mirip dengan yang berikut ini:

   NAME           READY   STATUS    RESTARTS   AGE
   redis-leader   1/1     Running   0          118s
   

   Pod mungkin perlu waktu hingga dua menit untuk mulai berjalan.

3. Transfer file yang berisi set data pelatihan dan pengujian ke volume NFS.

   sh scripts/transfer-datasets.sh
   

   Skrip ini menyalin file dari repositori kode contoh ke direktori /mnt/fileserver/datasets/ di Pod redis-leader.

4. Isi antrean Redis.

   sh scripts/queue-jobs.sh
   

   Skrip ini mengirimkan jalur file untuk set data pelatihan ke daftar bernama datasets dalam database Redis. Antrean ini akan digunakan oleh workload untuk menemukan set data berikutnya yang akan diproses.

5. Deploy Layanan agar server Redis dapat ditemukan dalam cluster GKE.

   kubectl apply -f ./kubernetes-manifests/redis-service.yaml
   

Menjalankan workload batch

Pada titik ini, Anda telah menyiapkan cluster GKE, antrean tugas Redis, dan fileshare. Sekarang, Anda dapat menjalankan workload batch Anda.

Di bagian ini, Anda akan menggunakan image container contoh workload untuk melatih model deteksi penipuan menggunakan batch data transaksi keuangan. Proses pelatihan dapat diringkas sebagai berikut:

1. Klien Redis mengklaim tugas (jalur file ke set data) dalam antrean Redis, dan menghapusnya dari antrean jika sudah selesai.

2. Class pengelola pelatihan model, FraudDetectionModelTrainer, akan memuat batch data baru dan, secara opsional, status tersimpan dari model machine learning. Set data digunakan untuk meningkatkan model (proses yang dikenal sebagai pelatihan "warm start").

3. Status baru model serta laporan detail batch dan skor performa disimpan dalam volume NFS Filestore, yang dapat diakses di cluster GKE menggunakan PersistentVolumeClaim.

Untuk mempelajari lebih lanjut, jelajahi kode sumber.

Menentukan tugas

Manifes berikut menjelaskan Job Kubernetes untuk image workload batch.

apiVersion: batch/v1
kind: Job
metadata:
  name: workload
spec:
  parallelism: 1
  template:
    metadata:
      name: workload
    spec:
      nodeSelector:
        cloud.google.com/gke-spot: "true"
      containers:
      - name: workload
        image: "us-docker.pkg.dev/google-samples/containers/gke/batch-ml-workload"
        volumeMounts:
        - mountPath: /mnt/fileserver
          name: workload-pvc
      volumes:
      - name: workload-pvc
        persistentVolumeClaim:
          claimName: fileserver-claim
          readOnly: false
      restartPolicy: OnFailure

Catatan: Jika mengonfigurasi workload yang dapat dijalankan secara paralel (misalnya mengklasifikasikan batch gambar, analisis data yang berjalan lama, dll.), Anda dapat meningkatkan nilai parallelism agar banyak Pod dapat menjalankan tugas secara serentak hingga kondisi penyelesaian terpenuhi. Spesifikasi nodeSelector memberi tahu GKE untuk menggunakan Spot Pod.

Men-deploy workload

1. Deploy Job:

   kubectl apply -f ./kubernetes-manifests/workload.yaml
   

2. Periksa apakah status Pod workload-XXX adalah Completed:

   watch kubectl get pods
   

   Proses ini mungkin memerlukan waktu beberapa detik. Anda dapat kembali ke command line dengan menekan Ctrl+C.

   Output akan mirip dengan yang berikut ini:

   NAME             READY   STATUS      RESTARTS   AGE
   redis-leader     1/1     Running     0          16m
   workload-4p55d   0/1     Completed   0          83s
   

3. Periksa log dari Job workload:

   kubectl logs job/workload
   

   Output akan mirip dengan yang berikut ini:

   Worker with sessionID: b50f9459-ce7f-4da8-9f84-0ab5c3233a72
   Initial queue state: empty=False
   Processing dataset: datasets/training/2018-04-04.pkl
   Processing dataset: datasets/training/2018-04-03.pkl
   Processing dataset: datasets/training/2018-04-02.pkl
   Processing dataset: datasets/training/2018-04-01.pkl
   Queue empty, exiting
   

   File .pkl adalah serialisasi set data yang berisi sekumpulan transaksi kartu kredit, yang ditandai sebagai valid atau penipuan. Job workload melakukan iterasi pada file ini, mengekstrak set data dan menggunakannya untuk melatih model machine learning, sebelum menghapusnya dari antrean Redis. Workload terus memproses data dalam batch, hingga antrean Redis dikosongkan, sebelum keluar dengan sukses.

Mempelajari volume NFS

Selama operasinya, workload tersebut membuat file dalam volume NFS yang terpasang, yang dapat diakses di seluruh cluster oleh tugas batch lain atau aplikasi online.

1. Daftar file yang dibuat oleh workload:

   kubectl exec --stdin --tty redis-leader -- /bin/sh -c "ls -1 /mnt/fileserver/output"
   

   Output harus berupa yang berikut ini:

   model_cpt_2018-04-01.pkl
   model_cpt_2018-04-02.pkl
   model_cpt_2018-04-03.pkl
   model_cpt_2018-04-04.pkl
   report.txt
   

   Titik pemeriksaan untuk model terlatih (nama file seperti model_cpt_XXX.pkl) dan laporan performa model (report.txt) dibuat di direktori /mnt/fileserver/output di volume NFS.

2. Periksa laporan performa model:

   kubectl exec --stdin --tty redis-leader -- /bin/sh -c "cat /mnt/fileserver/output/report.txt"
   

   Berikut adalah cuplikan dari output:

   Report generated on: 2022-02-09 14:19:42.303619
   Training dataset: 2018-04-04.pkl
   Model checkpoint: model_cpt_2018-04-04.pkl
   ---
   Accuracy on training data: 0.9981112277019937
   Accuracy on testing data: 0.9977204434773599
   

   File berisi entri yang menampilkan detail waktu pelatihan, set data yang digunakan, akurasi yang dicapai, dan nama file checkpoint model yang terkait dengan pelatihan.

Untuk mempelajari volume NFS lebih lanjut, lihat Panduan Filestore.

Pembersihan

Agar tidak perlu membayar 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.

Menghapus setiap resource

Untuk menghapus setiap resource yang dibuat untuk tutorial ini, jalankan perintah berikut.

1. Hapus kluster:

   gcloud container clusters delete batch-aiml \
       --region=us-central1
   

2. Hapus instance Filestore:

   gcloud filestore instances delete batch-aiml-filestore \
       --zone=us-central1-b
   

Menghapus project

Perhatian: Menghapus project memiliki efek berikut:

• Semua hal dalam project akan dihapus. Jika menggunakan project yang sudah ada untuk tugas dalam dokumen ini, saat Anda menghapusnya, pekerjaan lain yang telah Anda lakukan dalam project tersebut juga akan terhapus.
• Project ID kustom hilang. Saat membuat project ini, Anda mungkin telah membuat project ID kustom yang ingin digunakan di masa mendatang. Untuk mempertahankan URL yang menggunakan project ID, seperti URL appspot.com, hapus resource yang dipilih di dalam project, bukan menghapus seluruh project.

Jika Anda berencana mempelajari beberapa arsitektur, tutorial atau panduan memulai, dengan menggunakan kembali project dapat membantu Anda agar tidak melampaui batas kuota project.

1. In the Google Cloud console, go to the Manage resources page.

   Go to Manage resources

2. In the project list, select the project that you want to delete, and then click Delete.
3. In the dialog, type the project ID, and then click Shut down to delete the project.

Langkah berikutnya

• Lihat dokumentasi GKE.

• Pelajari Volume Persisten secara lebih mendetail.

• Pelajari lebih lanjut Job di GKE.

• Pelajari cara menggunakan Spot VM untuk menjalankan workload fault-tolerant.

• Pelajari tutorial Kubernetes Engine lainnya.

• Pelajari arsitektur referensi, diagram, dan praktik terbaik tentang Google Cloud. Lihat Cloud Architecture Center kami.