Men-deploy Redis ke GKE menggunakan Redis Enterprise

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. 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 throughput operasi yang linear, penjenjangan data, fitur keamanan tingkat lanjut, 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).

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:

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

  2. 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 Anda.

  3. Buat clone repositori GitHub:

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

  4. 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, konfigurasi kubectl untuk berkomunikasi dengan cluster:

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

Men-deploy operator Redis Enterprise ke cluster Anda

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

  1. Buat namespace untuk REC dan aplikasinya:

    kubectl create namespace rec-ns
kubectl create namespace application

  2. Beri label pada namespace:

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

  3. 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}'`

  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 Redis Enterprise Cluster

  1. Terapkan manifes ke cluster Anda:

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

    Pemrosesan perintah ini dapat memerlukan waktu beberapa menit.

  2. 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 penerimaan

Secara opsional, Anda dapat mengonfigurasi infrastruktur untuk validasi database saat deployment.

  1. Siapkan pengontrol penerimaan dan periksa apakah Secret TLS penerimaan ada:

    kubectl get secret admission-tls -n rec-ns

  2. Dapatkan sertifikat:

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

  3. Salin sertifikat ke dalam file webhook.yaml:

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

  4. Deploy webhook validasi:

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

    Pengontrol penerimaan memvalidasi sintaksis database pada namespace berlabel.

  5. 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. Untuk mengizinkan Redis Enterprise Operator membuat endpoint database dan REDB di namespace lain, Anda harus mengonfigurasi RBAC.

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

  2. Buat binding peran cluster dan 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

  3. 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 akan di-patch.

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

  1. Buat Database Redis Enterprise di namespace aplikasi:

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

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

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

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

Melakukan autentikasi menggunakan sandi

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.

  1. Buat Pod klien:

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

  2. Hubungkan ke Pod klien:

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

  3. Hubungkan ke database:

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

  4. Buat kunci:

    SET mykey "Hello World"

    Outputnya mirip dengan hal berikut ini:

    OK

  5. Dapatkan kuncinya:

    GET mykey

    Outputnya mirip dengan hal berikut ini:

    "Hello World"

  6. 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 menampilkan metrik cluster dalam format Prometheus.

  1. 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 proxy terbalik untuk endpoint ini guna mengekspos metrik di port HTTP.

  2. Buat resource PodMonitoring untuk meng-scrape metrik menurut labelSelector:

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

  3. Di konsol Google Cloud , buka halaman GKE Clusters Dashboard.

    Buka Dasbor Cluster GKE

    Dasbor menampilkan rasio penyerapan metrik bukan nol.

Membuat Dasbor

Anda dapat melihat metrik dengan membuat dasbor.

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

  2. Di konsol Google Cloud , buka halaman Dashboards.

    Buka Dashboards

  3. Buka dasbor Redis Enterprise Cluster. Mungkin perlu waktu beberapa menit agar dasbor disediakan secara otomatis.

Memverifikasi metrik yang diekspor

Untuk memverifikasi metrik, buat database baru dan periksa metriknya.

  1. Buka dasbor Redis Enterprise Cluster.

  2. Buat database Redis tambahan:

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

    Jumlah Database di dasbor akan diperbarui.

  3. Buat Pod klien untuk terhubung ke database baru:

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

  4. Hubungkan ke Pod klien dan siapkan variabel:

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

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

  6. Muat ulang halaman dan amati bahwa grafik telah diperbarui untuk menampilkan status database yang sebenarnya.

  7. Keluar dari shell Pod

    exit