Implantar o Redis no GKE usando o Redis Enterprise

O guia mostra como implantar o Redis Enterprise nos clusters do Google Kubernetes Engine (GKE).

O Redis é um banco de dados NoSQL na memória de código aberto usado principalmente para armazenamento em cache. Ele tem replicação integrada, scripting Lua, remoção de LRU, transações, persistência no disco e alta disponibilidade.

Além disso, é uma solução de nível empresarial que estende o código aberto do Redis com gerenciamento simplificado, incluindo distribuição de dados replicados geograficamente, escalonamento linear de capacidade de operações, níveis de dados, recursos avançados de segurança e muito mais.

O Redis Enterprise tem preços diferentes para cada opção de implantação, incluindo: Software, Nuvem ou Híbrido e Multicloud.

Este guia é destinado a administradores de plataformas, arquitetos de nuvem e profissionais de operações interessados em implantar o Redis Enterprise no Google Kubernetes Engine (GKE).

Observação: o software Redis Enterprise é distribuído sob licença da Redis Enterprise, e as restrições de licença exigem que os usuários tenham uma assinatura ativa após um período de teste de 30 dias, para continuar usando o Redis Enterprise.

Configurar o ambiente

Neste tutorial, você vai usar o Cloud Shell para gerenciar recursos hospedados no Google Cloud. O Cloud Shell vem pré-instalado com o software necessário para este tutorial, incluindo kubectl, a gcloud CLI e o Terraform.

Para configurar o ambiente com o Cloud Shell, siga estas etapas:

1. Inicie uma sessão do Cloud Shell no console do Google Cloud clicando em Ativar o Cloud Shell no console doGoogle Cloud . Isso inicia uma sessão no painel inferior do console Google Cloud .

2. Defina as variáveis de ambiente:

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

   Substitua PROJECT_ID: seu Google Cloud pelo ID do projeto.

3. Clone o repositório do GitHub:

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

4. Mude para o diretório de trabalho:

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

Criar a infraestrutura do cluster

Nesta seção, você executará um script do Terraform para criar um cluster do GKE e uma VPC privada e altamente disponível.

O diagrama a seguir mostra um cluster regional padrão particular do GKE implantado em três zonas diferentes:

Para implantar essa infraestrutura, execute os seguintes comandos no 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 solicitado, digite yes. Pode levar vários minutos para que esse comando seja concluído e o cluster mostre um status pronto.

O Terraform cria os seguintes recursos:

• Uma rede VPC e uma sub-rede particular para os nós do Kubernetes.
• Um roteador para acessar a Internet usando NAT.
• Um cluster particular do GKE na região us-central1.
• Um pool de nós com escalonamento automático ativado (de um a dois nós por zona, no mínimo um nó por zona)

O resultado será assim:

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

Conexão ao cluster

Usando o Cloud Shell, configure kubectl para se comunicar com o cluster:

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

Implantar o operador Redis Enterprise no seu cluster

Nesta seção, você implantará o operador Redis Enterprise no seu cluster do Kubernetes.

1. Crie namespaces para o REC e os aplicativos dele:

   kubectl create namespace rec-ns
   kubectl create namespace application
   

2. Rotule os namespaces:

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

3. Obtenha a versão mais recente do pacote do operador 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. Instale o operador Redis Enterprise:

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

   O resultado será assim:

   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
   

Implantar o cluster do Redis Enterprise

1. Aplique o manifesto ao cluster:

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

   O comando pode levar alguns minutos para ser concluído.

2. Verifique o status da implantação do REC:

   kubectl get rec -n rec-ns
   

   O resultado será assim:

   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
   

   O cluster estará pronto quando STATE for RUNNING.

Opcional: configurar o controlador de admissão

Se quiser, é possível configurar a infraestrutura para a validação do banco de dados na implantação.

1. Configure o controlador de admissão e verifique se o Secret tls de admissão está presente:

   kubectl get secret admission-tls -n rec-ns
   

2. Obtenha o certificado:

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

3. Copie o certificado no arquivo webhook.yaml:

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

4. Implante o webhook de validação:

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

   O controlador de admissão valida a sintaxe do banco de dados em namespaces rotulados.

