Implementa Redis en GKE con Redis Enterprise

Estándar

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

Objetivos

Planificar y, además, implementar la infraestructura de GKE para Redis
Implementar el operador de Redis Enterprise
Implementar Redis Enterprise Cluster
Crear una base de datos de Redis Enterprise
Demostrar la autenticación de bases de datos

Ventajas

Redis Enterprise ofrece los siguientes beneficios:

Una forma nativa de Kubernetes de administrar el ciclo de vida de Redis Enterprise Cluster (REC) y las bases de datos de Redis Enterprise (REDB)
Uso de recursos a través de la ubicación conjunta de varias bases de datos de Redis dentro de un solo Pod de Kubernetes
Reducción de la sobrecarga operativa a través del control de las tareas de mantenimiento de rutina, como la aplicación de parches y las actualizaciones
Compatibilidad con imágenes de software de Redis de registros de contenedores privados, como Artifact Registry, para mejorar la seguridad y la disponibilidad de los contenedores
Asistencia para Google Cloud Managed Service para Prometheus para la supervisión y la observabilidad de la base de datos
Funciones de seguridad mejoradas, como la encriptación, los controles de acceso y la integración con el RBAC (control de acceso basado en roles) de Kubernetes
Métodos de autenticación avanzada, lo que incluye LDAP y administradores de credenciales de terceros como Vault
Capacidad de configurar copias de seguridad programadas

Arquitectura de implementación

Redis Enterprise administra los siguientes recursos de Kubernetes:

El clúster de Enterprise y su configuración en un StatefulSet. El clúster consta de nodos de Redis (Pods) con paquetes de Redis instalados. Estos nodos tienen procesos en ejecución para garantizar que el nodo sea parte de un clúster. Cada nodo proporciona un contenedor para ejecutar varias instancias de base de datos (fragmentos). Aunque las prácticas recomendadas de Kubernetes indican que un Pod debe representar una aplicación con un contenedor, Redis Enterprise implementa varias bases de datos de Redis en un solo contenedor. Este enfoque proporciona un mejor uso de los recursos, rendimiento y capacidad de procesamiento de red. Cada contenedor también tiene un proxy de latencia cero para enrutar y administrar el tráfico a procesos específicos de bases de datos de Redis dentro de un contenedor.
El recurso personalizado RedisEnterpriseDatabase (REDB) que representa las instancias de bases de datos de Redis creadas dentro de REC
Los objetos Service de Kubernetes que entregan instancias de REDB como extremos de base de datos
Un Pod del controlador llamado Service Rigger que crea y borra extremos de base de datos cuando se crea o borra una base de datos

En este instructivo, crearás una implementación de uno a varios a través de la implementación de un REC en un espacio de nombres dedicado y el uso de espacios de nombres separados para implementaciones de aplicaciones para obtener un mejor aislamiento.

En el siguiente diagrama, se describen los componentes de Redis Enterprise y cómo se interconectan:

En el diagrama, se muestra un ejemplo de arquitectura de Redis Enterprise. — **Figura 1**: ejemplo de arquitectura de Redis Enterprise.

En este instructivo, configurarás Redis Enterprise Cluster para que tenga alta disponibilidad. Para ello, REC requiere una cantidad impar de nodos y un mínimo de tres nodos. También configurarás reglas de afinidad, antiafinidad y taints de nodo que garanticen que cada nodo de Redis se coloque en un nodo de Kubernetes diferente y que los nodos de Redis se distribuyan de manera uniforme en el clúster de Kubernetes.

El uso de múltiples nodos y zonas es fundamental para lograr un clúster de GKE con alta disponibilidad por los siguientes motivos:

