Mengoptimalkan penggunaan resource di cluster GKE multi-tenant menggunakan penyediaan otomatis node

Tutorial ini menunjukkan cara menggunakan penyediaan otomatis node untuk menskalakan cluster Google Kubernetes Engine (GKE) multi-tenant, dan cara menggunakan Workload Identity untuk mengontrol akses tenant ke resource seperti bucket Cloud Storage. Panduan ini ditujukan untuk developer dan arsitek dan mengasumsikan pengetahuan dasar tentang Kubernetes dan GKE. Jika Anda memerlukan pengantar, lihat ringkasan GKE.

Multi-tenancy cluster sering diterapkan untuk mengurangi biaya atau menstandarkan operasi di seluruh tenant. Untuk sepenuhnya mewujudkan penghematan biaya, Anda harus menyesuaikan ukuran cluster Anda agar resource cluster digunakan secara efisien. Anda juga harus meminimalkan pemborosan resource saat cluster Anda diskalakan otomatis dengan memastikan node cluster yang ditambahkan memiliki ukuran yang sesuai.

Dalam tutorial ini, Anda menggunakan penyediaan otomatis node untuk menskalakan cluster. Penyediaan otomatis node dapat membantu mengoptimalkan penggunaan resource cluster sehingga mengontrol biaya dengan menambahkan node cluster yang paling sesuai dengan workload Anda yang tertunda.

Tujuan

Buat cluster GKE yang telah mengaktifkan penyediaan otomatis node dan Workload Identity.
Siapkan cluster untuk multi-tenancy.
Kirimkan tugas ke cluster untuk menunjukkan cara penyediaan otomatis node membuat dan menghancurkan node dengan ukuran yang dioptimalkan.
Gunakan taint dan label untuk menginstruksikan penyediaan otomatis node agar membuat node pool khusus untuk setiap tenant.
Gunakan Workload Identity untuk mengontrol akses ke resource tenant khusus seperti bucket Cloud Storage.

Biaya

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

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

Sebelum memulai

Login ke akun Google Cloud Anda. Jika Anda baru menggunakan Google Cloud, buat akun untuk mengevaluasi performa produk kami dalam skenario dunia nyata. Pelanggan baru juga mendapatkan kredit gratis senilai $300 untuk menjalankan, menguji, dan men-deploy workload.

Di konsol Google Cloud, pada halaman pemilih project, pilih atau buat project Google Cloud.

Buka pemilih project

Pastikan penagihan telah diaktifkan untuk project Google Cloud Anda.

Di konsol Google Cloud, pada halaman pemilih project, pilih atau buat project Google Cloud.

Buka pemilih project

Pastikan penagihan telah diaktifkan untuk project Google Cloud Anda.

Di konsol Google Cloud, aktifkan Cloud Shell.

Aktifkan Cloud Shell

Di bagian bawah Google Cloud Console, Cloud Shell sesi akan terbuka dan menampilkan perintah command line. Cloud Shell adalah lingkungan shell dengan Google Cloud CLI yang sudah terinstal, dan dengan nilai yang sudah ditetapkan untuk project Anda saat ini. Diperlukan waktu beberapa detik untuk melakukan inisialisasi sesi.
Aktifkan API untuk GKE dan Cloud Build API di Cloud Shell:
```
gcloud services enable container.googleapis.com \
    cloudbuild.googleapis.com
```
Operasi ini dapat memerlukan waktu hingga beberapa menit untuk selesai.

Mempersiapkan lingkungan

Di bagian ini, Anda akan mendapatkan kode yang diperlukan untuk tutorial ini dan menyiapkan lingkungan dengan nilai yang Anda gunakan selama tutorial.

Di Cloud Shell, tentukan variabel lingkungan yang Anda gunakan untuk tutorial ini:
```
export PROJECT_ID=$(gcloud config get-value project)
```

Buat clone repositori GitHub yang berisi kode untuk tutorial ini:

git clone https://github.com/GoogleCloudPlatform/solutions-gke-autoprovisioning

