Men-deploy cluster Redis di GKE

Standar

---

Tutorial ini menjelaskan praktik yang direkomendasikan untuk membuat aplikasi stateful dan mengupgrade cluster Google Kubernetes Engine (GKE) yang menjalankan aplikasi. Tutorial ini menggunakan Redis sebagai contoh untuk men-deploy aplikasi stateful, tetapi konsep yang sama berlaku untuk jenis aplikasi stateful lain yang di-deploy di GKE.

Tujuan

Tutorial ini membahas langkah-langkah berikut:

1. Membuat cluster GKE yang terdaftar di saluran rilis.
2. Membuat Cluster Redis di GKE.
3. Men-deploy aplikasi klien Redis ke GKE.
4. Melakukan praktik terbaik berikut untuk upgrade node pool:
   1. Menyiapkan Anggaran Gangguan Pod (PDB).
   2. Menyiapkan masa pemeliharaan dan pengecualian pemeliharaan.
   3. Siapkan strategi upgrade node untuk upgrade lonjakan atau upgrade blue-green.
5. Menguji aplikasi.
6. Mengupgrade cluster.
7. Menguji gangguan workload.

Diagram berikut menunjukkan tampilan tingkat tinggi arsitektur cluster untuk tutorial ini:

Biaya

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

• GKE

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

Menyiapkan project

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

2. Di konsol Google Cloud, pada halaman pemilih project, klik Buat project untuk mulai membuat project Google Cloud baru.

   Buka pemilih project

3. Pastikan penagihan telah diaktifkan untuk project Google Cloud Anda.

4. Enable the GKE API.

   Enable the API

5. Di konsol Google Cloud, pada halaman pemilih project, klik Buat project untuk mulai membuat project Google Cloud baru.

   Buka pemilih project

6. Pastikan penagihan telah diaktifkan untuk project Google Cloud Anda.

7. Enable the GKE API.

   Enable the API

Menetapkan setelan default untuk Google Cloud CLI

1. Di konsol Google Cloud, mulai instance Cloud Shell:
   Buka Cloud Shell

2. Download kode sumber untuk aplikasi contoh ini:

    git clone https://github.com/GoogleCloudPlatform/kubernetes-engine-samples
    cd kubernetes-engine-samples/quickstarts/hello-app-redis/manifests
   

3. Tetapkan variabel lingkungan default:

    gcloud config set project PROJECT-ID
    gcloud config set compute/zone COMPUTE-ZONE
   

   Ganti nilai berikut:

   • PROJECT_ID: project ID Google Cloud Anda.
   • COMPUTE_ZONE: zona Compute Engine.

Membuat cluster GKE yang terdaftar di saluran rilis

Untuk membuat cluster GKE, selesaikan langkah-langkah berikut:

1. Buat cluster bernama redis-test dengan tiga node:

   gcloud container clusters create redis-test \
       --num-nodes=3 \
       --release-channel regular
   

   Setelah cluster dibuat, Anda akan melihat output yang mirip dengan contoh berikut:

     NAME: redis-test
     LOCATION: us-central1-c
     MASTER_VERSION: 1.22.10-gke.600
     MASTER_IP: 34.69.67.7
     MACHINE_TYPE: e2-medium
     NODE_VERSION: 1.22.10-gke.600
     NUM_NODES: 3
     STATUS: RUNNING
   

2. Konfigurasi kubectl untuk berkomunikasi dengan cluster:

   gcloud container clusters get-credentials redis-test
   

Membuat Cluster Redis di GKE

Di bagian ini, Anda menambahkan Cluster Redis di atas cluster GKE yang sebelumnya Anda buat dengan men-deploy ConfigMap .StatefulSet , danLayanan headless.

Untuk membuat cluster Redis, ikuti seluruh langkah berikut:

