Ce guide vous explique comment déployer Redis Enterprise sur des clusters Google Kubernetes Engine (GKE).
Redis est une base de données Open Source en mémoire NoSQL principalement utilisée pour la mise en cache. Elle offre une réplication intégrée, des scripts Lua, l'éviction LRU, des transactions, la persistance sur disque et une haute disponibilité.
Redis Enterprise est une solution de niveau entreprise qui étend la base de données Open Source Redis et offre une gestion simplifiée, y compris la distribution des données géo-répliquées, le scaling linéaire du débit des opérations, la hiérarchisation des données, des fonctionnalités de sécurité avancées, etc.
La tarification de Redis Enterprise diffère pour chaque option de déploiement, y compris les suivantes : Logiciels, Cloud ou hybride et multicloud.
Ce guide est destiné aux administrateurs de plate-forme, aux architectes cloud et aux professionnels des opérations qui souhaitent déployer Redis Enterprise sur Google Kubernetes Engine (GKE).
Configurer votre environnement
Dans ce tutoriel, vous utilisez Cloud Shell pour gérer les ressources hébergées surGoogle Cloud. Les logiciels dont vous avez besoin pour ce tutoriel sont préinstallés sur Cloud Shell, y compris kubectl, la gcloud CLI et Terraform.
Pour configurer votre environnement avec Cloud Shell, procédez comme suit :
Lancez une session Cloud Shell depuis la console Google Cloud en cliquant sur
Activer Cloud Shell dans la consoleGoogle Cloud .
Une session s'ouvre dans le volet inférieur de la console Google Cloud .Définissez les variables d'environnement :
export PROJECT_ID=PROJECT_ID export KUBERNETES_CLUSTER_PREFIX=redis export REGION=us-central1Remplacez
PROJECT_ID: your Google Cloud par votre ID de projet.Clonez le dépôt GitHub.
git clone https://github.com/GoogleCloudPlatform/kubernetes-engine-samplesAccédez au répertoire de travail :
cd kubernetes-engine-samples/databases/redis-enterprise-operator
Créer l'infrastructure de votre cluster
Dans cette section, vous allez exécuter un script Terraform pour créer un VPC et un cluster GKE régional, privé, à disponibilité élevée.
Le schéma suivant présente un cluster GKE standard régional privé déployé sur trois zones différentes :
Pour déployer cette infrastructure, exécutez les commandes suivantes à partir de 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}
Lorsque vous y êtes invité, saisissez yes. L'exécution de cette commande et le passage du cluster à l'état prêt peuvent prendre plusieurs minutes.
Terraform crée les ressources suivantes :
- Un réseau VPC et un sous-réseau privé pour les nœuds Kubernetes.
- Un routeur pour accéder à Internet via NAT.
- Un cluster GKE privé dans la région
us-central1. - Un pool de nœuds avec autoscaling activé (un à deux nœuds par zone, un nœud par zone au minimum).
Le résultat ressemble à ce qui suit :
...
Apply complete! Resources: 14 added, 0 changed, 0 destroyed.
...
Se connecter au cluster
Avec Cloud Shell, configurez kubectl pour communiquer avec le cluster :
gcloud container clusters get-credentials ${KUBERNETES_CLUSTER_PREFIX}-cluster --location ${REGION}
Déployer l'opérateur Redis Enterprise sur votre cluster
Dans cette section, vous allez déployer l'opérateur Redis Enterprise sur votre cluster Kubernetes.
Créez des espaces de noms pour le REC et ses applications :
kubectl create namespace rec-ns kubectl create namespace applicationAjoutez un libellé aux espaces de noms :
kubectl label namespace rec-ns connection=redis kubectl label namespace application connection=redisObtenez la dernière version du bundle d'opérateurs Redis Enterprise :
VERSION=`curl --silent https://api.github.com/repos/RedisLabs/redis-enterprise-k8s-docs/releases/latest | grep tag_name | awk -F'"' '{print $4}'`Installez l'opérateur Redis Enterprise :
kubectl apply -n rec-ns -f https://raw.githubusercontent.com/RedisLabs/redis-enterprise-k8s-docs/$VERSION/bundle.yamlLe résultat ressemble à ce qui suit :
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
Déployer un cluster Redis Enterprise
Appliquez le fichier manifeste à votre cluster :
kubectl apply -n rec-ns -f manifests/01-basic-cluster/rec.yamlCette commande peut prendre plusieurs minutes.
Vérifiez l'état du déploiement de REC :
kubectl get rec -n rec-nsLe résultat ressemble à ce qui suit :
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 4m7sLe cluster est prêt lorsque la valeur
STATEest définie surRUNNING.
Facultatif : Configurer le contrôleur d'admission
Vous pouvez éventuellement configurer l'infrastructure pour la validation de la base de données lors du déploiement.
Configurez le contrôleur d'admission et vérifiez si le secret TLS d'admission est présent :
kubectl get secret admission-tls -n rec-nsObtenez le certificat :
export CERT=$(kubectl get secret admission-tls -n rec-ns -o jsonpath='{.data.cert}')Copiez le certificat dans le fichier
webhook.yaml:sed -i -e 's/CRT/'$CERT'/g' manifests/01-basic-cluster/webhook.yamlDéployez le webhook de validation :
sed -i -e 's/CRT/'$CERT'/g' manifests/01-basic-cluster/webhook.yamlLe contrôleur d'admission valide la syntaxe de la base de données dans les espaces de noms libellés.
Vérifiez le contrôleur d'admission en créant une base de données non fonctionnelle :
kubectl apply -n rec-ns -f - << EOF apiVersion: app.redislabs.com/v1alpha1 kind: RedisEnterpriseDatabase metadata: name: redis-enterprise-database spec: evictionPolicy: illegal EOFLe résultat ressemble à ce qui suit :
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']
Créer des espaces de noms
Par défaut, l'opérateur Redis Enterprise ne dispose d'aucun droit permettant d'effectuer des actions en dehors de son propre espace de noms. Pour autoriser l'opérateur Redis Enterprise à créer des points de terminaison REDB et de base de données dans d'autres espaces de noms, vous devez configurer RBAC.
Appliquez le rôle et la liaison de rôle correspondants dans l'espace de noms de l'application :
kubectl apply -f manifests/01-basic-cluster/role.yaml -n application kubectl apply -f manifests/01-basic-cluster/role-binding.yaml -n applicationCréez un rôle de cluster et une liaison de rôle de cluster dans l'espace de noms
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.yamlModifiez le fichier ConfigMap REC pour ajouter un contrôle sur l'espace de noms de l'application :
kubectl patch ConfigMap/operator-environment-config --type merge -p '{"data": {"REDB_NAMESPACES_LABEL": "connection=redis"}}' -n rec-nsChaque espace de noms étiqueté en tant que ConfigMap est corrigé.
Vérifiez l'état des ressources de votre infrastructure Redis dans l'espace de noms
rec-ns:kubectl get pod,deploy,svc,rec,statefulset,cm,secrets -n rec-nsLe résultat ressemble à ce qui suit :
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
Déployer des bases de données Redis Enterprise
Créez des bases de données Redis Enterprise dans les espaces de noms de l'application :
kubectl apply -f manifests/01-basic-cluster/a-rdb.yaml -n applicationVérifiez l'état REDB :
kubectl get redb --all-namespacesLe résultat ressemble à ce qui suit :
NAMESPACE NAME VERSION PORT CLUSTER SHARDS STATUS SPEC STATUS AGE application app-db 7.2.0 12999 gke-rec 1 active Valid 15sVérifiez que les services de chaque REDB sont en cours d'exécution :
kubectl get svc --all-namespacesLe résultat ressemble à ce qui suit :
NAMESPACE NAME TYPE CLUSTER-IP EXTERNAL-IP PORT(S) AGE application app-db ExternalName <none> redis-12999.rec-ns.svc.cluster.local 12999/TCP 72mVérifiez que le secret a été créé :
kubectl get secrets -n applicationLe résultat ressemble à ce qui suit :
NAME TYPE DATA AGE redb-app-db Opaque 3 96m
S'authentifier à l'aide de mots de passe
Vous pouvez vous connecter à REDB à l'aide d'un pod avec redis-cli dans l'espace de noms de l'application. Le pod client utilise les secrets disponibles dans l'espace de noms de l'application (REDB) pour établir une connexion.
Les bases de données créées avec le REDB de ressource personnalisée ne sont compatibles qu'avec l'authentification par mot de passe sans LCA.
Créez le pod client :
kubectl apply -n application -f manifests/03-auth/client_pod.yamlConnectez-vous au pod client :
kubectl exec -n application -i -t redis-client -c redis-client -- /bin/shConnectez-vous à la base de données :
redis-cli -h $SERVICE -p $PORT --pass $PASSCréez une clé :
SET mykey "Hello World"Le résultat ressemble à ce qui suit :
OKObtenez la clé :
GET mykeyLe résultat ressemble à ce qui suit :
"Hello World"Quittez l'interface système du pod.
exit
Comprendre comment Prometheus collecte les métriques pour votre cluster Redis
Le schéma suivant illustre le fonctionnement de la collecte de métriques Prometheus :
Dans le schéma, un cluster privé GKE contient :
- Un pod Redis qui collecte des métriques sur le chemin
/et le port8070 - Collecteurs basés sur Prometheus qui traitent les métriques à partir du pod Redis
- Une ressource
PodMonitoringqui envoie des métriques à Cloud Monitoring
L'opérateur Redis Enterprise expose les métriques de cluster au format Prometheus.
Créez le déploiement metrics-proxy :
kubectl apply -n rec-ns -f manifests/02-prometheus-metrics/metrics-proxy.yamlÉtant donné que l'opérateur ne fournit qu'un point de terminaison HTTPS avec le certificat autosigné et que la ressource
PodMonitoringne permet pas de désactiver la validation du certificat TLS, utilisez le podmetrics-proxyen sens inverse. Proxy pour ce point de terminaison afin d'exposer les métriques sur le port HTTP.Créez la ressource PodMonitoring pour récupérer les métriques par
labelSelector:kubectl apply -n rec-ns -f manifests/02-prometheus-metrics/pod-monitoring.yamlDans la console Google Cloud , accédez à la page Tableau de bord des clusters GKE.
Accéder au tableau de bord des clusters GKE
Le tableau de bord affiche un taux d'ingestion de métriques différent de zéro.
Créer un tableau de bord
Vous pouvez afficher les métriques en créant un tableau de bord.
Créez le tableau de bord :
gcloud --project "${PROJECT_ID}" monitoring dashboards create --config-from-file monitoring/dashboard.jsonLe résultat ressemble à ce qui suit :
Created [f4efbe4e-2605-46b4-9910-54b13d29b3be].Dans la console Google Cloud , accédez à la page Tableaux de bord.
Ouvrez le tableau de bord des clusters Redis Enterprise. Le provisionnement automatique du tableau de bord peut prendre plusieurs minutes.
Vérifier les métriques exportées
Pour vérifier les métriques, créez une base de données et examinez-les.
Ouvrez le tableau de bord des clusters Redis Enterprise.
Créez une base de données Redis supplémentaire :
kubectl apply -n rec-ns -f manifests/02-prometheus-metrics/c-rdb.yamlLe nombre de bases de données dans le tableau de bord devrait être mis à jour.
Créez un pod client pour vous connecter à la nouvelle base de données :
kubectl apply -n rec-ns -f manifests/02-prometheus-metrics/client_pod.yamlConnectez-vous au pod client et préparez les variables :
kubectl exec -it redis-client-c -n rec-ns -- /bin/bashUtilisez l'outil
redis-clipour créer des clés :for i in {1..50}; do \ redis-cli -h $SERVICE -p $PORT -a $PASS \ --no-auth-warning SET mykey-$i "myvalue-$i"; \ doneActualisez la page et observez que les graphiques ont été mis à jour pour afficher l'état réel de la base de données.
Quittez l'interface système du pod.
exit