Tolerancia a errores: varios nodos distribuyen la carga de trabajo en el clúster y garantizan que, si un nodo falla, los otros puedan tomar el control de las tareas, lo que evita el tiempo de inactividad y las interrupciones del servicio.
Escalabilidad: tener varios nodos permite el escalamiento horizontal, ya que se agregan o quitan nodos según sea necesario, lo que garantiza una asignación de recursos óptima y adapta el aumento del tráfico o las demandas de carga de trabajo.
Alta disponibilidad: usar varias zonas dentro de una región garantiza la redundancia y minimiza el riesgo de un punto único de fallo. Si una zona de disponibilidad completa experimenta una interrupción, el clúster puede seguir ejecutándose en otras zonas y mantener la disponibilidad del servicio.
Redundancia geográfica: cuando se cubren los nodos en todas las regiones, los datos y los servicios del clúster se distribuyen geográficamente, lo que proporciona resiliencia ante desastres naturales, interrupciones de energía y otras interrupciones locales que podrían afectar a una sola zona.
Actualizaciones y mantenimiento progresivos: cuando usas varios nodos, puedes realizar actualizaciones y mantenimiento progresivas en nodos individuales sin afectar la disponibilidad general del clúster. Esto garantiza un servicio continuo, al tiempo que te permite realizar las actualizaciones necesarias y aplicar parches sin problemas.
Acuerdos de Nivel de Servicio (ANS): Google Cloud proporciona ANS para implementaciones multizona, lo que garantiza un nivel mínimo de tiempo de actividad y disponibilidad.

Costos

En este documento, usarás los siguientes componentes facturables de Google Cloud:

Para generar una estimación de costos en función del uso previsto, usa la calculadora de precios. Es posible que los usuarios nuevos de Google Cloud califiquen para obtener una prueba gratuita.

Cuando finalices las tareas que se describen en este documento, puedes borrar los recursos que creaste para evitar que continúe la facturación. Para obtener más información, consulta Cómo realizar una limpieza.

Antes de comenzar

Sign in to your Google Cloud account. If you're new to Google Cloud, create an account to evaluate how our products perform in real-world scenarios. New customers also get $300 in free credits to run, test, and deploy workloads.

Install the Google Cloud CLI.

To initialize the gcloud CLI, run the following command:

gcloud init

Note: If you installed the gcloud CLI previously, make sure you have the latest version by running

gcloud components
      update

Create or select a Google Cloud project.

Create a Google Cloud project:
```
gcloud projects create PROJECT_ID
```
Replace PROJECT_ID with a name for the Google Cloud project you are creating.
Select the Google Cloud project that you created:
```
gcloud config set project PROJECT_ID
```
Replace PROJECT_ID with your Google Cloud project name.

Make sure that billing is enabled for your Google Cloud project.

Enable the Compute Engine, IAM, GKE, and Resource Manager APIs:

gcloud services enable compute.googleapis.com iam.googleapis.com container.googleapis.com cloudresourcemanager.googleapis.com

Install the Google Cloud CLI.

To initialize the gcloud CLI, run the following command:

gcloud init

Note: If you installed the gcloud CLI previously, make sure you have the latest version by running

gcloud components
      update

Create or select a Google Cloud project.

Create a Google Cloud project:
```
gcloud projects create PROJECT_ID
```
Replace PROJECT_ID with a name for the Google Cloud project you are creating.
Select the Google Cloud project that you created:
```
gcloud config set project PROJECT_ID
```
Replace PROJECT_ID with your Google Cloud project name.

Make sure that billing is enabled for your Google Cloud project.

Enable the Compute Engine, IAM, GKE, and Resource Manager APIs:

gcloud services enable compute.googleapis.com iam.googleapis.com container.googleapis.com cloudresourcemanager.googleapis.com

Grant roles to your user account. Run the following command once for each of the following IAM roles: roles/compute.securityAdmin, roles/compute.viewer, roles/container.clusterAdmin, roles/container.admin, roles/iam.serviceAccountAdmin, roles/iam.serviceAccountUser
```
gcloud projects add-iam-policy-binding PROJECT_ID --member="user:USER_IDENTIFIER" --role=ROLE
```
- Replace PROJECT_ID with your project ID.
- Replace USER_IDENTIFIER with the identifier for your user account. For example, user:myemail@example.com.
- Replace ROLE with each individual role.

Configura tu entorno

En este instructivo, usarás Cloud Shell para administrar recursos alojados en Google Cloud. Cloud Shell tiene preinstalado el software que necesitas para este instructivo, lo que incluye kubectl, gcloud CLI y Terraform.

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

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

Establece las variables de entorno:

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

