Mengisolasi workload menggunakan GKE Sandbox

Autopilot Standard

Anda dapat melindungi kernel host node Google Kubernetes Engine (GKE) dari container yang menjalankan kode yang tidak tepercaya atau tidak dikenal menggunakan GKE Sandbox. Dokumen ini menunjukkan kepada spesialis Keamanan cara mengaktifkan GKE Sandbox, menjalankan Pod di sandbox, dan memverifikasi isolasi.

Anda seharusnya sudah memahami GKE Sandbox.

Jenis sandbox yang tersedia

GKE Sandbox mendukung jenis sandbox berikut, yang masing-masing menggunakan teknologi tertentu untuk memisahkan kode aplikasi dari kernel host:

• gvisor: penerapan ulang ruang pengguna dari API kernel Linux yang tidak memerlukan hak istimewa yang ditingkatkan. Kernel ruang pengguna menangkap dan melayani sebagian besar panggilan sistem atas nama kernel host, yang membatasi akses langsung ke kernel host.
• microvm: VM ringan yang di-nesting di VM host menggunakan virtualisasi bertingkat. Setiap Pod di node berjalan di VM bertingkatnya sendiri dengan kernel tamu sendiri. Karena kode berjalan di VM khusus, jenis sandbox ini memberikan isolasi yang lebih kuat daripada sandbox gVisor.

Untuk mengetahui informasi selengkapnya tentang cara kerja setiap jenis sandbox dan kapan harus menggunakan jenis tertentu, lihat Tentang GKE Sandbox.

Batasan

GKE Sandbox dan teknologi sandbox tertentu memiliki berbagai batasan, seperti dukungan GPU dan TPU atau dukungan untuk fitur Linux dan Kubernetes tertentu. Untuk mengetahui informasi selengkapnya, lihat Batasan.

Sebelum memulai

Sebelum memulai, pastikan Anda telah melakukan tugas berikut:

• Aktifkan Google Kubernetes Engine API.
Aktifkan Google Kubernetes Engine API
• Untuk menggunakan Google Cloud CLI untuk tugas ini, instal lalu lakukan inisialisasi gcloud CLI. Jika sebelumnya Anda telah menginstal gcloud CLI, dapatkan versi terbaru dengan menjalankan perintah gcloud components update. Versi gcloud CLI yang lebih lama mungkin tidak mendukung menjalankan perintah dalam dokumen ini.
  Catatan: Untuk penginstalan gcloud CLI yang ada, pastikan untuk menyetel properti compute/region. Jika Anda terutama menggunakan cluster zona, tetapkan compute/zone sebagai gantinya. Dengan menyetel lokasi default, Anda dapat menghindari error di gcloud CLI yang seperti ini: One of [--zone, --region] must be supplied: Please specify location. Anda mungkin perlu menentukan lokasi dalam perintah tertentu jika lokasi cluster Anda berbeda dengan lokasi default yang Anda tetapkan.

• Untuk mengikuti langkah-langkah di bagian Pilih jenis sandbox untuk node yang dibuat otomatis, gunakan cluster Autopilot atau Standard yang ada. Untuk menggunakan sandbox microVM, node Anda harus menjalankan GKE versi 1.37.0-gke.4713000 atau yang lebih baru.

Pilih jenis sandbox untuk node yang dibuat otomatis

Anda dapat menggunakan ComputeClasses dengan mode Autopilot atau pembuatan otomatis node pool untuk mengaktifkan GKE Sandbox di node yang dibuat GKE. Di cluster Autopilot, gVisor didukung secara default, sehingga Anda dapat memilih untuk menghilangkan konfigurasi sandbox dari ComputeClass.

Untuk mengonfigurasi GKE Sandbox untuk node yang dibuat secara otomatis, ikuti langkah-langkah berikut:

1. Hubungkan ke cluster Autopilot atau Standard yang ada:

   gcloud container clusters get-credentials CLUSTER_NAME \
       --location=CONTROL_PLANE_LOCATION
   

   Ganti kode berikut:

   • CLUSTER_NAME: nama cluster Anda.
   • CONTROL_PLANE_LOCATION: region atau zona bidang kontrol cluster Anda.