Ubah ke direktori repositori:
```
cd solutions-gke-autoprovisioning
```
Update file konfigurasi tugas YAML Kubernetes dengan project ID Google Anda:
```
sed -i "s/MY_PROJECT/$PROJECT_ID/" manifests/bases/job/base-job.yaml
```
Kirim tugas Cloud Build untuk membangun image container:
```
gcloud builds submit pi/ --tag gcr.io/$PROJECT_ID/generate-pi
```
Gambar ini adalah program Go yang menghasilkan perkiraan pi. Anda akan menggunakan image container ini nantinya.

Cloud Build mengekspor image ke Container Registry project Anda.

Membuat cluster GKE

Di bagian ini, Anda membuat cluster GKE yang mengaktifkan penyediaan otomatis node dan identitas workload. Perhatikan detail proses pembuatan cluster berikut:

Anda dapat menentukan batas CPU dan memori untuk cluster. Penyediaan otomatis node mematuhi batasan ini saat menambahkan atau menghapus node dari cluster. Untuk informasi selengkapnya, lihat Mengaktifkan penyediaan otomatis node di dokumentasi GKE.
Anda menentukan cakupan dan akun layanan default yang digunakan oleh node dalam node pool yang disediakan secara otomatis. Menggunakan setelan ini, Anda dapat mengontrol izin akses node yang disediakan. Untuk informasi selengkapnya, lihat Menetapkan default identitas untuk node yang disediakan secara otomatis dalam dokumentasi GKE.
Anda menetapkan profil penskalaan otomatis yang memprioritaskan pemakaian. Profil ini memberi tahu autoscaler cluster untuk menurunkan skala cluster dengan cepat guna meminimalkan resource yang tidak digunakan. Hal ini dapat membantu efisiensi resource untuk workload batch atau yang berpusat pada tugas. Setelan ini berlaku untuk semua node pool dalam cluster.
Anda mengaktifkan Workload Identity dengan menentukan kumpulan workload.

Untuk membuat cluster:

Buat akun layanan:
```
gcloud iam service-accounts create nap-sa
```
Akun layanan ini digunakan oleh node yang disediakan secara otomatis.

Izinkan akun layanan baru untuk mengambil image dari bucket Cloud Storage yang digunakan oleh Container Registry:

gsutil iam ch \
    serviceAccount:nap-sa@$PROJECT_ID.iam.gserviceaccount.com:objectViewer \
    gs://artifacts.$PROJECT_ID.appspot.com

Buat cluster GKE yang telah mengaktifkan penyediaan otomatis node dan workload identity:

gcloud container clusters create multitenant \
    --release-channel=regular \
    --zone=us-central1-c \
    --num-nodes=2 \
    --machine-type=n1-standard-2 \
    --workload-pool=${PROJECT_ID}.svc.id.goog \
    --autoscaling-profile=optimize-utilization \
    --enable-autoprovisioning \
    --autoprovisioning-service-account=nap-sa@${PROJECT_ID}.iam.gserviceaccount.com \
    --autoprovisioning-scopes=\
https://www.googleapis.com/auth/devstorage.read_write,\
https://www.googleapis.com/auth/cloud-platform \
    --min-cpu 1 \
    --min-memory 1 \
    --max-cpu 50 \
    --max-memory 256 \
    --enable-network-policy \
    --enable-ip-alias

Tetapkan nama cluster default dan zona komputasi:

gcloud config set container/cluster multitenant
gcloud config set compute/zone us-central1-c

Menyiapkan cluster untuk multi-tenancy

Saat mengoperasikan aplikasi software-as-a-service (SaaS) multi-tenant, biasanya Anda harus memisahkan tenant. Memisahkan tenant dapat membantu meminimalkan setiap kerusakan dari tenant yang disusupi. Hal ini juga dapat membantu Anda mengalokasikan resource cluster secara merata ke seluruh tenant, dan melacak berapa resource yang digunakan setiap tenant. Walaupun tidak dapat menjamin isolasi yang sepenuhnya aman di antara tenant, Kubernetes menawarkan fitur yang mungkin memadai untuk kasus penggunaan tertentu. Untuk informasi selengkapnya tentang fitur multi-tenancy GKE, lihat ringkasan dan panduan praktik terbaik dalam dokumentasi GKE.

