Halaman ini diterjemahkan oleh Cloud Translation API.

Men-deploy Redis ke GKE menggunakan Redis Enterprise

Standard

Panduan ini menunjukkan cara men-deploy Redis Enterprise ke cluster Google Kubernetes Engine (GKE).

Redis adalah database NoSQL dalam memori open source yang terutama digunakan untuk penyimpanan dalam cache. Redis memiliki replikasi bawaan, skrip Lua, pengusiran LRU, transaksi, persistensi di disk, dan ketersediaan tinggi.

Redis Enterprise adalah solusi tingkat perusahaan yang memperluas open source Redis dengan pengelolaan yang disederhanakan, termasuk distribusi data yang direplikasi secara geografis, penskalaan linear throughput operasi, tingkatan data, fitur keamanan lanjutan, dan lainnya.

Redis Enterprise memiliki harga yang berbeda untuk setiap opsi deployment, termasuk: Software, Cloud, atau Hybrid dan Multi-cloud.

Panduan ini ditujukan untuk administrator platform, arsitek cloud, dan tenaga profesional operasi yang tertarik untuk men-deploy Redis Enterprise di Google Kubernetes Engine (GKE).

Tujuan

Merencanakan dan men-deploy infrastruktur GKE untuk Redis
Men-deploy Operator Redis Enterprise
Men-deploy Cluster Redis Enterprise
Membuat Database Redis Enterprise
Menunjukkan autentikasi database

Manfaat

Redis Enterprise menawarkan manfaat berikut:

Cara native Kubernetes untuk mengelola siklus proses Redis Enterprise Cluster (REC) dan Database Redis Enterprise (REDB)
Penggunaan resource dengan menempatkan bersama beberapa database Redis dalam satu Pod Kubernetes
Mengurangi overhead operasional dengan menangani tugas pemeliharaan rutin seperti pembaruan dan upgrade
Dukungan untuk image software Redis dari registry container pribadi, seperti Artifact Registry, untuk meningkatkan keamanan dan ketersediaan container
Dukungan untuk Google Cloud Managed Service for Prometheus untuk pemantauan dan pengamatan database
Fitur keamanan yang ditingkatkan seperti enkripsi, kontrol akses, dan integrasi dengan RBAC (Kontrol Akses Berbasis Peran) Kubernetes
Metode autentikasi lanjutan termasuk LDAP dan pengelola kredensial pihak ketiga seperti Vault
Kemampuan untuk mengonfigurasi pencadangan terjadwal

Arsitektur deployment

Redis Enterprise mengelola resource Kubernetes berikut:

Cluster Enterprise dan konfigurasinya dalam StatefulSet. Cluster terdiri dari node Redis (Pod) dengan paket Redis yang diinstal. Node ini memiliki proses yang berjalan untuk memastikan node adalah bagian dari cluster. Setiap node menyediakan penampung untuk menjalankan beberapa instance database (shard). Meskipun praktik terbaik Kubernetes menyatakan bahwa Pod harus mewakili satu aplikasi dengan satu container, Redis Enterprise men-deploy beberapa database Redis ke satu container. Pendekatan ini memberikan pemanfaatan resource, performa, dan throughput jaringan yang lebih baik. Setiap penampung juga memiliki proxy latensi nol untuk merutekan dan mengelola traffic ke proses database Redis tertentu dalam penampung.
Resource kustom RedisEnterpriseDatabase (REDB) yang mewakili instance database Redis yang dibuat dalam REC
Layanan Kubernetes yang menayangkan instance REDB sebagai endpoint database
Pod pengontrol yang disebut Service Rigger yang membuat dan menghapus endpoint database saat database dibuat atau dihapus

Dalam tutorial ini, Anda akan membuat deployment satu ke banyak dengan men-deploy REC ke namespace khusus dan menggunakan namespace terpisah untuk deployment aplikasi guna mendapatkan isolasi yang lebih baik.

Diagram berikut menjelaskan komponen Redis Enterprise dan cara komponen tersebut saling terhubung:

Diagram menunjukkan contoh arsitektur Redis Enterprise. — **Gambar 1**: Contoh arsitektur Redis Enterprise.