2. Simpan salah satu manifes ComputeClass berikut, bergantung pada teknologi sandbox yang Anda inginkan:

   • gVisor:

     apiVersion: cloud.google.com/v1
     kind: ComputeClass
     metadata:
       name: sandbox-gvisor-class
     spec:
       priorities:
       - machineFamily: n4
       - machineFamily: c4
       nodePoolConfig:
         sandbox:
           type: gvisor
       nodePoolAutoCreation:
         enabled: true
       whenUnsatisfiable: DoNotScaleUp
     

   • microVM:

     apiVersion: cloud.google.com/v1
     kind: ComputeClass
     metadata:
       name: sandbox-microvm-class
     spec:
       priorities:
       - machineFamily: n4
       - machineFamily: c4
       nodePoolConfig:
         sandbox:
           type: microvm
       priorityDefaults:
         enableNestedVirtualization: true
       nodePoolAutoCreation:
         enabled: true
       whenUnsatisfiable: DoNotScaleUp
     

     ComputeClass untuk sandbox microVM memungkinkan virtualisasi bertingkat dengan menggunakan kolom enableNestedVirtualization. Kolom ini wajib diisi untuk sandbox microVM. Untuk menggunakan kolom ini, cluster Anda harus menjalankan versi 1.37.0-gke.4713000 atau yang lebih baru.

   Contoh manifes ini menggunakan kolom nodePoolAutoCreation untuk mengaktifkan pembuatan otomatis node pool. Anda juga dapat menentukan konfigurasi sandbox di ComputeClass yang menggunakan kolom autopilot untuk menjalankan Pod dalam mode Autopilot. Jika Anda menggunakan cluster Autopilot, GKE akan mengabaikan kolom nodePoolAutoCreation dan autopilot.

3. Buat ComputeClass:

   kubectl apply -f PATH_TO_COMPUTE_CLASS_MANIFEST
   

   Ganti PATH_TO_COMPUTE_CLASS_MANIFEST dengan jalur ke manifes ComputeClass.

Untuk memilih ComputeClass ini dan meminta lingkungan sandbox, lihat Meminta lingkungan sandbox untuk Pod.

Memilih jenis sandbox saat Anda membuat node pool

Anda dapat mengaktifkan GKE Sandbox secara manual saat membuat node pool baru di cluster Standard. Batasan berikut berlaku saat Anda mengaktifkan GKE Sandbox secara manual:

• Untuk mengaktifkan GKE Sandbox selama pembuatan cluster Standard, Anda harus mengonfigurasi setidaknya satu node pool tambahan. Node pool tambahan diperlukan karena GKE memerlukan setidaknya satu node pool di cluster yang tidak menggunakan GKE Sandbox untuk menjalankan workload sistem yang dikelola GKE. Jika menggunakan gcloud CLI untuk membuat cluster, Anda harus membuat cluster, lalu membuat node pool yang menggunakan GKE Sandbox.
• Untuk memilih jenis sandbox microVM, Anda harus menggunakan gcloud CLI atau GKE API. Konsol Google Cloud tidak mendukung pemilihan jenis sandbox microVM.

Mengaktifkan jenis sandbox gVisor

Untuk mengaktifkan sandbox gVisor secara manual saat Anda membuat node pool baru, pilih salah satu opsi berikut:

Konsol

1. Di konsol Google Cloud , buka halaman Kubernetes clusters.

   Buka cluster Kubernetes

2. Klik nama cluster yang ingin diubah. Halaman Cluster details akan terbuka.

3. Klik tab Nodes.

4. Di bagian Node pool, klik Tambahkan node pool yang dikelola pengguna. Halaman Tambahkan node pool akan terbuka.

5. Di menu navigasi, klik Nodes dan konfigurasi setelan berikut:

   1. Di menu drop-down Image type, pilih Container-Optimized OS with Containerd (cos_containerd).
   2. Di bagian Machine configuration, pilih seri mesin dan jenis mesin untuk node.
   3. Opsional: pilih jenis GPU yang didukung atau jenis TPU yang didukung.

6. Di menu navigasi, klik Security. Halaman Node security akan terbuka.

7. Centang kotak Enable sandbox with gVisor.

8. Untuk membuat node pool, klik Buat.

gcloud

Untuk membuat node pool yang menggunakan gVisor untuk sandbox, jalankan perintah berikut:

gcloud container node-pools create NODE_POOL_NAME \
    --cluster=CLUSTER_NAME \
    --location=CONTROL_PLANE_LOCATION \
    --sandbox=type=gvisor

Ganti kode berikut:

• NODE_POOL_NAME: nama untuk node pool.
• CLUSTER_NAME: nama cluster Anda.
• CONTROL_PLANE_LOCATION: region atau zona bidang kontrol cluster Anda.

