Esegui il deployment di Redis su GKE utilizzando Redis Enterprise

Configura l'ambiente

In questo tutorial utilizzerai Cloud Shell per gestire le risorse ospitate su Google Cloud. Cloud Shell include il software necessario per questo tutorial, tra cui kubectl, la gcloud CLI e Terraform.

Per configurare l'ambiente con Cloud Shell:

1. Avvia una sessione di Cloud Shell dalla console Google Cloud facendo clic su Attiva Cloud Shell nella consoleGoogle Cloud . Viene avviata una sessione nel riquadro inferiore della console Google Cloud .

2. Imposta le variabili di ambiente:

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

   Sostituisci PROJECT_ID: il tuo Google Cloud con il tuo ID progetto.

3. Clona il repository GitHub:

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

4. Passa alla directory di lavoro:

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

Crea l'infrastruttura del cluster

In questa sezione esegui uno script Terraform per creare un cluster GKE e un VPC privati, a disponibilità elevata e regionali.

Il seguente diagramma mostra un cluster GKE Standard regionale privato di cui è stato eseguito il deployment in tre zone diverse:

Per eseguire il deployment di questa infrastruttura, esegui i seguenti comandi da 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}

Quando richiesto, digita yes. Il completamento di questo comando e la visualizzazione dello stato pronto del cluster potrebbero richiedere diversi minuti.

Terraform crea le seguenti risorse:

• Una rete VPC e una subnet privata per i nodi Kubernetes
• Un router per accedere a internet tramite NAT
• Un cluster GKE privato nella regione us-central1
• Un pool di nodi con scalabilità automatica abilitata (da uno a due nodi per zona, minimo un nodo per zona)

L'output è simile al seguente:

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

Connettiti al cluster

Utilizzando Cloud Shell, configura kubectl per comunicare con il cluster:

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

Esegui il deployment dell'operatore Redis Enterprise nel tuo cluster

In questa sezione, esegui il deployment dell'operatore Redis Enterprise nel tuo cluster Kubernetes.

1. Crea spazi dei nomi per il REC e le relative applicazioni:

   kubectl create namespace rec-ns
   kubectl create namespace application
   

2. Etichetta gli spazi dei nomi:

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

3. Scarica l'ultima versione del bundle Redis Enterprise Operator:

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

4. Installa l'operatore Redis Enterprise:

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

   L'output è simile al seguente:

   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
   

Esegui il deployment del cluster Redis Enterprise

1. Applica il manifest al cluster:

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

   Il completamento di questo comando potrebbe richiedere diversi minuti.

2. Controlla lo stato del deployment di REC:

   kubectl get rec -n rec-ns
   

   L'output è simile al seguente:

   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
   

   Il cluster è pronto quando STATE è RUNNING.

(Facoltativo) Configura il controller di ammissione

Se vuoi, puoi configurare l'infrastruttura per la convalida del database durante il deployment.

1. Configura il controller di ammissione e controlla se il secret TLS di ammissione è presente:

   kubectl get secret admission-tls -n rec-ns
   

2. Ottenere il certificato:

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

3. Copia il certificato nel file webhook.yaml:

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

4. Esegui il deployment del webhook di convalida:

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

   Il controller di ammissione convalida la sintassi del database negli spazi dei nomi etichettati.

5. Verifica il controller di ammissione creando un database non funzionante:

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

   L'output è simile al seguente:

   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']
   

Crea spazi dei nomi

Per impostazione predefinita, Redis Enterprise Operator non dispone di privilegi per eseguire azioni al di fuori del proprio spazio dei nomi. Per consentire all'operatore Redis Enterprise di creare endpoint REDB e di database in altri spazi dei nomi, devi configurare RBAC.

1. Applica il ruolo e l'associazione di ruoli corrispondenti nello spazio dei nomi dell'applicazione:

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