5. Verifique o controlador de admissão criando um banco de dados não funcional:

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

   O resultado será assim:

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

Criar namespaces

Por padrão, o operador Redis Enterprise não tem privilégios para executar ações fora do próprio namespace. Para permitir que o operador Redis Enterprise crie endpoints de banco de dados e REDB em outros namespaces, configure o RBAC.

1. Aplique o papel e a vinculação de papel correspondentes no namespace do aplicativo:

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

2. Crie um papel de cluster e uma vinculação de papel de cluster no namespace 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. Edite o REC ConfigMap para adicionar controle sobre o namespace do aplicativo:

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

   Cada namespace rotulado como ConfigMap recebe um patch.

4. Verifique o status dos recursos na infraestrutura do Redis no namespace rec-ns:

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

   O resultado será assim:

   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
   

Implantar bancos de dados Redis Enterprise

1. Crie bancos de dados Redis Enterprise nos namespaces do aplicativo:

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

2. Verifique o status de REDB:

   kubectl get redb --all-namespaces
   

   O resultado será assim:

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

3. Verifique se os serviços de cada REDB estão em execução:

   kubectl get svc --all-namespaces
   

   O resultado será assim:

   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. Verifique se o Secret foi criado:

   kubectl get secrets -n application
   

   O resultado será assim:

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

Autenticar usando senhas

É possível se conectar ao REDB usando um pod com redis-cli no namespace do aplicativo. O pod cliente usa os secrets disponíveis no namespace do aplicativo (REDB) para estabelecer uma conexão.

Os bancos de dados criados com o recurso personalizado de REDB são compatíveis apenas com a autenticação por senha sem ACL.

1. Crie o pod cliente:

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

2. Conecte-se ao pod cliente:

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

3. Conecte-se ao banco de dados:

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

4. Crie uma chave:

   SET mykey "Hello World"
   

   O resultado será assim:

   OK
   

5. Obtenha a chave:

   GET mykey
   

   O resultado será assim:

   "Hello World"
   

6. Saia do shell do pod

   exit
   

Entender como o Prometheus coleta métricas para seu cluster do Redis

No diagrama a seguir, mostramos como funciona a coleta de métricas do Prometheus:

No diagrama, um cluster particular do GKE contém os seguintes componentes:

• Um pod Redis que coleta métricas no caminho / e na porta 8070.
• Coletores baseados em Prometheus que processam as métricas do pod do Redis.
• Um recurso PodMonitoring que envia métricas ao Cloud Monitoring.

O operador Redis Enterprise expõe as métricas do cluster no formato do Prometheus.

1. Crie a implantação metrics-proxy:

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

   Como o operador fornece apenas um endpoint HTTPS com o certificado autoassinado e o recurso PodMonitoring não oferece suporte à desativação da verificação de certificado TLS, use o pod metrics-proxy como um proxy reverso desse endpoint para expor as métricas na porta HTTP.

2. Crie o recurso PodMonitoring para raspar métricas por labelSelector:

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

3. No console do Google Cloud , acesse a página Painel de clusters do GKE.

   Acessar o painel de clusters do GKE

   O painel mostra uma taxa de ingestão de métricas diferente de zero.

Criar um painel

Para visualizar as métricas, crie um painel.

1. Crie o painel:

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

   O resultado será assim:

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

2. No console Google Cloud , acesse a página Painéis.

   Ir para "Painéis"

3. Abra o painel do cluster do Redis Enterprise. Pode levar vários minutos para que o painel seja provisionado automaticamente.

Verificar as métricas exportadas

Para verificar as métricas, crie um banco de dados e examine as métricas.

1. Abra o painel do cluster do Redis Enterprise.

2. Crie um banco de dados adicional do Redis:

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

   A Contagem de banco de dados no painel será atualizada.

3. Crie um pod cliente para se conectar ao novo banco de dados:

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

4. Conecte-se ao pod cliente e prepare as variáveis:

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

5. Use a ferramenta redis-cli para criar novas chaves:

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

6. Atualize a página e observe se os gráficos foram atualizados para mostrar o estado real do banco de dados.

7. Saia do shell do pod

   exit