1. Lihat file ConfigMap (redis-configmap.yaml) yang menyimpan konfigurasi Redis. Cuplikan di bawah ini menunjukkan skrip pemeriksaan Kesiapan dan skrip pemeriksaan Keaktifan.

   readiness.sh: |-
     #!/bin/sh
   
     pingResponse="$(redis-cli -h localhost ping)"
     if [ "$?" -eq "124" ]; then
       echo "PING timed out"
       exit 1
     fi
   
     if [ "$pingResponse" != "PONG"]; then
       echo "$pingResponse"
       exit 1
     fi
   liveness.sh: |-
     #!/bin/sh
   
     pingResponse="$(redis-cli -h localhost ping | head -n1 | awk '{print $1;}')"
     if [ "$?" -eq "124" ]; then
       echo "PING timed out"
       exit 1
     fi
   
     if [ "$pingResponse" != "PONG"] && [ "$pingResponse" != "LOADING" ] && [ "$pingResponse" != "MASTERDOWN" ]; then
       echo "$pingResponse"
       exit 1
     fi

   Skrip readiness.sh dan liveness.sh menggunakan ping redis-cli untuk memeriksa apakah server redis berjalan atau tidak. Jika yang ditampilkan adalah PONG, berarti server Redis sudah aktif dan berjalan. Skrip ini akan digunakan di redis-cluster.yaml.

   Untuk mempelajari parameter Redis dalam ConfigMap ini lebih lanjut, lihat bagian parameter konfigurasi Cluster Redis di tutorial Cluster Redis.

2. Men-deploy ConfigMap:

   kubectl apply -f redis-configmap.yaml
   

3. Lihat cuplikan StatefulSet (redis-cluster.yaml) di bawah, yang menunjukkan penggunaan pemeriksaan Kesiapan dan pemeriksaan Keaktifan.

   Untuk mempelajari cara mengonfigurasi pemeriksaan di Kubernetes, lihat Mengonfigurasi Pemeriksaan.

   startupProbe:
     periodSeconds: 5
     timeoutSeconds: 5
     successThreshold: 1
     failureThreshold: 20
     tcpSocket:
       port: redis
   livenessProbe:
     periodSeconds: 5
     timeoutSeconds: 5
     successThreshold: 1
     failureThreshold: 5
     exec:
       command: ["sh", "-c", "/probes/liveness.sh"]
   readinessProbe:
     periodSeconds: 5
     timeoutSeconds: 1
     successThreshold: 1
     failureThreshold: 5
     exec:
       command: ["sh", "-c", "/probes/readiness.sh"]

   Anda sangat disarankan untuk menggunakan pemeriksaan Kesiapan dan Keaktifan saat mengupgrade node pool; hal ini memastikan bahwa Pod Anda siap selama upgrade.

4. Men-deploy StatefulSet:

   kubectl apply -f redis-cluster.yaml
   

5. Layanan headless yang bernama redis-service.yaml ditujukan untuk koneksi node Redis. Kolom clusterIP ditetapkan ke None untuk membuat Layanan headless.

   Men-deploy Service:

   kubectl apply -f redis-service.yaml
   

6. Tunggu sekitar dua menit dan pastikan semua Pod berjalan dengan menggunakan perintah berikut:

   kubectl get pods
   

   Anda akan melihat output yang mirip dengan contoh berikut ini:

   NAME      READY   STATUS              RESTARTS   AGE
   redis-0   1/1     Running             0          2m29s
   redis-1   1/1     Running             0          2m8s
   redis-2   1/1     Running             0          107s
   redis-3   1/1     Running             0          85s
   redis-4   1/1     Running             0          54s
   redis-5   1/1     Running             0          23s
   

7. Pastikan volume persisten dibuat dengan menjalankan perintah berikut:

   kubectl get pv
   

   Anda akan melihat output yang mirip dengan contoh berikut ini:

   NAME       CAPACITY   ACCESS MODES   RECLAIM POLICY   STATUS   CLAIM                  STORAGECLASS   REASON   AGE
   pvc-HASH   1Gi        RWO            Delete           Bound    default/data-redis-5   standard                75s
   pvc-HASH   1Gi        RWO            Delete           Bound    default/data-redis-1   standard                2m59s
   pvc-HASH   1Gi        RWO            Delete           Bound    default/data-redis-3   standard                2m16s
   pvc-HASH   1Gi        RWO            Delete           Bound    default/data-redis-2   standard                2m38s
   pvc-HASH   1Gi        RWO            Delete           Bound    default/data-redis-0   standard                3m20s
   pvc-HASH   1Gi        RWO            Delete           Bound    default/data-redis-4   standard                104s
   

   Dalam output ini, HASH mewakili hash yang disertakan ke setiap nama volume persisten.

Menetapkan peran ke Cluster Redis