2. Crea il ruolo cluster e l'associazione di ruolo cluster nello spazio dei nomi 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. Modifica il ConfigMap REC per aggiungere il controllo sullo spazio dei nomi dell'applicazione:

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

   Viene applicata una patch a ogni spazio dei nomi etichettato come ConfigMap.

4. Controlla lo stato delle risorse nella tua infrastruttura Redis nello spazio dei nomi rec-ns:

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

   L'output è simile al seguente:

   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
   

Esegui il deployment dei database Redis Enterprise

1. Crea database Redis Enterprise negli spazi dei nomi dell'applicazione:

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

2. Controlla lo stato di REDB:

   kubectl get redb --all-namespaces
   

   L'output è simile al seguente:

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

3. Verifica che i servizi per ogni REDB siano in esecuzione:

   kubectl get svc --all-namespaces
   

   L'output è simile al seguente:

   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. Verifica che il secret sia stato creato:

   kubectl get secrets -n application
   

   L'output è simile al seguente:

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

Autenticarsi utilizzando le password

Puoi connetterti a REDB utilizzando un pod con redis-cli nello spazio dei nomi dell'applicazione. Il pod client utilizza i secret disponibili nello spazio dei nomi dell'applicazione (REDB) per stabilire una connessione.

I database creati con la risorsa personalizzata REDB supportano solo l'autenticazione con password senza ACL.

1. Crea il pod client:

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

2. Connettiti al pod client:

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

3. Connettiti al database:

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

4. Crea una chiave:

   SET mykey "Hello World"
   

   L'output è simile al seguente:

   OK
   

5. Recupera la chiave:

   GET mykey
   

   L'output è simile al seguente:

   "Hello World"
   

6. Esci dalla shell del pod

   exit
   

Scopri come Prometheus raccoglie le metriche per il tuo cluster Redis

Il seguente diagramma mostra come funziona la raccolta delle metriche Prometheus:

Nel diagramma, un cluster GKE privato contiene:

• Un pod Redis che raccoglie metriche sul percorso / e sulla porta 8070
• Raccoglitori basati su Prometheus che elaborano le metriche del pod Redis
• Una risorsa PodMonitoring che invia metriche a Cloud Monitoring

L'operatore Redis Enterprise espone le metriche del cluster nel formato Prometheus.

1. Crea il deployment metrics-proxy:

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

   Poiché l'operatore fornisce solo un endpoint HTTPS con il certificato autofirmato e la risorsa PodMonitoring non supporta la disattivazione della verifica del certificato TLS, utilizzi il pod metrics-proxy come proxy inverso per questo endpoint per esporre le metriche sulla porta HTTP.

2. Crea la risorsa PodMonitoring per estrarre le metriche in base a labelSelector:

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

3. Nella console Google Cloud , vai alla pagina Dashboard dei cluster GKE.

   Vai alla dashboard dei cluster GKE

   La dashboard mostra il tasso di importazione delle metriche diverse da zero.

Creare una dashboard

Puoi visualizzare le metriche creando una dashboard.

1. Crea la dashboard:

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

   L'output è simile al seguente:

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

2. Nella console Google Cloud , vai alla pagina Dashboard.

   Accedi a Dashboard

3. Apri la dashboard del cluster Redis Enterprise. Potrebbero essere necessari diversi minuti prima che la dashboard venga sottoposta al provisioning automatico.

Verificare le metriche esportate

Per verificare le metriche, crea un nuovo database ed esamina le metriche.

1. Apri la dashboard del cluster Redis Enterprise.

2. Crea un database Redis aggiuntivo:

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

   Il Conteggio database nella dashboard dovrebbe essere aggiornato.

3. Crea un pod client per connetterti al nuovo database:

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

4. Connettiti al pod client e prepara le variabili:

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

5. Utilizza lo strumento redis-cli per creare nuove chiavi:

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

6. Aggiorna la pagina e osserva che i grafici sono stati aggiornati per mostrare lo stato effettivo del database.

7. Esci dalla shell del pod

   exit