Dalam tutorial ini, Anda akan mengonfigurasi Cluster Redis Enterprise agar sangat tersedia. Untuk melakukannya, REC memerlukan jumlah node ganjil dan minimum tiga node. Anda juga menetapkan afinitas, aturan anti-afinitas, dan taint node yang memastikan bahwa setiap node Redis ditempatkan di node Kubernetes yang berbeda dan node Redis tersebar secara merata di seluruh cluster Kubernetes.

Penggunaan beberapa node dan zona sangat penting untuk mencapai cluster GKE yang memiliki ketersediaan tinggi. Alasannya sebagai berikut:

Fault tolerance: Beberapa node mendistribusikan workload di seluruh cluster, memastikan bahwa jika satu node gagal, node lainnya dapat mengambil alih tugas, sehingga mencegah periode nonaktif dan gangguan layanan.
Skalabilitas: Memiliki beberapa node memungkinkan penskalaan horizontal dengan menambahkan atau menghapus node sesuai kebutuhan, sehingga memastikan alokasi resource yang optimal dan mengakomodasi peningkatan permintaan workload dan traffic.
Ketersediaan tinggi: Penggunaan beberapa zona dalam satu region akan memastikan redundansi dan meminimalkan risiko titik tunggal kegagalan. Jika seluruh zona ketersediaan mengalami pemadaman, cluster dapat terus berjalan di zona lain, sehingga mempertahankan ketersediaan layanan.
Redundansi geografis: Dengan menjangkau node di berbagai region, data dan layanan cluster akan dapat terdistribusi secara geografis, sehingga memberikan ketahanan terhadap bencana alam, pemadaman listrik, atau gangguan lokal lainnya yang mungkin memengaruhi satu zona.
Update dan pemeliharaan berkelanjutan: Dengan menggunakan beberapa node, Anda dapat melakukan update dan pemeliharaan berkelanjutan pada setiap node tanpa memengaruhi ketersediaan cluster secara keseluruhan. Hal ini memastikan layanan yang berkelanjutan sekaligus memungkinkan Anda melakukan update yang diperlukan dan menerapkan patch dengan lancar.
Perjanjian Tingkat Layanan (SLA): Google Cloud menyediakan SLA untuk deployment multi-zona, yang menjamin tingkat waktu beroperasi dan ketersediaan minimum.

Biaya

Dalam dokumen ini, Anda akan 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.

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

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.

Install the Google Cloud CLI.

To initialize the gcloud CLI, run the following command:

gcloud init

Note: If you installed the gcloud CLI previously, make sure you have the latest version by running

gcloud components
      update

Create or select a Google Cloud project.

Create a Google Cloud project:
```
gcloud projects create PROJECT_ID
```
Replace PROJECT_ID with a name for the Google Cloud project you are creating.
Select the Google Cloud project that you created:
```
gcloud config set project PROJECT_ID
```
Replace PROJECT_ID with your Google Cloud project name.

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

Enable the Compute Engine, IAM, GKE, and Resource Manager APIs:

gcloud services enable compute.googleapis.com iam.googleapis.com container.googleapis.com cloudresourcemanager.googleapis.com

Install the Google Cloud CLI.

To initialize the gcloud CLI, run the following command:

gcloud init

Note: If you installed the gcloud CLI previously, make sure you have the latest version by running

gcloud components
      update

Create or select a Google Cloud project.

Create a Google Cloud project:
```
gcloud projects create PROJECT_ID
```
Replace PROJECT_ID with a name for the Google Cloud project you are creating.
Select the Google Cloud project that you created:
```
gcloud config set project PROJECT_ID
```
Replace PROJECT_ID with your Google Cloud project name.

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

Enable the Compute Engine, IAM, GKE, and Resource Manager APIs:

gcloud services enable compute.googleapis.com iam.googleapis.com container.googleapis.com cloudresourcemanager.googleapis.com