Setelah konfigurasi selesai, tetapkan peran ke Cluster Redis.

Skrip berikut memperoleh alamat IP Pod, lalu menetapkan peran pemimpin dan pengikut dengan meneruskan setiap alamat IP Pod ke dalam perintah:

#!/bin/bash
# Usage: ./roles.sh

urls=$(kubectl get pods -l app=redis -o jsonpath='{range.items[*]}{.status.podIP} ')
command="kubectl exec -it redis-0 -- redis-cli --cluster create --cluster-replicas 1 "

for url in $urls
do
    command+=$url":6379 "
done

echo "Executing command: " $command
$command

Untuk menetapkan peran ke cluster Redis, ikuti seluruh langkah berikut:

1. Jalankan skrip:

   chmod +x ./roles.sh
   ./roles.sh
   

2. Ketikkan yes saat diminta.

3. Login ke node Redis untuk memeriksa perannya. Misalnya, untuk memverifikasi bahwa redis-0 memiliki peran pemimpin, jalankan perintah berikut:

   kubectl exec -it redis-0 -- redis-cli role
   

   Anda akan melihat output yang mirip dengan contoh berikut ini:

   1) "master"
   2) (integer) 574
   3) 1) 1) "10.28.2.3"
          2) "6379"
          3) "574"
   

Men-deploy aplikasi klien Redis

Untuk men-deploy aplikasi ke cluster GKE yang Anda buat, tentukan Deployment untuk aplikasi Anda. File bernama app-deployment.yaml berisi definisi deployment untuk aplikasi.

Untuk mempelajari lebih lanjut pemeriksaan dan aturan afinitas Pod yang digunakan dalam Deployment ini, lihat Praktik terbaik GKE: Mendesain dan membangun cluster dengan ketersediaan tinggi.

Untuk membuat Deployment, ikuti seluruh langkah berikut:

1. Terapkan Deployment:

   kubectl apply -f app-deployment.yaml
   

2. Ekspos aplikasi melalui load balancer:

   kubectl expose deployment hello-web \
       --type=LoadBalancer \
       --port 80 \
       --target-port 8080
   

3. Tunggu sekitar satu menit, lalu ambil alamat IP eksternal aplikasi dengan menjalankan perintah berikut:

   kubectl get service
   

   Dari output, salin nilai yang tercantum di kolom hello-web's EXTERNAL-IP:

   NAME             TYPE           CLUSTER-IP    EXTERNAL-IP    PORT(S)              AGE
   hello-web        LoadBalancer   10.13.10.55   EXTERNAL_IP   80:30703/TCP         166m
   

4. Pastikan bahwa aplikasi berfungsi dengan menempelkan EXTERNAL_IP ke browser web Anda. Anda akan melihat output yang mirip dengan contoh berikut ini:

   I have been hit [1] times since deployment!
   

   Catat angka kunjungan. Anda harus menggunakannya di bagian Menguji gangguan aplikasi.

5. Tetapkan variabel untuk EXTERNAL_IP yang baru saja Anda salin. Anda menggunakan nilai ini saat membuat skrip untuk menguji aplikasi di bagian berikutnya:

   export IP=EXTERNAL_IP
   

Mengonfigurasi praktik terbaik untuk upgrade node pool

Lakukan praktik terbaik ini untuk aplikasi stateful guna mengoptimalkan ketersediaan yang lebih baik selama upgrade node pool.

Menyiapkan Anggaran Gangguan Pod (PDB)

Buat Anggaran Gangguan Pod untuk membatasi jumlah replika Pod yang mengalami gangguan secara bersamaan selama gangguan yang bersifat sukarela. Hal ini berguna untuk aplikasi stateful yang memerlukan ketersediaan replika dengan jumlah tertentu sebagai kuorum selama upgrade.

apiVersion: policy/v1
kind: PodDisruptionBudget
metadata:
  name: redis-pdb
spec:
  minAvailable: 3
  selector:
    matchLabels:
      app: redis

Dalam definisi PDB:

• app menentukan aplikasi tempat PDB ini diterapkan.
• minAvailable menetapkan jumlah minimum Pod yang akan tersedia selama terjadinya gangguan. Hal ini dapat berupa nilai atau persentase (misalnya 30%).
• maxUnavailable menetapkan jumlah maksimum Pod yang tidak dapat tersedia selama gangguan. Data ini bisa berupa nilai atau persentase juga.