Di aplikasi contoh, Anda membuat dua tenant, tenant1 dan tenant2. Anda memisahkan setiap tenant dan resource Kubernetes ke masing-masing namespace. Buat kebijakan jaringan sederhana yang menerapkan isolasi tenant dengan mencegah komunikasi dari namespace lain. Kemudian, Anda akan menggunakan kolom taint node dan nodeSelector untuk mencegah Pod dari tenant yang berbeda dijadwalkan pada node yang sama. Anda dapat menyediakan tingkat pemisahan tambahan dengan menjalankan workload tenant di node khusus.

Anda menggunakan Kustomize untuk mengelola manifes Kubernetes yang dikirim ke cluster. Dengan Kustomize, Anda dapat menggabungkan dan menyesuaikan file YAML untuk berbagai tujuan.

Buat resource namespace, akun layanan, dan kebijakan jaringan untuk tenant1:

kubectl apply -k manifests/setup/tenant1

Outputnya akan terlihat seperti berikut:

namespace/tenant1-ns created
serviceaccount/tenant1-ksa created
networkpolicy.networking.k8s.io/tenant1-deny-from-other-namespaces created

Buat resource cluster untuk tenant2:

kubectl apply -k manifests/setup/tenant2

Memverifikasi perilaku penyediaan otomatis node

Cluster GKE terdiri dari satu node pool atau lebih. Semua node dalam sebuah node pool memiliki jenis mesin yang sama, yang berarti mereka memiliki jumlah CPU dan memori yang sama. Jika permintaan resource workload bervariasi, Anda dapat memanfaatkan beberapa node pool yang memiliki jenis mesin berbeda dalam cluster. Dengan cara ini, autoscaler cluster dapat menambahkan node dari jenis yang paling sesuai untuk meningkatkan efisiensi resource Anda dan mengurangi biaya. Namun, mengelola banyak node pool akan menyebabkan overhead pengelolaan. Mengelola banyak node pool juga mungkin tidak praktis dalam cluster multi-tenant jika Anda ingin mengeksekusi workload tenant di node pool khusus.

Sebagai gantinya, Anda dapat menggunakan penyediaan otomatis node untuk memperluas autoscaler cluster. Saat penyediaan otomatis node diaktifkan, autoscaler cluster dapat membuat node pool baru secara otomatis berdasarkan spesifikasi Pod yang tertunda. Hasilnya, autoscaler cluster dapat membuat node dari jenis yang paling sesuai, tetapi Anda tidak perlu membuat atau mengelola node pool sendiri. Menggunakan, penyediaan otomatis node, cluster Anda dapat melakukan penskalaan otomatis secara efisien tanpa penyediaan yang berlebihan, sehingga dapat membantu menurunkan biaya.

Selain itu, jika Pod yang tertunda memiliki batasan pemisahan workload, penyediaan otomatis node dapat membuat node yang memenuhi batasan tersebut. Dengan cara ini, Anda dapat menggunakan penyediaan otomatis node untuk membuat node pool secara otomatis yang hanya akan digunakan oleh satu tenant.

Di bagian ini, Anda akan mengirimkan berbagai tugas ke cluster untuk memverifikasi perilaku penyediaan otomatis node. Tugas tersebut menggunakan image generate-pi yang Anda buat sebelumnya.

Mengirimkan tugas sederhana

Pertama, Anda mengirimkan tugas sederhana ke cluster. Tugas ini tidak menentukan batasan khusus per tenant. Cluster memiliki kapasitas cadangan yang cukup untuk menangani permintaan CPU dan memori tugas. Oleh karena itu, tugas tersebut akan dijadwalkan ke salah satu node yang ada di node pool default. Tidak ada node tambahan yang disediakan.