Reemplaza PROJECT_ID por tu Google Cloud con el ID del proyecto.

Clona el repositorio de GitHub:

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

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 --region ${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.

Crea espacios de nombres para REC y sus aplicaciones:

kubectl create namespace rec-ns
kubectl create namespace application

Etiqueta los espacios de nombres:

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

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

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

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.

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.

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
```

Obtén el certificado:

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

Copia el certificado en el archivo webhook.yaml:

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

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.

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.

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

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

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.

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

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
```

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

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

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

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.

Crea el Pod del cliente:

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

Conéctate al Pod cliente:

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

Conéctate a la base de datos:

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

Crea una clave:
```
SET mykey "Hello World"
```
El resultado es similar al siguiente:
```
OK
```
Obtén la clave:
```
GET mykey
```
El resultado es similar al siguiente:
```
"Hello World"
```
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.

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.

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

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

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.

Crea el panel:

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

El resultado es similar al siguiente:

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

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

Ir a Paneles
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.

Abre el panel de Redis Enterprise Cluster.
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.

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

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

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

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

Actualiza la página y observa que los gráficos se actualizaron para mostrar el estado real de la base de datos.
Sal de la shell del Pod
```
exit
```

Realiza una limpieza

Borra el proyecto

Precaución: Borrar un proyecto tiene las siguientes consecuencias:

Se borra todo en el proyecto. Si usaste un proyecto existente para las tareas de este documento, cuando lo borres, también se borrará cualquier otro trabajo que hayas realizado en el proyecto.
Se pierden los ID personalizados de proyectos. Cuando creaste este proyecto, es posible que hayas creado un ID del proyecto personalizado que desees utilizar en el futuro. Para conservar las URL que utilizan el ID del proyecto, como una URL appspot.com, borra los recursos seleccionados dentro del proyecto en lugar de borrar todo el proyecto.

Si planeas explorar varias infraestructuras, instructivos y guías de inicio rápido la reutilización de proyectos puede ayudarte a evitar exceder los límites de las cuotas del proyecto.

Delete a Google Cloud project:

gcloud projects delete PROJECT_ID

Borra los recursos individuales

Configurar variables de entorno

export PROJECT_ID=${PROJECT_ID}
export KUBERNETES_CLUSTER_PREFIX=redis
export REGION=us-central1

Ejecuta el comando terraform destroy:

export GOOGLE_OAUTH_ACCESS_TOKEN=$(gcloud auth print-access-token)
cd terraform/gke-standard
terraform destroy -var project_id=${PROJECT_ID}   \
  -var region=${REGION}  \
  -var cluster_prefix=${KUBERNETES_CLUSTER_PREFIX}

Cuando se te solicite, escribe yes.

Busca todos los discos no conectados:

export disk_list=$(gcloud compute disks list --filter="-users:* AND labels.name=${KUBERNETES_CLUSTER_PREFIX}-cluster" --format "value[separator=|](name,zone)")

Borra los discos:

for i in $disk_list; do
  disk_name=$(echo $i| cut -d'|' -f1)
  disk_zone=$(echo $i| cut -d'|' -f2|sed 's|.*/||')
  echo "Deleting $disk_name"
  gcloud compute disks delete $disk_name --zone $disk_zone --quiet
done

Borra el repositorio de GitHub
```
rm -r ~/kubernetes-engine-samples/
```

¿Qué sigue?

Explora arquitecturas de referencia, diagramas y prácticas recomendadas sobre Google Cloud. Consulta nuestro Cloud Architecture Center.

Implementa Redis en GKE con Redis Enterprise

Objetivos

Ventajas

Arquitectura de implementación

Costos

Antes de comenzar

Configura tu entorno

Crea la infraestructura del clúster

Conéctate al clúster

Implementa el operador de Redis Enterprise en tu clúster

Implementa Redis Enterprise Cluster

Opcional: Configura el controlador de admisión

Crea espacios de nombres

Implementa bases de datos de Redis Enterprise

Autentica a través de contraseñas

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

Crea un panel

Verifica las métricas exportadas

Realiza una limpieza

Borra el proyecto

Borra los recursos individuales

¿Qué sigue?