Catatan: Berdasarkan kuorum atau preferensi aplikasi, pilih salah satu dari minAvailable atau maxUnavailable untuk PDB.

Catatan: Setelah PodDisruptionBudget ditetapkan, GKE tidak akan menonaktifkan Pod di aplikasi Anda jika jumlah pod sama dengan atau kurang dari batas yang dikonfigurasi hingga 60 menit.

Untuk menyiapkan PDB, ikuti seluruh langkah berikut:

1. Deploy PDB:

   kubectl apply -f pdb-minavailable.yaml
   

2. Pastikan bahwa layanan telah dibuat:

   kubectl get pdb
   

Menyiapkan masa pemeliharaan dan pengecualian pemeliharaan

Upgrade otomatis node menyederhanakan proses upgrade dan menjaga agar node dalam cluster selalu terbaru saat bidang kontrol diupgrade untuk Anda. Fitur ini diaktifkan secara default. Untuk mempelajari lebih lanjut, lihat Mengupgrade node otomatis.

Gunakan masa pemeliharaan dan pengecualian pemeliharaan untuk menyiapkan jangka waktu dan mengontrol kapan pemeliharaan dapat dan tidak dapat dilakukan di cluster GKE:

1. Siapkan masa pemeliharaan yang dimulai pukul 02.00 UTC pada 19 Agustus 2022, dan selesai empat jam setelahnya. Masa pemeliharaan ini berjalan setiap hari. Selama jangka waktu ini, pemeliharaan otomatis diizinkan.

   gcloud container clusters update redis-test \
      --maintenance-window-start 2022-08-19T02:00:00Z \
      --maintenance-window-end 2022-08-19T06:00:00Z \
      --maintenance-window-recurrence FREQ=DAILY
   

2. Siapkan periode pengecualian yang mencegah pemeliharaan selama liburan Tahun Baru. Pengecualian pemeliharaan ini menggunakan cakupan no_upgrades. Selama jangka waktu ini, pemeliharaan otomatis apa pun tidak diizinkan. Untuk mempelajari lebih lanjut, lihat Cakupan pemeliharaan yang akan dikecualikan.

   gcloud container clusters update redis-test \
      --add-maintenance-exclusion-name new-year \
      --add-maintenance-exclusion-start 2022-12-26T00:00:00Z \
      --add-maintenance-exclusion-end 2023-01-02T02:00:00Z \
      --add-maintenance-exclusion-scope no_upgrades
   

3. Pastikan masa pemeliharaan dan pengecualian diterapkan. Lihat di bawah maintenancePolicy:

   gcloud container clusters describe redis-test
   

Untuk mempelajari lebih lanjut, lihat Mengonfigurasi masa pemeliharaan dan pengecualian pemeliharaan.

Mengonfigurasi strategi upgrade node

Ada dua strategi upgrade node yang dapat Anda gunakan untuk node pool di cluster GKE: Upgrade blue-green dan upgrade surge. Untuk mempelajari lebih lanjut, lihat Strategi upgrade node.

Upgrade blue-green

Pilih upgrade blue-green jika workload tidak terlalu toleran terhadap gangguan, dan kenaikan biaya sementara karena penggunaan resource yang lebih tinggi dapat diterima.

Jalankan perintah berikut untuk mengubah node pool saat ini menjadi strategi upgrade blue-green.

gcloud container node-pools update default-pool \
--cluster=redis-test \
--enable-blue-green-upgrade \
--zone COMPUTE-ZONE \
--node-pool-soak-duration=120s

Durasi pengujian node pool disetel ke dua menit untuk menghemat waktu selama fase node pool pengujian untuk tujuan tutorial ini. Fase ini digunakan untuk memverifikasi kondisi workload setelah node pool biru dikosongkan. Sebaiknya tetapkan durasi pengujian node pool ke satu jam (3600 detik) atau durasi yang paling sesuai dengan aplikasi.

Untuk informasi selengkapnya tentang cara mengelola alokasi pod, lihat Men-deploy Pod ke node pool tertentu dan Men-deploy Layanan ke node pool tertentu.

Untuk informasi selengkapnya tentang cara mengonfigurasi upgrade blue-green, lihat Mengonfigurasi upgrade blue-green.