Cantumkan node pool dalam cluster:
```
gcloud container node-pools list
```
Anda akan melihat satu kumpulan default.
Cetak konfigurasi tugas ke konsol:
```
kubectl kustomize manifests/jobs/simple-job/
```
Outputnya akan terlihat seperti berikut:
```
apiVersion: batch/v1
kind: Job
metadata:
name: pi-job
spec:
...
```
Konfigurasi ini tidak menentukan taint atau pemilih node.

Kirim tugas:

kubectl apply -k manifests/jobs/simple-job/

Lihat node pool di cluster:
```
watch -n 5 gcloud container node-pools list
```
Anda masih akan melihat satu kumpulan default. Tidak ada node pool baru yang dibuat.
Setelah sekitar 30 detik, tekan Control+C untuk berhenti melihat node pool.
Lihat node di cluster:
```
kubectl get nodes -w
```
Anda tidak akan melihat ada node baru yang dibuat.
Setelah 1 menit, tekan Control+C untuk berhenti melihat.
Cantumkan tugas di cluster:
```
kubectl get jobs --all-namespaces
```
Outputnya akan terlihat seperti berikut:
```
NAMESPACE   NAME     COMPLETIONS   DURATION   AGE
default     pi-job   1/1           14s        21m
```
Nilai 1/1 di kolom Completions menunjukkan 1 dari total 1 tugas telah selesai.

Mengirimkan tugas yang memiliki batasan khusus tenant

Di bagian ini, Anda mengirimkan tugas lain untuk mengonfirmasi bahwa penyediaan otomatis node mematuhi batasan pemisahan workload. Konfigurasi tugas mencakup pemilih node dan toleransi khusus tenant. Tugas hanya dapat dijadwalkan ke node yang memiliki label yang cocok dengan pasangan nilai kunci pemilih. Toleransi berfungsi bersama dengan taint node yang juga membatasi tugas mana yang dapat dijadwalkan ke sebuah node. Praktik terbaik dengan penyediaan otomatis node adalah dengan menyertakan pemilih node dan toleransi untuk pemisahan workload.

Tugas ini tidak dapat dijadwalkan ke dalam node pool default karena kumpulan tersebut tidak memiliki node yang memenuhi batasan pemilih. Oleh karena itu, penyediaan otomatis node akan membuat node pool baru dengan label node yang memenuhi persyaratan pemilih. Penyediaan otomatis node juga menambahkan taint khusus tenant ke node yang sesuai dengan toleransi dalam konfigurasi tugas. Hanya Pod yang memiliki toleransi yang cocok yang dapat dijadwalkan ke node dalam kumpulan, sehingga Anda dapat memisahkan workload tenant lebih lanjut.

Cantumkan node pool dalam cluster:
```
gcloud container node-pools list
```
Anda akan melihat satu kumpulan default.
Cetak konfigurasi tugas ke konsol:
```
kubectl kustomize manifests/jobs/one-tenant/
```
Konfigurasi ini mencakup persyaratan pemilih node khusus tenant dan toleransi. Outputnya akan terlihat seperti berikut:
```
apiVersion: batch/v1
kind: Job
metadata:
name: tenant1-pi-job
spec:
...
```

Kirim tugas:

kubectl apply -k manifests/jobs/one-tenant/