Grant roles to your user account. Run the following command once for each of the following IAM roles: roles/compute.securityAdmin, roles/compute.viewer, roles/container.clusterAdmin, roles/container.admin, roles/iam.serviceAccountAdmin, roles/iam.serviceAccountUser
```
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:myemail@example.com.
- Replace ROLE with each individual role.

Menyiapkan lingkungan Anda

Dalam tutorial ini, Anda akan menggunakan Cloud Shell untuk mengelola resource yang dihosting di Google Cloud. Cloud Shell telah diinstal dengan software yang Anda perlukan untuk tutorial ini, termasuk kubectl, gcloud CLI, dan Terraform.

Untuk menyiapkan lingkungan Anda dengan Cloud Shell, ikuti langkah-langkah berikut:

Luncurkan sesi Cloud Shell dari konsol Google Cloud, dengan mengklik Aktifkan Cloud Shell di konsol Google Cloud. Tindakan ini akan meluncurkan sesi di panel bawah konsol Google Cloud.

Menetapkan variabel lingkungan:

export PROJECT_ID=PROJECT_ID
export KUBERNETES_CLUSTER_PREFIX=redis
export REGION=us-central1

Ganti PROJECT_ID: Google Cloud Anda dengan project ID.

Buat clone repositori GitHub:

git clone https://github.com/GoogleCloudPlatform/kubernetes-engine-samples

Ubah ke direktori kerja:

cd kubernetes-engine-samples/databases/redis-enterprise-operator

Membuat infrastruktur cluster

Di bagian ini, Anda akan menjalankan skrip Terraform untuk membuat VPC dan cluster GKE regional pribadi yang sangat tersedia.

Diagram berikut menunjukkan cluster GKE Standard regional pribadi yang di-deploy ke tiga zona yang berbeda:

Untuk men-deploy infrastruktur ini, jalankan perintah berikut dari Cloud Shell:

  cd terraform/gke-standard
  export GOOGLE_OAUTH_ACCESS_TOKEN=$(gcloud auth print-access-token)
  terraform init
  terraform apply -var project_id=${PROJECT_ID}   \
    -var region=${REGION}  \
    -var cluster_prefix=${KUBERNETES_CLUSTER_PREFIX}

Saat diminta, ketik yes. Anda mungkin perlu menunggu beberapa menit agar perintah ini selesai dan cluster akan menampilkan status siap.

Terraform membuat resource berikut:

Jaringan VPC dan subnet pribadi untuk node Kubernetes
Router untuk mengakses internet melalui NAT
Cluster GKE pribadi di region us-central1
Satu node pool dengan penskalaan otomatis diaktifkan (Satu hingga dua node per zona, minimum satu node per zona)

Outputnya mirip dengan hal berikut ini:

...
Apply complete! Resources: 14 added, 0 changed, 0 destroyed.
...

Hubungkan ke cluster

Dengan menggunakan Cloud Shell, konfigurasikan kubectl untuk berkomunikasi dengan cluster:

gcloud container clusters get-credentials ${KUBERNETES_CLUSTER_PREFIX}-cluster --region ${REGION}

Men-deploy operator Redis Enterprise ke cluster Anda

Di bagian ini, Anda akan men-deploy operator Redis Enterprise ke cluster Kubernetes.

Buat namespace untuk REC dan aplikasinya:

kubectl create namespace rec-ns
kubectl create namespace application

Beri label pada namespace:

kubectl label namespace rec-ns connection=redis
kubectl label namespace application connection=redis

Dapatkan paket Operator Redis Enterprise versi terbaru:

VERSION=`curl --silent https://api.github.com/repos/RedisLabs/redis-enterprise-k8s-docs/releases/latest | grep tag_name | awk -F'"' '{print $4}'`

Instal operator Redis Enterprise:

kubectl apply -n rec-ns -f https://raw.githubusercontent.com/RedisLabs/redis-enterprise-k8s-docs/$VERSION/bundle.yaml

Outputnya mirip dengan hal berikut ini:

role.rbac.authorization.k8s.io/redis-enterprise-operator created
rolebinding.rbac.authorization.k8s.io/redis-enterprise-operator created
serviceaccount/redis-enterprise-operator created
service/admission created
customresourcedefinition.apiextensions.k8s.io/redisenterpriseclusters.app.redislabs.com created
customresourcedefinition.apiextensions.k8s.io/redisenterprisedatabases.app.redislabs.com created
customresourcedefinition.apiextensions.k8s.io/redisenterpriseremoteclusters.app.redislabs.com created
customresourcedefinition.apiextensions.k8s.io/redisenterpriseactiveactivedatabases.app.redislabs.com created
deployment.apps/redis-enterprise-operator created

Men-deploy Cluster Redis Enterprise