Anda juga dapat mengaktifkan sandbox gVisor saat membuat node pool yang menggunakan jenis GPU yang didukung atau jenis TPU yang didukung. Untuk informasi selengkapnya, lihat dokumen berikut:

• Men-deploy workload TPU di GKE Standard
• Men-deploy workload GPU di GKE Standard

Mengaktifkan jenis sandbox microVM

Anda dapat mengaktifkan jenis sandbox microVM saat membuat node pool menggunakan gcloud CLI atau GKE API. Konsol Google Cloud tidak mendukung pengaktifan jenis sandbox microVM. Untuk membuat node pool yang menggunakan sandbox microVM, jalankan perintah berikut:

gcloud container node-pools create NODE_POOL_NAME \
    --cluster=CLUSTER_NAME \
    --location=CONTROL_PLANE_LOCATION \
    --sandbox=type=microvm \
    --enable-nested-virtualization \
    --machine-type=MACHINE_TYPE

Ganti kode berikut:

• NODE_POOL_NAME: nama untuk node pool.
• CLUSTER_NAME: nama cluster Anda.
• CONTROL_PLANE_LOCATION: region atau zona bidang kontrol cluster Anda.
• MACHINE_TYPE: jenis mesin untuk node. Nilai ini harus berupa jenis mesin yang mendukung virtualisasi bertingkat. Untuk mengetahui informasi selengkapnya, lihat baris Virtualisasi bertingkat di tabel perbandingan seri mesin.

Mengaktifkan pemantauan dan logging

Untuk mengumpulkan dan melihat log dan metrik dari sandbox Anda, pastikan cluster Anda mengaktifkan layanan pengamatan berikut:

• Cloud Logging
• Cloud Monitoring
• Google Cloud Managed Service for Prometheus

Layanan ini diaktifkan secara default di semua cluster GKE baru.

Meminta lingkungan sandbox untuk Pod

Untuk menjalankan Pod tertentu di sandbox, Anda dapat menentukan gvisor atau microvm RuntimeClass dalam spesifikasi Pod. GKE menjadwalkan Pod pada node yang menggunakan jenis sandbox yang ditentukan. Untuk memilih jenis sandbox dalam spesifikasi Pod, ikuti langkah-langkah berikut:

1. Simpan salah satu contoh manifes Deployment berikut, bergantung pada apakah Anda mengaktifkan GKE Sandbox menggunakan ComputeClass atau node pool yang dibuat secara manual:

   • ComputeClasses:

     apiVersion: apps/v1
     kind: Deployment
     metadata:
       name: sandbox-pod
       labels:
         environment: sandbox
     spec:
       replicas: 2
       selector:
         matchLabels:
           environment: sandbox
       template:
         metadata:
           labels:
             environment: sandbox
         spec:
           nodeSelector:
             cloud.google.com/compute-class: COMPUTECLASS_NAME
           runtimeClassName: SANDBOX_TYPE
           
           containers:
           - name: nginx
             image: nginx
     

     Ganti kode berikut:

     • COMPUTECLASS_NAME: nama ComputeClass yang Anda buat, seperti yang dijelaskan dalam Memilih jenis sandbox untuk node yang dibuat otomatis.

     • SANDBOX_TYPE: jenis sandbox yang akan digunakan untuk Pod. Nilai-nilai berikut didukung:

       • gvisor
       • microvm

       Jenis sandbox yang Anda tentukan harus cocok dengan jenis sandbox yang diaktifkan oleh ComputeClass yang dipilih.

   • Node pool yang dibuat secara manual:

     apiVersion: apps/v1
     kind: Deployment
     metadata:
       name: httpd
       labels:
         app: httpd
     spec:
       replicas: 1
       selector:
         matchLabels:
           app: httpd
       template:
         metadata:
           labels:
             app: httpd
         spec:
           runtimeClassName: SANDBOX_TYPE
           containers:
           - name: httpd
             image: httpd
     

     Ganti SANDBOX_TYPE dengan jenis sandbox. Nilai berikut didukung:

     • gvisor
     • microvm

     Jenis sandbox yang Anda tentukan harus cocok dengan jenis sandbox dari node pool yang ada di cluster.

2. Membuat Deployment:

   kubectl apply -f PATH_TO_DEPLOYMENT_MANIFEST
   

   Ganti PATH_TO_DEPLOYMENT_MANIFEST dengan jalur ke manifes Deployment.

