Desplegar Redis en GKE con Redis Enterprise

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

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

Redis Enterprise es una solución de nivel empresarial que amplía el código abierto de Redis con una gestión simplificada que incluye la distribución de datos replicados geográficamente, el escalado lineal del rendimiento de las operaciones, la estratificación de datos, funciones de seguridad avanzadas y más.

Redis Enterprise tiene precios diferentes para cada opción de implementación, incluidas las siguientes: Software, Cloud o Híbrida y multicloud.

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

Configurar un entorno

En este tutorial, usarás Cloud Shell para gestionar los recursos alojados enGoogle Cloud. Cloud Shell tiene preinstalado el software que necesitas para este tutorial, como kubectl, la CLI de gcloud y Terraform.

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

  1. Inicia una sesión de Cloud Shell desde la Google Cloud consolaIcono de activación de Cloud Shell haciendo clic en Activar Cloud Shell en la Google Cloud consola. Se iniciará una sesión en el panel inferior de la consola Google Cloud .

  2. Define las variables de entorno:

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

    Sustituye PROJECT_ID: your Google Cloud por tu ID de 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

Crear la infraestructura del clúster

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

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

Para desplegar 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. Este comando puede tardar varios minutos en completarse y el clúster en mostrar el estado "Listo".

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 el autoescalado habilitado (de uno a dos nodos por zona, con un mínimo de un nodo por zona)

El resultado debería ser similar al siguiente:

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

Conéctate al clúster

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

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

Desplegar el operador de Redis Enterprise en tu clúster

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

  1. Crea espacios de nombres para el 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 última versión del paquete del operador de Redis Enterprise:

    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 debería ser 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

Desplegar un clúster de Redis Enterprise

  1. Aplica el manifiesto a tu clúster:

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

    El comando puede tardar varios minutos en completarse.

  2. Comprueba el estado del despliegue de REC:

    kubectl get rec -n rec-ns

    El resultado debería ser 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 estará listo cuando STATE sea RUNNING.

Opcional: Configurar el controlador de admisión

También 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 comprueba si el secreto 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. Verifica el controlador de admisión creando una base de datos no funcional:

    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 debería ser 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']

Crear espacios de nombres

De forma predeterminada, el operador de Redis Enterprise no tiene privilegios para realizar acciones fuera de su propio espacio de nombres. Para permitir que el operador de Redis Enterprise cree endpoints de REDB y de bases de datos en otros espacios de nombres, debe configurar el control de acceso basado en roles (RBAC).

  1. Aplica el rol y la vinculación de roles 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 un enlace 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 añadir 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

    Se aplica un parche a cada espacio de nombres etiquetado como ConfigMap.

  4. Consulta el estado de los recursos de 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 debería ser 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

Desplegar 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. Comprueba el estado de REDB:

    kubectl get redb --all-namespaces

    El resultado debería ser 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 servicios de cada REDB se estén ejecutando:

    kubectl get svc --all-namespaces

    El resultado debería ser 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 se haya creado el secreto:

    kubectl get secrets -n application

    El resultado debería ser similar al siguiente:

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

Autenticarse con contraseñas

Puedes conectarte a REDB mediante un pod con redis-cli en el espacio de nombres de la aplicación. El pod del cliente usa los secretos disponibles en el espacio de nombres de la aplicación (REDB) para establecer una conexión.

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

  1. Crea el pod del cliente:

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

  2. Conéctate al pod del 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. Para crear una clave, sigue estos pasos:

    SET mykey "Hello World"

    El resultado debería ser similar al siguiente:

    OK

  5. Obtén la clave:

    GET mykey

    El resultado debería ser similar al siguiente:

    "Hello World"

  6. Salir del shell del pod

    exit

Información sobre cómo recoge Prometheus las métricas de tu clúster de Redis

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

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

  • Un pod de Redis que recoge métricas en la ruta / y el puerto 8070
  • Recogedores 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 Prometheus.

  1. Crea el Deployment metrics-proxy:

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

    Como el operador solo proporciona un endpoint HTTPS con el certificado autofirmado y el recurso PodMonitoring no admite la inhabilitación de la verificación del certificado TLS, se usa el pod metrics-proxy como proxy inverso de este endpoint para exponer las métricas en el puerto HTTP.

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

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

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

    Ir al panel de control de clústeres de GKE

    En el panel de control se muestra la tasa de ingestión de métricas distintas de cero.

Crear un panel de control

Para ver las métricas, crea un panel de control.

  1. Crea el panel de control:

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

    El resultado debería ser similar al siguiente:

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

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

    Ir a Paneles

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

Verificar las métricas exportadas

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

  1. Abre el panel de control de Redis Enterprise Cluster.

  2. Crea una base de datos Redis adicional:

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

    El valor de Número de bases de datos del panel de control debería actualizarse.

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

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

  4. Conéctate al pod del cliente y prepara las variables:

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

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

    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 han actualizado para mostrar el estado real de la base de datos.

  7. Salir del shell del pod

    exit