Terapkan manifes ke cluster Anda:
```
kubectl apply -n rec-ns -f manifests/01-basic-cluster/rec.yaml
```
Pemrosesan perintah ini mungkin memerlukan waktu beberapa menit.

Periksa status deployment REC:

kubectl get rec -n rec-ns

Outputnya mirip dengan hal berikut ini:

NAME      NODES   VERSION    STATE     SPEC STATUS   LICENSE STATE   SHARDS LIMIT   LICENSE EXPIRATION DATE   AGE
gke-rec   3       7.2.4-52   Running   Valid         Valid           4              2023-09-29T20:15:32Z      4m7s

Cluster siap jika STATE adalah RUNNING.

Opsional: Mengonfigurasi pengontrol akses

Anda dapat mengonfigurasi infrastruktur untuk validasi database pada deployment secara opsional.

Siapkan pengontrol akses dan periksa apakah Secret tls akses ada:
```
kubectl get secret admission-tls -n rec-ns
```

Dapatkan sertifikat:

export CERT=$(kubectl get secret admission-tls -n rec-ns -o jsonpath='{.data.cert}')

Salin sertifikat ke dalam file webhook.yaml:

sed -i -e 's/CRT/'$CERT'/g' manifests/01-basic-cluster/webhook.yaml

Deploy webhook validasi:
```
sed -i -e 's/CRT/'$CERT'/g' manifests/01-basic-cluster/webhook.yaml
```
Pengontrol penerimaan memvalidasi sintaksis database di namespace berlabel.

Verifikasi pengontrol akses dengan membuat database yang tidak berfungsi:

kubectl apply -n rec-ns -f - << EOF
apiVersion: app.redislabs.com/v1alpha1
kind: RedisEnterpriseDatabase
metadata:
  name: redis-enterprise-database
spec:
  evictionPolicy: illegal
EOF

Outputnya mirip dengan hal berikut ini:

Error from server: error when creating "STDIN": admission webhook "redisenterprise.admission.redislabs" denied the request: 'illegal' is an invalid value for 'eviction_policy'. Possible values are ['volatile-lru', 'volatile-ttl', 'volatile-random', 'allkeys-lru', 'allkeys-random', 'noeviction', 'volatile-lfu', 'allkeys-lfu']

Membuat namespace

Secara default, Operator Redis Enterprise tidak memiliki hak istimewa untuk melakukan tindakan di luar namespace-nya sendiri. Agar Redis Enterprise Operator dapat membuat REDB dan endpoint database di namespace lain, Anda harus mengonfigurasi RBAC.

Terapkan peran dan binding peran yang sesuai di namespace aplikasi:

kubectl apply -f manifests/01-basic-cluster/role.yaml -n application
kubectl apply -f manifests/01-basic-cluster/role-binding.yaml -n application

Buat peran cluster dan binding peran cluster di namespace rec-ns:

kubectl apply -n rec-ns -f manifests/01-basic-cluster/cluster_role.yaml
kubectl apply -n rec-ns -f manifests/01-basic-cluster/cluster_role_binding.yaml

Edit ConfigMap REC untuk menambahkan kontrol atas namespace aplikasi:

kubectl patch ConfigMap/operator-environment-config --type merge -p '{"data": {"REDB_NAMESPACES_LABEL": "connection=redis"}}' -n rec-ns

Setiap namespace yang diberi label sebagai ConfigMap akan di-patch.

Periksa status resource di infrastruktur Redis Anda di namespace rec-ns:.

kubectl get pod,deploy,svc,rec,statefulset,cm,secrets -n rec-ns

Outputnya mirip dengan hal berikut ini:

NAME                                             READY   STATUS    RESTARTS        AGE
pod/gke-rec-0                                    2/2     Running   0               172m
pod/gke-rec-1                                    2/2     Running   0               171m
pod/gke-rec-2                                    2/2     Running   0               168m
pod/gke-rec-services-rigger-5f885f59dc-gc79g     1/1     Running   0               172m
pod/redis-enterprise-operator-6668ccd8dc-kx29z   2/2     Running   2 (5m58s ago)   5h

NAME                                        READY   UP-TO-DATE   AVAILABLE   AGE
deployment.apps/gke-rec-services-rigger     1/1     1            1           172m
deployment.apps/redis-enterprise-operator   1/1     1            1           5h