Lihat node pool di cluster:
```
watch -n 5 gcloud container node-pools list
```
Setelah beberapa saat, Anda akan melihat node pool baru. Outputnya akan terlihat seperti berikut:
```
NAME                            MACHINE_TYPE       DISK_SIZE_GB
default-pool                    n1-standard-2      100
nap-n1-standard-1-15jwludl      n1-standard-1      100
```
Nama node pool diawali dengan nap-, yang menunjukkan bahwa node pool tersebut dibuat oleh penyediaan otomatis node. Nama node pool juga mencakup jenis mesin node dalam kumpulan, misalnya, n1-standard-1.
Lihat node di cluster:
```
kubectl get nodes -w
```
Setelah sekitar satu menit, Anda akan melihat node baru muncul dalam daftar. Nama node menyertakan nama node pool nap-. Node baru awalnya memiliki status Not Ready. Setelah beberapa saat, status node baru berubah menjadi Ready, yang berarti node kini dapat menerima tugas yang tertunda.
Untuk berhenti melihat node, tekan Control+C.
Cantumkan taint node:
```
kubectl get nodes -o custom-columns=NAME:.metadata.name,TAINTS:.spec.taints
```
Anda melihat bahwa node baru memiliki taint NoSchedule untuk pasangan nilai kunci tenant: tenant1. Oleh karena itu, hanya Pod yang memiliki toleransi terkait untuk tenant: tenant1 yang dapat dijadwalkan ke node.
Lihat tugas di cluster:
```
kubectl get jobs -w --all-namespaces
```
Setelah beberapa waktu, Anda melihat bahwa tenant1-pi-job memiliki penyelesaian 1/1, yang menunjukkan bahwa proses tersebut berhasil diselesaikan.
Untuk berhenti melihat tugas, tekan Control+C.
Lihat node pool di cluster:
```
watch -n 5 gcloud container node-pools list
```
Setelah beberapa saat, Anda melihat bahwa kumpulan nap- dihapus, dan cluster sekali lagi hanya memiliki satu node pool default. Penyediaan otomatis node telah menghapus node pool nap-, karena sudah tidak ada tugas tertunda yang sesuai dengan batasan kumpulan.
Untuk berhenti melihat node pool, tekan Control+C.

Mengirimkan dua tugas yang lebih besar yang memiliki batasan tenant

Di bagian ini, Anda mengirimkan dua tugas yang memiliki batasan khusus tenant, dan juga meningkatkan permintaan resource untuk setiap tugas. Sekali lagi, tugas ini tidak dapat dijadwalkan ke node pool default karena batasan pemilih node. Penyediaan otomatis node akan membuat dua node pool baru karena setiap tugas memiliki batasan pemilihnya sendiri. Dengan cara ini, Anda dapat menggunakan penyediaan otomatis node untuk memisahkan tugas tenant. Karena tugas ini memiliki jumlah permintaan resource yang lebih tinggi, penyediaan otomatis node akan membuat node pool yang memiliki jenis mesin yang lebih besar daripada sebelumnya.

Cantumkan node pool dalam cluster:
```
gcloud container node-pools list
```
Anda akan melihat satu kumpulan default.
Cetak konfigurasi gabungan:
```
kubectl kustomize manifests/jobs/two-tenants/
```
Konfigurasi ini mencakup dua tugas terpisah, masing-masing dengan pemilih dan toleransi node khusus tenant, serta dengan peningkatan permintaan resource.

Outputnya akan terlihat seperti berikut:
```
apiVersion: batch/v1
kind: Job
metadata:
name: tenant1-larger-pi-job
spec:
...
```

Kirim tugas:

kubectl apply -k manifests/jobs/two-tenants/

Lihat node pool di cluster:
```
watch -n 5 gcloud container node-pools list
```
Setelah beberapa saat, Anda akan melihat dua node pool tambahan. Outputnya akan terlihat seperti berikut:
```
NAME                            MACHINE_TYPE       DISK_SIZE_GB
default-pool                    n1-standard-2      100
nap-n1-standard-2-6jxjqobt      n1-standard-2      100
nap-n1-standard-2-z3s06luj      n1-standard-2      100
```
Nama node pool diawali dengan nap-, yang menunjukkan bahwa node pool tersebut dibuat oleh penyediaan otomatis node. Nama node pool juga mencakup jenis mesin node dalam kumpulan, misalnya, n1-standard-2.
Untuk berhenti melihat node, tekan Control+C.
Lihat node di cluster:
```
kubectl get nodes -w
```
Setelah sekitar satu menit, Anda akan melihat dua node baru muncul dalam daftar. Nama node awalnya menyertakan nama node pool nap- terkait. Node baru awalnya memiliki status Not Ready. Setelah beberapa saat, status node baru berubah menjadi Ready, yang berarti bahwa node kini dapat menerima tugas yang tertunda.
Untuk berhenti melihat node, tekan Control+C.
Cantumkan taint node:
```
kubectl get nodes -o custom-columns=NAME:.metadata.name,TAINTS:.spec.taints
```
Anda melihat bahwa node baru memiliki taint NoSchedule, masing-masing dengan pasangan nilai kunci tenant: tenant1 dan tenant: tenant2. Hanya Pod yang memiliki toleransi tenant yang sesuai yang dapat dijadwalkan ke node.
Lihat tugas di cluster:
```
kubectl get jobs -w --all-namespaces
```
Setelah beberapa saat, Anda melihat bahwa tenant1-larger-pi-job dan tenant2-larger-pi-job berubah sehingga masing-masing memiliki 1/1 penyelesaian, yang menunjukkan bahwa tugas berhasil diselesaikan.
Untuk berhenti melihat tugas, tekan Control+C.
Lihat node pool di cluster:
```
watch -n 5 gcloud container node-pools list
```
Setelah beberapa saat, Anda akan melihat kedua kumpulan nap- dihapus, dan cluster sekali lagi hanya memiliki satu node pool default. Penyediaan otomatis node telah menghapus node pool nap-, karena sudah tidak ada tugas tertunda yang sesuai dengan batasan kumpulan.
Untuk berhenti melihat node pool, tekan Control+C.

