La guida mostra come eseguire il deployment di Redis Enterprise nei cluster Google Kubernetes Engine (GKE).
Redis è un database NoSQL in memoria open source utilizzato principalmente per la memorizzazione nella cache. Dispone di replica integrata, scripting Lua, rimozione LRU, transazioni, persistenza su disco e alta disponibilità.
Redis Enterprise è una soluzione di livello aziendale che estende l'open source Redis con una gestione semplificata, tra cui la distribuzione dei dati con replica geografica, la scalabilità lineare del throughput delle operazioni, il tiering dei dati, funzionalità di sicurezza avanzate e altro ancora.
Redis Enterprise ha prezzi diversi per ogni opzione di deployment, tra cui: Software, Cloud o ibrido e multicloud.
Questa guida è destinata ad amministratori di piattaforme, architetti cloud e professionisti delle operazioni interessati al deployment di Redis Enterprise su Google Kubernetes Engine (GKE).
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, gcloud CLI e Terraform.
Per configurare l'ambiente con Cloud Shell:
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 .Imposta le variabili di ambiente:
export PROJECT_ID=PROJECT_ID export KUBERNETES_CLUSTER_PREFIX=redis export REGION=us-central1Sostituisci
PROJECT_ID: il tuo Google Cloud con il tuo ID progetto.Clona il repository GitHub:
git clone https://github.com/GoogleCloudPlatform/kubernetes-engine-samplesPassa 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 questi 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.
Crea spazi dei nomi per il REC e le relative applicazioni:
kubectl create namespace rec-ns kubectl create namespace applicationEtichetta gli spazi dei nomi:
kubectl label namespace rec-ns connection=redis kubectl label namespace application connection=redisScarica 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}'`Installa l'operatore Redis Enterprise:
kubectl apply -n rec-ns -f https://raw.githubusercontent.com/RedisLabs/redis-enterprise-k8s-docs/$VERSION/bundle.yamlL'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
Applica il manifest al cluster:
kubectl apply -n rec-ns -f manifests/01-basic-cluster/rec.yamlIl completamento di questo comando potrebbe richiedere diversi minuti.
Controlla lo stato del deployment di REC:
kubectl get rec -n rec-nsL'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 4m7sIl 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.
Configura il controller di ammissione e controlla se il secret TLS di ammissione è presente:
kubectl get secret admission-tls -n rec-nsOttenere il certificato:
export CERT=$(kubectl get secret admission-tls -n rec-ns -o jsonpath='{.data.cert}')Copia il certificato nel file
webhook.yaml:sed -i -e 's/CRT/'$CERT'/g' manifests/01-basic-cluster/webhook.yamlEsegui il deployment del webhook di convalida:
sed -i -e 's/CRT/'$CERT'/g' manifests/01-basic-cluster/webhook.yamlIl controller di ammissione convalida la sintassi del database negli spazi dei nomi etichettati.
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 EOFL'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 il controllo dell'accesso basato sui ruoli (RBAC).
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 applicationCrea 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.yamlModifica 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-nsViene applicata una patch a ogni spazio dei nomi etichettato come ConfigMap.
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-nsL'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
Crea database Redis Enterprise negli spazi dei nomi dell'applicazione:
kubectl apply -f manifests/01-basic-cluster/a-rdb.yaml -n applicationControlla lo stato di REDB:
kubectl get redb --all-namespacesL'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 15sVerifica che i servizi per ogni REDB siano in esecuzione:
kubectl get svc --all-namespacesL'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 72mVerifica che il secret sia stato creato:
kubectl get secrets -n applicationL'output è simile al seguente:
NAME TYPE DATA AGE redb-app-db Opaque 3 96m
Esegui l'autenticazione usando 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.
Crea il pod client:
kubectl apply -n application -f manifests/03-auth/client_pod.yamlConnettiti al pod client:
kubectl exec -n application -i -t redis-client -c redis-client -- /bin/shConnettiti al database:
redis-cli -h $SERVICE -p $PORT --pass $PASSCrea una chiave:
SET mykey "Hello World"L'output è simile al seguente:
OKRecupera la chiave:
GET mykeyL'output è simile al seguente:
"Hello World"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 porta8070 - Raccoglitori basati su Prometheus che elaborano le metriche del pod Redis
- Una risorsa
PodMonitoringche invia metriche a Cloud Monitoring
L'operatore Redis Enterprise espone le metriche del cluster in formato Prometheus.
Crea il deployment metrics-proxy:
kubectl apply -n rec-ns -f manifests/02-prometheus-metrics/metrics-proxy.yamlPoiché l'operatore fornisce solo un endpoint HTTPS con il certificato autofirmato e la risorsa
PodMonitoringnon supporta la disattivazione della verifica del certificato TLS, utilizzi il podmetrics-proxycome proxy inverso per questo endpoint per esporre le metriche sulla porta HTTP.Crea la risorsa PodMonitoring per estrarre le metriche in base a
labelSelector:kubectl apply -n rec-ns -f manifests/02-prometheus-metrics/pod-monitoring.yamlNella console Google Cloud , vai alla pagina Dashboard 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.
Crea la dashboard:
gcloud --project "${PROJECT_ID}" monitoring dashboards create --config-from-file monitoring/dashboard.jsonL'output è simile al seguente:
Created [f4efbe4e-2605-46b4-9910-54b13d29b3be].Nella console Google Cloud , vai alla pagina Dashboard.
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.
Apri la dashboard del cluster Redis Enterprise.
Crea un database Redis aggiuntivo:
kubectl apply -n rec-ns -f manifests/02-prometheus-metrics/c-rdb.yamlIl Conteggio database nella dashboard dovrebbe essere aggiornato.
Crea un pod client per connetterti al nuovo database:
kubectl apply -n rec-ns -f manifests/02-prometheus-metrics/client_pod.yamlConnettiti al pod client e prepara le variabili:
kubectl exec -it redis-client-c -n rec-ns -- /bin/bashUtilizza lo strumento
redis-cliper 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"; \ doneAggiorna la pagina e osserva che i grafici sono stati aggiornati per mostrare lo stato effettivo del database.
Esci dalla shell del pod
exit