NAME                   TYPE        CLUSTER-IP    EXTERNAL-IP   PORT(S)             AGE
service/admission      ClusterIP   10.52.11.13   <none>        443/TCP             5h
service/gke-rec        ClusterIP   10.52.5.44    <none>        9443/TCP,8001/TCP   172m
service/gke-rec-prom   ClusterIP   None          <none>        8070/TCP            172m
service/gke-rec-ui     ClusterIP   10.52.3.29    <none>        8443/TCP            172m

NAME                                               NODES   VERSION    STATE     SPEC STATUS   LICENSE STATE   SHARDS LIMIT   LICENSE EXPIRATION DATE   AGE
redisenterprisecluster.app.redislabs.com/gke-rec   3       7.2.4-52   Running   Valid         Valid           4              2023-10-05T11:07:20Z      172m

NAME                       READY   AGE
statefulset.apps/gke-rec   3/3     172m

NAME                                    DATA   AGE
configmap/gke-rec-bulletin-board        1      172m
configmap/gke-rec-health-check          5      172m
configmap/kube-root-ca.crt              1      5h2m
configmap/operator-environment-config   1      5h

NAME                   TYPE     DATA   AGE
secret/admission-tls   Opaque   2      5h
secret/gke-rec         Opaque   2      172m

Men-deploy Database Redis Enterprise

Buat Database Redis Enterprise di namespace aplikasi:

kubectl apply -f manifests/01-basic-cluster/a-rdb.yaml -n application

Periksa status REDB:

kubectl get redb --all-namespaces

Outputnya mirip dengan hal berikut ini:

NAMESPACE       NAME       VERSION   PORT    CLUSTER   SHARDS   STATUS   SPEC STATUS   AGE
application   app-db   7.2.0     12999   gke-rec   1        active   Valid         15s

Pastikan Layanan untuk setiap REDB berjalan:

kubectl get svc --all-namespaces

Outputnya mirip dengan hal berikut ini:

NAMESPACE      NAME      TYPE          CLUSTER-IP   EXTERNAL-IP                           PORT(S)    AGE
application  app-db  ExternalName  <none>       redis-12999.rec-ns.svc.cluster.local  12999/TCP  72m

Pastikan Secret telah dibuat:

kubectl get secrets -n application

Outputnya mirip dengan hal berikut ini:

NAME            TYPE     DATA   AGE
redb-app-db   Opaque   3      96m

Anda dapat terhubung ke REDB menggunakan Pod dengan redis-cli di namespace aplikasi. Pod klien menggunakan secret yang tersedia di namespace aplikasi (REDB) untuk membuat koneksi.

Database yang dibuat dengan REDB Resource Kustom hanya mendukung autentikasi sandi tanpa ACL.

Buat Pod klien:

kubectl apply -n application -f manifests/03-auth/client_pod.yaml

Menghubungkan ke Pod klien:

kubectl exec -n application -i -t redis-client -c redis-client -- /bin/sh

Menghubungkan ke database:

redis-cli -h $SERVICE -p $PORT --pass $PASS

Buat kunci:
```
SET mykey "Hello World"
```
Outputnya mirip dengan hal berikut ini:
```
OK
```
Dapatkan kunci:
```
GET mykey
```
Outputnya mirip dengan hal berikut ini:
```
"Hello World"
```
Keluar dari shell Pod
```
exit
```

Memahami cara Prometheus mengumpulkan metrik untuk cluster Redis Anda

Diagram berikut menunjukkan cara kerja pengumpulan metrik Prometheus:

Dalam diagram, cluster pribadi GKE berisi:

Pod Redis yang mengumpulkan metrik di jalur / dan port 8070
Pengumpul berbasis Prometheus yang memproses metrik dari Pod Redis
Resource PodMonitoring yang mengirim metrik ke Cloud Monitoring

Operator Redis Enterprise mengekspos metrik cluster dalam format Prometheus.

Buat Deployment proxy metrik:
```
kubectl apply -n rec-ns -f manifests/02-prometheus-metrics/metrics-proxy.yaml
```
Karena operator hanya menyediakan endpoint HTTPS dengan sertifikat yang ditandatangani sendiri dan resource PodMonitoring tidak mendukung penonaktifan verifikasi sertifikat TLS, Anda menggunakan Pod metrics-proxy sebagai proxy balik untuk endpoint ini guna mengekspos metrik di port HTTP.