Mengontrol akses ke resource Google Cloud

Selain mempertahankan pemisahan tenant dalam cluster, biasanya Anda ingin mengontrol akses tenant ke resource Google Cloud seperti bucket Cloud Storage atau topik Pub/Sub. Misalnya, setiap tenant mungkin membutuhkan bucket Cloud Storage yang tidak bisa diakses oleh tenant lain.

Dengan menggunakan Workload Identity, Anda dapat membuat pemetaan antara akun layanan Kubernetes dan akun layanan Google Cloud. Kemudian, Anda dapat menetapkan peran Identity and Access Management (IAM) yang sesuai untuk akun layanan Google Cloud. Dengan cara ini, Anda dapat menerapkan prinsip hak istimewa terendah sehingga tugas tenant dapat mengakses resource yang ditetapkan, tetapi tugas tersebut tidak dapat mengakses resource yang dimiliki oleh tenant lain.

Menyiapkan identitas workload GKE

Konfigurasi pemetaan antara akun layanan Kubernetes dan akun layanan Google Cloud yang Anda buat.

Buat akun layanan Google Cloud untuk tenant1:

gcloud iam service-accounts create tenant1-gsa

Izinkan akun layanan Kubernetes untuk IAM tenant1 agar dapat menggunakan akun layanan Google Cloud untuk tenant1 yang sesuai:

gcloud iam service-accounts add-iam-policy-binding \
    tenant1-gsa@${PROJECT_ID}.iam.gserviceaccount.com \
    --role roles/iam.workloadIdentityUser \
    --member "serviceAccount:${PROJECT_ID}.svc.id.goog[tenant1-ns/tenant1-ksa]"

Selesaikan pemetaan antar akun layanan dengan memberikan anotasi pada akun layanan Kubernetes dengan akun layanan Google Cloud:

kubectl annotate serviceaccount tenant1-ksa -n tenant1-ns \
    iam.gke.io/gcp-service-account=tenant1-gsa@${PROJECT_ID}.iam.gserviceaccount.com

Mengirimkan tugas penulisan ke bucket Cloud Storage

Di bagian ini, Anda mengonfirmasi bahwa tugas yang dieksekusi sebagai akun layanan Kubernetes tertentu dapat menggunakan izin IAM dari akun layanan Google Cloud yang telah dipetakan.

Buat bucket Cloud Storage baru untuk tenant1:
```
export BUCKET=tenant1-$PROJECT_ID
gsutil mb -b on -l us-central1 gs://$BUCKET
```
Anda menggunakan project ID sebagai akhiran pada nama bucket agar nama tersebut unik.

Update file konfigurasi tugas untuk menggunakan bucket Cloud Storage:

sed -i "s/MY_BUCKET/$BUCKET/" \
    manifests/jobs/write-gcs/bucket-write.yaml

