Implementa Redis en GKE con Redis Enterprise

En la guía, se muestra cómo implementar Redis Enterprise en clústeres de Google Kubernetes Engine (GKE).

Redis es una base de datos NoSQL en la memoria de código abierto que se usa principalmente para el almacenamiento en caché. Tiene replicación integrada, secuencias de comandos de Lua, expulsión de LRU, transacciones, persistencia en el disco y alta disponibilidad.

Redis Enterprise es una solución de nivel empresarial que extiende el código abierto de Redis con administración simplificada, lo que incluye la distribución de datos con replicación geográfica, el escalamiento lineal de la capacidad de procesamiento de las operaciones, los niveles de datos, las funciones de seguridad avanzadas y mucho más.

Redis Enterprise tiene precios diferentes para cada opción de implementación, incluidos los siguientes: Software, Cloud o Nube híbrida y múltiple.

Esta guía está dirigida a administradores de plataformas, arquitectos de nube y profesionales de operaciones interesados en implementar Redis Enterprise en Google Kubernetes Engine (GKE).

Nota: Redis Enterprise Software distribuido bajo una licencia de Redis Enterprise y las restricciones de licencia requieren que los usuarios tengan una suscripción activa después de una prueba de 30 días para seguir usando Redis Enterprise.

Configura tu entorno

En este instructivo, usarás Cloud Shell para administrar recursos alojados enGoogle Cloud. Cloud Shell tiene preinstalado el software que necesitas para este instructivo, incluidos kubectl, la CLI de gcloud y Terraform.

Para configurar tu entorno con Cloud Shell, sigue estos pasos:

1. Para iniciar una sesión de Cloud Shell desde la Google Cloud consola, haz clic en Activar Cloud Shell en la Google Cloud consola. Esto inicia una sesión en el panel inferior de la consola de Google Cloud .

2. Establece las variables de entorno:

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

   Reemplaza PROJECT_ID: tu Google Cloud por tuID del proyecto.

3. Clona el repositorio de GitHub:

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

4. Cambia al directorio de trabajo:

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

Crea la infraestructura del clúster

En esta sección, ejecutarás una secuencia de comandos de Terraform para crear un clúster de GKE regional, con alta disponibilidad y privado, y una VPC.

En el siguiente diagrama, se muestra un clúster de GKE estándar regional privado implementado en tres zonas diferentes:

Para implementar esta infraestructura, ejecuta los siguientes comandos desde 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}

Cuando se te solicite, escribe yes. Es posible que este comando tarde varios minutos en completarse y que el clúster muestre un estado de preparación.

Terraform crea los siguientes recursos:

• Una red de VPC y una subred privada para los nodos de Kubernetes
• Un router para acceder a Internet a través de NAT
• Un clúster de GKE privado en la región us-central1
• Un grupo de nodos con ajuste de escala automático habilitado (de uno a dos nodos por zona y un nodo por zona como mínimo)

El resultado es similar al siguiente:

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

Conéctate al clúster

Usantod Cloud Shell, configura kubectl para que se comunique con el clúster:

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

Implementa el operador de Redis Enterprise en tu clúster

En esta sección, debes implementar el operador de Redis Enterprise en tu clúster de Kubernetes.

1. Crea espacios de nombres para REC y sus aplicaciones:

   kubectl create namespace rec-ns
   kubectl create namespace application
   

2. Etiqueta los espacios de nombres:

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

3. Obtén la versión más reciente del paquete de 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. Instala el operador de Redis Enterprise:

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

   El resultado es similar al siguiente:

   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
   

Implementa Redis Enterprise Cluster

1. Aplica el manifiesto al clúster:

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

   El comando puede tardar varios minutos en completarse.

2. Verifica el estado de la implementación de REC:

   kubectl get rec -n rec-ns
   

   El resultado es similar al siguiente:

   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
   

   El clúster está listo cuando STATE está en RUNNING.

Opcional: Configura el controlador de admisión

De forma opcional, puedes configurar la infraestructura para la validación de la base de datos en la implementación.

1. Configura el controlador de admisión y verifica si el Secret de tls de admisión está presente:

   kubectl get secret admission-tls -n rec-ns
   

2. Obtén el certificado:

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

3. Copia el certificado en el archivo webhook.yaml:

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

4. Implementa el webhook de validación:

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

   El controlador de admisión valida la sintaxis de la base de datos en los espacios de nombres etiquetados.