Upgrade Lonjakan

Pilih upgrade lonjakan jika pengoptimalan biaya penting dan jika workload dapat menoleransi penghentian terstruktur dalam waktu kurang dari 60 menit (GKE menaati ketentuan PDB, yaitu maksimal 60 menit).

Jalankan perintah berikut untuk mengubah node pool saat ini menjadi strategi upgrade lonjakan.

gcloud container node-pools update default-pool \
--max-surge-upgrade=1 \
--max-unavailable-upgrade=0 \
--cluster=redis-test

Dengan konfigurasi ini (maxSurge=1 dan maxUnavailable=0), hanya satu node lonjakan yang dapat ditambahkan ke node pool selama upgrade, sehingga hanya satu node yang dapat diupgrade pada satu waktu. Setelan ini mempercepat mulai ulang Pod selama upgrade namun proses tetap berlangsung secara konservatif.

Untuk informasi selengkapnya tentang cara mengonfigurasi upgrade lonjakan, lihat Mengonfigurasi upgrade lonjakan.

Periksa konfigurasi node pool saat ini:

   gcloud container node-pools describe default-pool \
   --cluster redis-test \
   --zone COMPUTE-ZONE

Untuk informasi selengkapnya tentang melihat node pool, lihat Melihat node pool di cluster.

Menguji aplikasi

Di bagian ini, Anda menggunakan dua skrip, satu yang mengirim permintaan ke aplikasi Anda, dan satu yang mengukur tingkat keberhasilan permintaan tersebut. Anda menggunakan skrip ini untuk mengukur apa yang terjadi saat mengupgrade cluster.

Untuk membuat skrip:

1. Ubah ke direktori yang berisi skrip:

   cd
   cd kubernetes-engine-samples/quickstarts/hello-app-redis/scripts
   

2. Lihat skrip bernama generate_load.sh yang mengirimkan permintaan kueri per detik (QPS) ke aplikasi Anda. Skrip ini menyimpan kode respons HTTP ke dalam direktori saat ini ke file bernama output. Nilai output digunakan dalam skrip yang Anda buat di langkah berikutnya.

   #!/bin/bash
   # Usage: ./generate_load.sh <IP> <QPS>
   
   IP=$1
   QPS=$2
   
   while true
     do for N in $(seq 1 $QPS)
       do curl -I -m 5 -s -w "%{http_code}\n" -o /dev/null http://${IP}/ >> output &
       done
     sleep 1
   done

3. Lihat skrip bernama print_error_rate.sh yang menghitung tingkat keberhasilan berdasarkan output yang dihasilkan oleh generate_load.sh.

   #!/bin/bash
   # Usage: watch ./print_error_rate.sh
   
   TOTAL=$(cat output | wc -l);
   SUCCESS=$(grep "200" output |  wc -l);
   ERROR1=$(grep "000" output |  wc -l)
   ERROR2=$(grep "503" output |  wc -l)
   ERROR3=$(grep "500" output |  wc -l)
   SUCCESS_RATE=$(($SUCCESS * 100 / TOTAL))
   ERROR_RATE=$(($ERROR1 * 100 / TOTAL))
   ERROR_RATE_2=$(($ERROR2 * 100 / TOTAL))
   ERROR_RATE_3=$(($ERROR3 * 100 / TOTAL))
   echo "Success rate: $SUCCESS/$TOTAL (${SUCCESS_RATE}%)"
   echo "App network Error rate: $ERROR1/$TOTAL (${ERROR_RATE}%)"
   echo "Resource Error rate: $ERROR2/$TOTAL (${ERROR_RATE_2}%)"
   echo "Redis Error rate: $ERROR3/$TOTAL (${ERROR_RATE_3}%)"

4. Berikan izin kepada diri Anda untuk menjalankan skrip:

   chmod u+x generate_load.sh print_error_rate.sh
   

5. Tetapkan variabel untuk jumlah QPS. Nilai ini digunakan dalam skrip generate_load.sh seperti variabel yang Anda tetapkan untuk EXTERNAL_IP. Sebaiknya tetapkan nilai sebesar 40.

   export QPS=40
   

6. Jalankan skrip generate_load.sh untuk mulai mengirim QPS:

   ./generate_load.sh $IP $QPS 2>&1
   

