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 caching. LRU memiliki replikasi bawaan, pembuatan skrip Lua, penghapusan LRU, transaksi, persistensi pada 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 banyak lagi.

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 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
Mendemonstrasikan autentikasi database

Manfaat

Redis Enterprise menawarkan manfaat berikut:

Cara berbasis Kubernetes untuk mengelola siklus proses Redis Enterprise Cluster (REC) dan Redis Enterprise Databases (REDB)
Pemanfaatan resource dengan menempatkan beberapa database Redis secara bersamaan dalam satu Pod Kubernetes
Mengurangi biaya operasional dengan menangani tugas pemeliharaan rutin seperti patching 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 kemampuan observasi dan pemantauan database
Fitur keamanan yang ditingkatkan seperti enkripsi, kontrol akses, dan integrasi dengan Kubernetes RBAC (Role-Based Access Control)
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 ini:

Cluster Enterprise dan konfigurasinya dalam StatefulSet. Cluster ini terdiri dari node Redis (Pod) dengan paket Redis yang terinstal. Node ini telah menjalankan proses untuk memastikan node tersebut merupakan bagian dari cluster. Setiap node menyediakan container untuk menjalankan beberapa instance database (shard). Meskipun praktik terbaik Kubernetes menyatakan bahwa Pod harus merepresentasikan 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 container juga memiliki proxy latensi nol untuk merutekan dan mengelola traffic ke proses database Redis tertentu dalam sebuah container.
Resource kustom RedisEnterpriseDatabase (REDB) yang mewakili instance database Redis yang dibuat dalam REC
Layanan Kubernetes yang melayani instance REDB sebagai endpoint database
Pod pengontrol bernama Service Rigger yang membuat dan menghapus endpoint database saat database dibuat atau dihapus

Dalam tutorial ini, Anda membuat deployment one-to-many dengan men-deploy REC ke dalam 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 memiliki ketersediaan tinggi. Untuk melakukannya, REC memerlukan node dalam jumlah ganjil dan minimal tiga node. Anda juga menetapkan aturan 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.

Menggunakan beberapa node dan zona sangat penting untuk mencapai cluster GKE yang tersedia tinggi karena alasan berikut:

Toleransi error: Beberapa node mendistribusikan beban kerja ke seluruh cluster, sehingga memastikan bahwa jika satu node gagal, node lain 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 traffic atau permintaan beban kerja.
Ketersediaan tinggi: Menggunakan beberapa zona dalam satu region memastikan redundansi dan meminimalkan risiko titik tunggal kegagalan. Jika seluruh zona ketersediaan mengalami pemadaman, cluster dapat terus berjalan di zona lain, sehingga menjaga ketersediaan layanan.
Redundansi geografis: Dengan mencakup node di seluruh region, data dan layanan cluster didistribusikan 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 menjalankan update dan pemeliharaan berkelanjutan pada masing-masing node tanpa memengaruhi ketersediaan cluster secara keseluruhan. Hal ini akan 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 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

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.

Menginstal Google Cloud CLI.

Untuk initialize gcloud CLI, jalankan perintah berikut:

gcloud init

Catatan: Jika Anda telah menginstal gcloud CLI sebelumnya, pastikan Anda memiliki versi baru dengan menjalankan

gcloud components
      update

Buat atau pilih project Google Cloud.

Membuat project Google Cloud:
```
gcloud projects create PROJECT_ID
```
Ganti PROJECT_ID dengan nama untuk project Google Cloud yang Anda buat.
Pilih project Google Cloud yang Anda buat:
```
gcloud config set project PROJECT_ID
```
Ganti PROJECT_ID dengan nama project Google Cloud Anda.

Pastikan penagihan telah diaktifkan untuk project Google Cloud Anda.

Aktifkan API Compute Engine, IAM, GKE, and Resource Manager:

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

Menginstal Google Cloud CLI.

Untuk initialize gcloud CLI, jalankan perintah berikut:

gcloud init

Catatan: Jika Anda telah menginstal gcloud CLI sebelumnya, pastikan Anda memiliki versi baru dengan menjalankan

gcloud components
      update

Buat atau pilih project Google Cloud.

Membuat project Google Cloud:
```
gcloud projects create PROJECT_ID
```
Ganti PROJECT_ID dengan nama untuk project Google Cloud yang Anda buat.
Pilih project Google Cloud yang Anda buat:
```
gcloud config set project PROJECT_ID
```
Ganti PROJECT_ID dengan nama project Google Cloud Anda.

Pastikan penagihan telah diaktifkan untuk project Google Cloud Anda.

Aktifkan API Compute Engine, IAM, GKE, and Resource Manager:

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

Berikan peran ke Akun Google Anda. Jalankan perintah berikut satu kali untuk setiap peran IAM berikut: 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:EMAIL_ADDRESS" --role=ROLE
```
- Ganti PROJECT_ID dengan project ID Anda.
- Ganti EMAIL_ADDRESS dengan alamat email Anda.
- Ganti ROLE dengan setiap peran individual.

Menyiapkan lingkungan Anda

Dalam tutorial ini, Anda akan menggunakan Cloud Shell untuk mengelola resource yang dihosting di Google Cloud. Cloud Shell dilengkapi dengan software bawaan 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 yang bersifat pribadi dan 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
{i>Router<i} untuk mengakses internet melalui NAT
Cluster GKE pribadi di region us-central1
Satu kumpulan node 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 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 Anda.

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 Redis Enterprise Operator 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
```
Mungkin perlu waktu beberapa menit untuk menyelesaikan perintah.

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 saat STATE adalah RUNNING.

Opsional: Mengonfigurasi pengontrol penerimaan

Anda dapat mengonfigurasi infrastruktur untuk validasi database saat deployment.

Siapkan pengontrol penerimaan dan periksa apakah Secret tls penerimaan 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 pada namespace berlabel.

Verifikasi pengontrol penerimaan 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 Operator Redis Enterprise dapat membuat REDB dan endpoint database di namespace lain, Anda harus mengonfigurasi RBAC.

Terapkan peran dan binding peran yang sesuai dalam 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 REC ConfigMap 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 di-patch.

Periksa status resource dalam infrastruktur Redis Anda dalam 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 bahwa 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 rahasia yang tersedia di namespace aplikasi (REDB) untuk membuat koneksi.

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

Membuat 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

Hubungkan ke database:

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

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

Pahami 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
Kolektor berbasis Prometheus yang memproses metrik dari Pod Redis
Resource PodMonitoring yang mengirimkan metrik ke Cloud Monitoring

Operator Redis Enterprise mengekspos metrik cluster dalam format Prometheus.

Buat Deployment Metrics-proxy:
```
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 reverse proxy untuk endpoint ini guna menampilkan metrik di port HTTP.

Buat resource PodMonitoring untuk menyalin metrik menurut labelSelector:

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

Di konsol Google Cloud, buka halaman Dasbor Cluster GKE.

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 Redis Enterprise Cluster. Mungkin perlu waktu beberapa menit hingga dasbor menyediakannya secara otomatis.

Memverifikasi metrik yang diekspor

Untuk memverifikasi metrik, buat database baru dan periksa metrik.

Buka dasbor Redis Enterprise Cluster.

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

Menghapus project Google Cloud:

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 penerimaan

Membuat namespace

Men-deploy Database Redis Enterprise

Mengautentikasi menggunakan sandi

Pahami cara Prometheus mengumpulkan metrik untuk cluster Redis Anda

Membuat Dasbor

Memverifikasi metrik yang diekspor

Pembersihan

Menghapus project

Menghapus resource satu per satu

Langkah selanjutnya