5. Crea una base de datos no funcional para verificar el controlador de admisión:

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

   El resultado es similar al siguiente:

   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 espacios de nombres

De forma predeterminada, Redis Enterprise Operator no tiene privilegios para realizar acciones fuera de su propio espacio de nombres. Para permitir que Redis Enterprise Operator cree extremos de REDB y base de datos en otros espacios de nombres, debes configurar RBAC.

1. Aplica el rol y la vinculación de rol correspondientes en el espacio de nombres de la aplicación:

   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 un rol de clúster y una vinculación de rol de clúster en el espacio de nombres 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. Edita el ConfigMap de REC para agregar control sobre el espacio de nombres de la aplicación:

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

   Cada espacio de nombres etiquetado como ConfigMap tiene un parche.

4. Verifica el estado de los recursos en tu infraestructura de Redis en el espacio de nombres rec-ns.

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

   El resultado es similar al siguiente:

   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
   

Implementa bases de datos de Redis Enterprise

1. Crea bases de datos de Redis Enterprise en los espacios de nombres de la aplicación:

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

2. Verifica el estado de REDB:

   kubectl get redb --all-namespaces
   

   El resultado es similar al siguiente:

   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 que los objetos Service para cada REDB estén en ejecución:

   kubectl get svc --all-namespaces
   

   El resultado es similar al siguiente:

   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 que el Secret se haya creado:

   kubectl get secrets -n application
   

   El resultado es similar al siguiente:

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

Autentica a través de contraseñas

Puedes conectarte a REDB a través de un Pod con redis-cli en el espacio de nombres de la aplicación. El Pod del cliente usa los objetos Secret disponibles en el espacio de nombres de la aplicación (REDB) para establecer una conexión.

Las bases de datos creadas con el REDB de recurso personalizado solo admiten la autenticación de contraseña sin LCA.

1. Crea el Pod del cliente:

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

2. Conéctate al Pod cliente:

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

3. Conéctate a la base de datos:

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

4. Crea una clave:

   SET mykey "Hello World"
   

   El resultado es similar al siguiente:

   OK
   

5. Obtén la clave:

   GET mykey
   

   El resultado es similar al siguiente:

   "Hello World"
   

6. Sal de la shell del Pod

   exit
   

Comprende cómo Prometheus recopila métricas para tu clúster de Redis

En el siguiente diagrama, se muestra cómo funciona la recopilación de métricas de Prometheus:

En el diagrama, un clúster privado de GKE contiene lo siguiente:

• Un Pod de Redis que recopila métricas en la ruta de acceso / y el puerto 8070
• Recopiladores basados en Prometheus que procesan las métricas del Pod de Redis
• Un recurso PodMonitoring que envía métricas a Cloud Monitoring

El operador de Redis Enterprise expone las métricas del clúster en formato de Prometheus.

1. Crea la implementación del proxy de métricas:

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

   Debido a que el operador solo proporciona un extremo HTTPS con el certificado autofirmado y el recurso PodMonitoring no admite la inhabilitación de la verificación de certificados TLS, debes usar el Pod metrics-proxy como un proxy inverso para que este extremo exponga las métricas en el puerto HTTP.

2. Crea el recurso PodMonitoring para extraer métricas por labelSelector:

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

3. En la consola de Google Cloud , ve a la página Panel de clústeres de GKE.

   Ir al Panel de clústeres de GKE

   En el panel, se muestra una tasa de transferencia de métricas distinta de cero.

Crea un panel

Para ver las métricas, crea un panel.

1. Crea el panel:

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

   El resultado es similar a este:

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

2. En la consola de Google Cloud , ve a la página Paneles.

   Ir a Paneles

3. Abre el panel de Redis Enterprise Cluster. El panel puede tardar varios minutos en aprovisionarse de forma automática.

Verifica las métricas exportadas

Para verificar las métricas, crea una base de datos nueva y examina las métricas.

1. Abre el panel de Redis Enterprise Cluster.

2. Crea una base de datos adicional de Redis:

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

   El recuento de bases de datos en el panel debería actualizarse.

3. Crea un Pod de cliente para conectarte a la base de datos nueva:

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

4. Conéctate al Pod de cliente y prepara las variables:

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

5. Usa la herramienta de redis-cli para crear claves nuevas:

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

6. Actualiza la página y observa que los gráficos se actualizaron para mostrar el estado real de la base de datos.

7. Sal de la shell del Pod

   exit