Beri akun layanan tenant1 izin untuk membaca dan menulis objek di bucket:

gsutil iam ch \
    serviceAccount:tenant1-gsa@$PROJECT_ID.iam.gserviceaccount.com:objectAdmin \
    gs://$BUCKET

Cetak konfigurasi tugas:
```
kubectl kustomize manifests/jobs/write-gcs/
```
Outputnya akan terlihat seperti berikut:
```
apiVersion: batch/v1
kind: Job
metadata:
name: tenant1-pi-job-gcs
spec:
...
```
Nama bucket baru diteruskan sebagai argumen ke container generate-pi, dan tugas tersebut menentukan akun layanan Kubernetes tenant1-ksa yang sesuai.
Kirim tugas:
```
kubectl apply -k manifests/jobs/write-gcs/
```
Seperti di bagian sebelumnya, penyediaan otomatis node membuat node pool dan node baru untuk mengeksekusi tugas.
Lihat Pod tugas:
```
kubectl get pods -n tenant1-ns -w
```
Dalam kasus ini, Anda akan melihat Pod dan bukan node pool-nya. Anda akan melihat transisi Pod melalui berbagai status. Setelah beberapa menit, statusnya akan berubah menjadi Completed. Status ini menunjukkan bahwa tugas tersebut telah berhasil diselesaikan.
Untuk berhenti melihat, tekan Control+C.
Pastikan bahwa file telah ditulis ke bucket Cloud Storage:
```
gsutil ls -l gs://$BUCKET
```
Anda akan melihat satu file.
Hapus tugas untuk melakukan pembersihan:
```
kubectl delete job tenant1-pi-job-gcs -n tenant1-ns
```
Anda akan mengirim ulang tugas ini di bagian berikutnya.

Mencabut izin IAM

Terakhir, Anda mengonfirmasi bahwa mencabut izin IAM dari akun layanan Google Cloud mencegah akun layanan Kubernetes yang dipetakan untuk dapat mengakses bucket Cloud Storage.

Cabut izin akun layanan Google Cloud untuk menulis ke bucket Cloud Storage:

gsutil iam ch -d \
    serviceAccount:tenant1-gsa@$PROJECT_ID.iam.gserviceaccount.com:objectAdmin \
    gs://$BUCKET

Kirimkan tugas yang sama seperti sebelumnya:

kubectl apply -k manifests/jobs/write-gcs/

Lihat status Pod tugas sekali lagi:
```
kubectl get pods -n tenant1-ns -w
```
Setelah beberapa menit, status akan berubah menjadi Error yang menunjukkan bahwa tugas gagal. Error ini sudah diperhitungkan karena tugas tersebut dieksekusi sebagai akun layanan Kubernetes yang dipetakan ke akun layanan Google Cloud yang tidak lagi memiliki izin tulis ke bucket Cloud Storage.
Untuk berhenti melihat Pod, tekan Control+C.
Tampilkan daftar file dalam bucket:
```
gsutil ls -l gs://$BUCKET
```
Anda melihat satu file dalam bucket; file baru belum ditulis.

Pembersihan

Cara termudah untuk menghilangkan penagihan adalah dengan menghapus project Google Cloud yang Anda buat untuk tutorial.

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 berbagai arsitektur, tutorial, atau panduan memulai, menggunakan kembali project dapat membantu agar Anda tidak melampaui batas kuota project.

Di konsol Google Cloud, buka halaman Manage resource.
Buka Manage resource
Pada daftar project, pilih project yang ingin Anda hapus, lalu klik Delete.
Pada dialog, ketik project ID, lalu klik Shut down untuk menghapus project.

Menghapus cluster GKE

Jika Anda tidak ingin menghapus project, hapus cluster GKE:

gcloud container clusters delete multitenant

Langkah selanjutnya

Pelajari lebih lanjut tentang multi-tenancy GKE.
Pelajari autoscaler cluster.
Pelajari arsitektur referensi, diagram, dan praktik terbaik tentang Google Cloud. Lihat Cloud Architecture Center kami.