Buat resource PodMonitoring untuk mengambil metrik menurut labelSelector:

kubectl apply -n rec-ns -f manifests/02-prometheus-metrics/pod-monitoring.yaml

Di konsol Google Cloud, buka halaman GKE Clusters Dashboard.

Buka Dasbor Cluster GKE

Dasbor menampilkan rasio penyerapan metrik yang bukan nol.

Membuat Dasbor

Anda dapat melihat metrik dengan membuat dasbor.

Buat dasbor:

gcloud --project "${PROJECT_ID}" monitoring dashboards create --config-from-file monitoring/dashboard.json

Outputnya mirip dengan hal berikut ini:

Created [f4efbe4e-2605-46b4-9910-54b13d29b3be].

Di Konsol Google Cloud, buka halaman Dashboards.

Buka Dashboards
Buka dasbor Cluster Redis Enterprise. Mungkin perlu waktu beberapa menit hingga dasbor disediakan secara otomatis.

Memverifikasi metrik yang diekspor

Untuk memverifikasi metrik, buat database baru dan periksa metrik.

Buka dasbor Cluster Redis Enterprise.

Buat database Redis tambahan:

kubectl apply -n rec-ns -f manifests/02-prometheus-metrics/c-rdb.yaml

Jumlah Database di dasbor akan diperbarui.

Buat Pod klien untuk terhubung ke database baru:

kubectl apply -n rec-ns -f manifests/02-prometheus-metrics/client_pod.yaml

Hubungkan ke Pod klien dan siapkan variabel:

kubectl exec -it redis-client-c -n rec-ns -- /bin/bash

Gunakan alat redis-cli untuk membuat kunci baru:

for i in {1..50}; do \
  redis-cli -h $SERVICE -p $PORT -a $PASS \
  --no-auth-warning SET mykey-$i "myvalue-$i"; \
done

Muat ulang halaman dan amati bahwa grafik telah diperbarui untuk menampilkan status database yang sebenarnya.
Keluar dari shell Pod
```
exit
```

Pembersihan

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.

Delete a Google Cloud project:

gcloud projects delete PROJECT_ID

Menghapus resource satu per satu

Menetapkan variabel lingkungan.

export PROJECT_ID=${PROJECT_ID}
export KUBERNETES_CLUSTER_PREFIX=redis
export REGION=us-central1

Jalankan perintah terraform destroy:

export GOOGLE_OAUTH_ACCESS_TOKEN=$(gcloud auth print-access-token)
cd terraform/gke-standard
terraform destroy -var project_id=${PROJECT_ID}   \
  -var region=${REGION}  \
  -var cluster_prefix=${KUBERNETES_CLUSTER_PREFIX}

Saat diminta, ketik yes.

Temukan semua disk yang tidak terpasang:

export disk_list=$(gcloud compute disks list --filter="-users:* AND labels.name=${KUBERNETES_CLUSTER_PREFIX}-cluster" --format "value[separator=|](name,zone)")

Hapus disk:

for i in $disk_list; do
  disk_name=$(echo $i| cut -d'|' -f1)
  disk_zone=$(echo $i| cut -d'|' -f2|sed 's|.*/||')
  echo "Deleting $disk_name"
  gcloud compute disks delete $disk_name --zone $disk_zone --quiet
done

Hapus repositori GitHub:
```
rm -r ~/kubernetes-engine-samples/
```

Langkah selanjutnya

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

Men-deploy Redis ke GKE menggunakan Redis Enterprise

Tujuan

Manfaat

Arsitektur deployment

Biaya

Sebelum memulai

Menyiapkan lingkungan Anda

Membuat infrastruktur cluster

Hubungkan ke cluster

Men-deploy operator Redis Enterprise ke cluster Anda

Men-deploy Cluster Redis Enterprise

Opsional: Mengonfigurasi pengontrol akses

Membuat namespace

Men-deploy Database Redis Enterprise

Mengautentikasi menggunakan sandi

Memahami cara Prometheus mengumpulkan metrik untuk cluster Redis Anda

Membuat Dasbor

Memverifikasi metrik yang diekspor

Pembersihan

Menghapus project

Menghapus resource satu per satu

Langkah selanjutnya