3. Pastikan Pod telah dibuat:

   kubectl get pods
   

   Outputnya mirip dengan hal berikut ini:

   NAME                    READY   STATUS    RESTARTS   AGE
   httpd-db5899bc9-dk7lk   1/1     Running   0          24s
   

Anda juga dapat meminta sandbox saat menjalankan Pod pada jenis GPU yang didukung atau jenis TPU yang didukung dengan menggunakan kolom runtimeClassName. Untuk informasi selengkapnya, lihat dokumen berikut:

• Men-deploy workload GPU di GKE Standard
• Men-deploy workload TPU di GKE Standard
• Men-deploy workload GPU di Autopilot
• Men-deploy workload TPU di Autopilot

Menjalankan Pod reguler bersama dengan Pod dengan sandbox

Langkah-langkah di bagian ini berlaku untuk workload mode Standard. Anda tidak perlu menjalankan Pod reguler bersama Pod sandbox dalam mode Autopilot, karena model harga Autopilot tidak perlu mengoptimalkan jumlah Pod yang dijadwalkan secara manual pada node.

Setelah mengaktifkan GKE Sandbox pada node pool, Anda dapat menjalankan aplikasi tepercaya pada node tersebut tanpa menggunakan sandbox menggunakan taint dan toleransi node. Pod ini disebut sebagai "Pod reguler" untuk membedakannya dari Pod dengan sandbox.

Pod reguler, seperti Pod dengan sandbox, dicegah mengakses layanan atau metadata clusterGoogle Cloud lainnya. Pencegahan ini adalah bagian dari konfigurasi node. Jika Pod reguler atau Pod dengan sandbox memerlukan akses ke layananGoogle Cloud , gunakan Workload Identity Federation for GKE.

Peringatan: Menjalankan kode tidak tepercaya di node yang sama dengan layanan sistem penting memiliki potensi risiko, meskipun kode tidak tepercaya dijalankan di sandbox. Pertimbangkan risiko ini saat mendesain aplikasi Anda.

GKE Sandbox menambahkan label dan taint berikut ke node yang dapat menjalankan Pod dengan sandbox:

• Label node sandbox.gke.io/runtime: SANDBOX_TYPE.
• Taint node sandbox.gke.io/runtime=SANDBOX_TYPE:NoSchedule. Hanya Pod yang memiliki toleransi yang cocok yang dapat dijadwalkan di node.

Jika Anda menggunakan kolom RuntimeClass untuk menjalankan Pod di sandbox, GKE akan otomatis menerapkan afinitas node dan toleransi ke Pod. Untuk menjalankan Pod reguler di node yang menggunakan GKE Sandbox, Anda harus menerapkan pemilih berikut secara manual ke spesifikasi Pod:

• Agar Pod Anda dapat berjalan di node yang menggunakan GKE Sandbox saat diperlukan, tambahkan hanya toleransi untuk taint node.
• Untuk menjalankan Pod hanya pada node yang menggunakan GKE Sandbox, tambahkan pemilih node dan toleransi untuk taint node.

Langkah-langkah berikut menunjukkan cara menjalankan Pod reguler di node yang menggunakan GKE Sandbox:

1. Simpan manifes Deployment berikut sebagai httpd-regular.yaml:

   apiVersion: apps/v1
   kind: Deployment
   metadata:
     name: httpd-regular
     labels:
       app: httpd-regular
   spec:
     replicas: 1
     selector:
       matchLabels:
         app: httpd-regular
     template:
       metadata:
         labels:
           app: httpd-regular
       spec:
         containers:
         - name: httpd-regular
           image: httpd
         affinity:
           nodeAffinity:
             requiredDuringSchedulingIgnoredDuringExecution:
               nodeSelectorTerms:
               - matchExpressions:
                 - key: sandbox.gke.io/runtime
                   operator: In
                   values:
                   - SANDBOX_TYPE
         tolerations:
           - effect: NoSchedule
             key: sandbox.gke.io/runtime
             operator: Equal
             value: SANDBOX_TYPE
   

   Ganti SANDBOX_TYPE dengan jenis sandbox, seperti gvisor atau microvm.

2. Membuat Deployment:

   kubectl apply -f httpd-regular.yaml
   

   Jika Pod tidak dapat dijadwalkan, pastikan afinitas node dan toleransi disetel dengan benar di manifes Pod.