7. Biarkan skrip generate_load.sh berjalan dan buka terminal baru. Di terminal baru, jalankan skrip print_error_rate.sh untuk memeriksa tingkat error:

   cd
   cd kubernetes-engine-samples/quickstarts/hello-app-redis/scripts
   watch ./print_error_rate.sh
   

   Anda akan melihat tingkat keberhasilan 100% dan tingkat error 0% karena QPS dibuat.

8. Biarkan kedua skrip berjalan dan buka terminal ketiga untuk mempersiapkan bagian berikutnya.

Mengupgrade cluster

Untuk mengupgrade cluster, ikuti seluruh langkah berikut:

1. Tentukan versi GKE yang digunakan cluster redis-test:

   V=$(gcloud container clusters describe redis-test | grep "version:" | sed "s/version: //")
   echo $V
   

   Anda akan melihat output yang mirip dengan contoh berikut: 1.22.9-gke.2000.

2. Ambil daftar versi Kubernetes yang tersedia:

   gcloud container get-server-config
   

3. Dalam daftar versi, temukan bagian validMasterVersions: dan cari versi redis-cluster yang Anda ambil pada langkah sebelumnya. Untuk menghindari ketidaksesuaian versi, salin versi dari daftar yang berada tepat di atas versi redis-cluster.

4. Upgrade bidang kontrol cluster ke versi yang Anda pilih dan ketik y saat diminta:

   gcloud container clusters upgrade redis-test \
       --master \
       --cluster-version VERSION
   

   Ganti VERSION dengan versi yang Anda pilih dari daftar di langkah sebelumnya.

   Upgrade bidang kontrol memerlukan waktu beberapa menit.

5. Upgrade node cluster ke versi yang Anda pilih dan ketik y saat diminta:

   gcloud container clusters upgrade redis-test \
       --cluster-version=VERSION \
       --node-pool=default-pool
   

   Ganti VERSION dengan versi yang Anda pilih dari daftar.

Menguji gangguan workload

Di bagian ini, Anda akan menguji status aplikasi dan mengamati gangguan workload.

1. Kembali ke jendela terminal yang menjalankan ./print_error_rate.sh dan amati perubahan tingkat keberhasilan selama upgrade. Anda akan melihat sedikit penurunan dalam tingkat keberhasilan dan sedikit peningkatan pada tingkat error jaringan aplikasi saat node dihapus untuk diupgrade.

   Di kolom Success rate, Anda akan melihat angka kunjungan yang berhasil dilakukan ke situs. Catat nilai ini.

2. Hentikan kedua skrip agar tidak berjalan dengan memasukkan CTRL+C di terminal yang relevan.

3. Kembali ke situs aplikasi Anda dengan memasukkan alamat IP-nya (ini adalah EXTERNAL_IP yang Anda salin saat bagian Men-deploy aplikasi klien Redis) ke browser Anda.

4. Amati angka kunjungan untuk aplikasi Anda. Angka yang Anda lihat harus sama:

   ORIGINAL_VISIT_NUMBER + SUCCESSFUL_VISIT_NUMBER

   dengan ORIGINAL_VISIT_NUMBER adalah angka yang Anda catat pada langkah terakhir, yaitu Men-deploy aplikasi klien Redis dan SUCCESSFUL_VISIT_NUMBER adalah nilai yang Anda catat pada langkah pertama bagian ini.

Pembersihan

Setelah menyelesaikan tutorial, Anda dapat membersihkan resource yang dibuat agar resource tersebut berhenti menggunakan kuota dan dikenai biaya. Bagian berikut menjelaskan cara menghapus atau menonaktifkan resource ini.

Menghapus project

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

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

1. Di konsol Google Cloud, buka halaman Manage resource.

   Buka Manage resource

2. Pada daftar project, pilih project yang ingin Anda hapus, lalu klik Delete.
3. Pada dialog, ketik project ID, lalu klik Shut down untuk menghapus project.

Hapus kluster

Agar dapat menghapus cluster yang Anda buat untuk tutorial ini, jalankan perintah berikut:

gcloud container clusters delete redis-test

Langkah selanjutnya

• Praktik terbaik untuk mengupgrade cluster
• Cara menyetel notifikasi Cluster
• Praktik Terbaik GKE: Operasi Hari ke-2
• Menyiapkan Health check dengan Pemeriksaan