3. Pastikan Pod tidak berada di sandbox:

   kubectl get pods -o jsonpath=$'{range .items[*]}{.metadata.name}: {.spec.runtimeClassName}\n{end}'
   

   Outputnya mirip dengan hal berikut ini:

   httpd-db5899bc9-dk7lk: SANDBOX_TYPE
   httpd-regular-5bf87996c6-cfmmd:
   

   Pod httpd-regular tidak memiliki nilai RuntimeClass, yang berarti Pod tersebut tidak berada di sandbox.

4. Pastikan Pod reguler berjalan di node yang menggunakan GKE Sandbox:

   kubectl get pod -o jsonpath=$'{range .items[*]}{.metadata.name}: {.spec.nodeName}\n{end}'
   

   Outputnya mirip dengan hal berikut ini:

   httpd-db5899bc9-dk7lk: gke-cluster-2-pool-1-75c8fc63-h373
   httpd-regular-5bf87996c6-cfmmd: gke-cluster-2-pool-1-75c8fc63-h373
   

   Pod dengan sandbox dan Pod reguler berada di node yang sama, yang menunjukkan bahwa Pod reguler berjalan di node yang menggunakan GKE Sandbox.

Memverifikasi konfigurasi sandbox

Bagian berikut menunjukkan cara memverifikasi bahwa Pod berjalan di sandbox dan bahwa Pod dengan sandbox diisolasi dari kernel host. Bagian ini mengasumsikan bahwa Anda telah membuat contoh Deployment di Meminta lingkungan sandbox untuk Pod.

Memverifikasi bahwa Pod berjalan di sandbox

Untuk memeriksa apakah Pod Anda menggunakan sandbox, dapatkan RuntimeClass Pod. Metode ini lebih dapat dipercaya daripada menjalankan perintah di dalam Pod, karena Anda tidak akan melihat data dari dalam sandbox itu sendiri. Apa pun yang dilaporkan dari dalam sandbox tidak dapat dipercaya, karena dapat rusak atau berbahaya.

• Dapatkan RuntimeClass setiap Pod yang berjalan:

  kubectl get pods -l=app=httpd -o jsonpath=$'{range .items[*]}{.metadata.name}: {.spec.runtimeClassName}\n{end}'
  

  Outputnya mirip dengan hal berikut ini:

  httpd-db5899bc9-dk7lk: gvisor
  httpd-db5899bc9-ab3cd: gvisor
  

  Jika output menampilkan gvisor atau microvm, berarti Pod berjalan di sandbox.

Memverifikasi isolasi Pod yang di-sandbox dari host

Anda dapat memverifikasi apakah Pod yang di-sandbox diisolasi dari node host dengan memeriksa perangkat virtual yang tersedia dan versi kernel yang dapat diakses Pod.

1. Untuk sandbox gVisor dan microVM, periksa apakah versi kernel yang dapat diakses Pod berbeda dengan versi kernel node host:

   1. Dapatkan versi kernel yang dapat diakses Pod:

      kubectl exec POD_NAME -- uname -r
      

      Ganti POD_NAME dengan nama Pod.

      Outputnya mirip dengan hal berikut ini:

      4.19.0-gvisor
      

   2. Dapatkan versi kernel di node host:

      kubectl get node NODE_NAME \
          -o jsonpath='{.status.nodeInfo.kernelVersion}'
      

      Ganti NODE_NAME dengan nama node yang menjalankan Pod.

      Outputnya mirip dengan hal berikut ini:

      6.12.94+
      

   Versi kernel node host berbeda dengan versi kernel yang dapat diakses Pod yang di-sandbox, karena Pod hanya melihat kernel ruang pengguna untuk gVisor atau kernel tamu untuk microVM.

2. Untuk sandbox microVM, Anda juga dapat memeriksa apakah perangkat yang dapat diakses Pod divirtualisasi oleh Cloud Hypervisor:

   kubectl exec POD_NAME -- cat /sys/class/dmi/id/product_name
   

   Jika output-nya adalah cloud-hypervisor, berarti Pod berada di sandbox microVM.

Menonaktifkan GKE Sandbox

Anda tidak dapat menonaktifkan GKE Sandbox di cluster GKE Autopilot atau di node pool GKE Standard. Jika Anda ingin berhenti menggunakan GKE Sandbox, hapus node pool.

Langkah berikutnya

• Pelajari mengelola node pool lebih lanjut.
• Baca ringkasan keamanan.