Déployer Redis sur GKE en utilisant Spotahome

Autopilot Standard

---

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

Ce guide est destiné aux administrateurs de plate-forme, aux architectes cloud et aux professionnels des opérations qui souhaitent déployer des clusters Redis sur Google Kubernetes Engine (GKE).

Le guide vous explique comment utiliser l'opérateur Spotahome Redis pour déployer des clusters Redis.

L'opérateur est sous licence sous Apache License 2.0.

Spotahome offre les avantages suivants :

• Gestion des clusters Redis natifs Kubernetes
• Haute disponibilité fournie par Redis Sentinel
• Intégration fluide de Prometheus pour l'observabilité des bases de données
• Prise en charge des configurations Redis personnalisées

Objectifs

• Planifier et déployer l'infrastructure GKE pour Redis
• Déployer et configurer l'opérateur Spotahome Redis
• Configurer Redis à l'aide de l'opérateur pour garantir la disponibilité, la sécurité, l'observabilité et les performances

Architecture de déploiement

Dans ce tutoriel, vous allez utiliser l'opérateur Spotahome Redis pour déployer et configurer un cluster Redis à disponibilité élevée sur GKE avec un nœud maître et deux instances répliquées avec accès en lecture, ainsi que le cluster Redis Sentinel composé de trois instances répliquées.

Redis Sentinel est un système de haute disponibilité et de surveillance pour Redis Open Source. Il surveille en permanence les instances Redis, y compris l'instance maître et ses instances répliquées associées. Si le nœud responsable échoue, Sentinel peut automatiquement promouvoir l'une des instances répliquées pour devenir la nouvelle instance principale, garantissant ainsi qu'il existe toujours un nœud responsable opérationnel disponible pour les lectures et les écritures de données. Lorsque des événements importants se produisent dans un cluster Redis, tels qu'une défaillance de responsable ou un événement de basculement, Sentinel peut avertir les administrateurs ou d'autres systèmes par e-mail ou d'autres mécanismes de notification.

Vous allez également déployer un cluster GKE régional hautement disponible pour Redis, avec plusieurs nœuds Kubernetes répartis sur plusieurs zones de disponibilité. Cette configuration permet d'assurer la tolérance aux pannes, l'évolutivité et la redondance géographique. Il permet d'effectuer des mises à jour et des opérations de maintenance progressives tout en fournissant des contrats de niveau de service en matière de disponibilité et de disponibilité. Pour en savoir plus, consultez la page Clusters régionaux.

Le schéma suivant montre comment un cluster Redis s'exécute sur plusieurs nœuds et zones d'un cluster GKE :

Dans le schéma, le StatefulSet Redis est déployé sur trois nœuds dans trois zones différentes. Vous contrôlez la manière dont GKE déploie le StatefulSet sur les nœuds et les zones en définissant des règles d'affinité et de répartition de la topologie des pods sur les spécifications de ressource personnalisée RedisFailover.

Si une zone échoue, à l'aide de la configuration recommandée, GKE replanifie les pods sur les nouveaux nœuds.

Le schéma suivant montre un déploiement Sentinel planifié sur trois nœuds dans trois zones différentes :

Coûts

Dans ce document, vous utilisez les composants facturables suivants de Google Cloud :

• Compute Engine
• GKE
• Google Cloud Managed Service pour Prometheus

Obtenez une estimation des coûts en fonction de votre utilisation prévue à l'aide du simulateur de coût. Les nouveaux utilisateurs de Google Cloud peuvent bénéficier d'un essai gratuit.

Une fois que vous avez terminé les tâches décrites dans ce document, vous pouvez éviter de continuer à payer des frais en supprimant les ressources que vous avez créées. Pour en savoir plus, consultez la section Effectuer un nettoyage.

Avant de commencer

1. 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.
2. Install the Google Cloud CLI.

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

4. Create or select a Google Cloud project.

   Note: If you don't plan to keep the resources that you create in this procedure, create a project instead of selecting an existing project. After you finish these steps, you can delete the project, removing all resources associated with the 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.

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

6. Enable the Compute Engine, IAM, GKE, Backup for GKE, and Resource Manager APIs:

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

7. Install the Google Cloud CLI.

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

9. Create or select a Google Cloud project.

   Note: If you don't plan to keep the resources that you create in this procedure, create a project instead of selecting an existing project. After you finish these steps, you can delete the project, removing all resources associated with the 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.

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

11. Enable the Compute Engine, IAM, GKE, Backup for GKE, and Resource Manager APIs:

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

12. Grant roles to your user account. Run the following command once for each of the following IAM roles: roles/storage.objectViewer, roles/container.admin, roles/iam.serviceAccountAdmin, roles/compute.admin, roles/gkebackup.admin, roles/monitoring.viewer

    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:[e-mail].

    • Replace ROLE with each individual role.

Configurer votre environnement

Dans ce tutoriel, vous utilisez Cloud Shell pour gérer les ressources hébergées sur Google Cloud. Cloud Shell est préinstallé avec les logiciels dont vous avez besoin pour ce tutoriel, y compris kubectl, gcloud CLI, Helm et Terraform.

Pour configurer votre environnement avec Cloud Shell, procédez comme suit :

1. Lancez une session Cloud Shell depuis la console Google Cloud en cliquant sur  Activer Cloud Shell dans la console Google Cloud. Une session s'ouvre dans le volet inférieur de la console Google Cloud.

2. Définissez les variables d'environnement :

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

   Remplacez PROJECT_ID par votre ID de projet Google Cloud.

3. Clonez le dépôt GitHub.

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

4. Accédez au répertoire de travail :

   cd kubernetes-engine-samples/databases/redis-spotahome
   

Créer l'infrastructure de votre cluster

Dans cette section, vous allez exécuter un script Terraform pour créer un cluster GKE régional, privé et à disponibilité élevée. Les étapes suivantes autorisent l'accès public au plan de contrôle.

Vous pouvez installer l'opérateur à l'aide d'un cluster standard ou Autopilot.

Standard

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 :

export GOOGLE_OAUTH_ACCESS_TOKEN=$(gcloud auth print-access-token)
terraform -chdir=terraform/gke-standard init
terraform -chdir=terraform/gke-standard 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.
• Deux pools de nœuds avec autoscaling activé (un à deux nœuds par zone, un nœud par zone au minimum).
• Un ServiceAccount avec les autorisations de journalisation et de surveillance.
• Sauvegarde pour GKE pour la reprise après sinistre.
• Google Cloud Managed Service pour Prometheus pour la surveillance du cluster.

Le résultat ressemble à ce qui suit :

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

Autopilot

Le schéma suivant présente un cluster GKE Autopilot régional privé :

Pour déployer l'infrastructure, exécutez les commandes suivantes à partir de Cloud Shell :

export GOOGLE_OAUTH_ACCESS_TOKEN=$(gcloud auth print-access-token)
terraform -chdir=terraform/gke-autopilot init
terraform -chdir=terraform/gke-autopilot 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 objet ServiceAccount avec une autorisation de journalisation et de surveillance.
• Google Cloud Managed Service pour Prometheus pour la surveillance du cluster.

Le résultat ressemble à ce qui suit :

...
Apply complete! Resources: 12 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 --region ${REGION}

Déployer l'opérateur Spotahome sur votre cluster

Dans cette section, vous allez déployer l'opérateur Spotahome sur votre cluster Kubernetes à l'aide d'un graphique Helm, puis déployer un cluster Redis.

1. Ajoutez le dépôt du chart Helm de l'opérateur Spotahome Redis :

   helm repo add redis-operator https://spotahome.github.io/redis-operator
   

2. Ajoutez un espace de noms pour l'opérateur Spotahome et le cluster Redis :

   kubectl create ns redis
   

3. Déployez l'opérateur Spotahome à l'aide de l'outil de ligne de commande Helm :

   helm install redis-operator redis-operator/redis-operator --version 3.2.9 -n redis
   

4. Vérifiez l'état de déploiement de l'opérateur Spotahome à l'aide de Helm :

   helm ls -n redis
   

   Le résultat ressemble à ce qui suit :

   NAME             NAMESPACE    REVISION    UPDATED                                STATUS      CHART                   APP VERSION
   redis-operator    redis      1           2023-09-12 13:21:48.179503 +0200 CEST    deployed    redis-operator-3.2.9    1.2.4
   

Déployer Redis

La configuration de base de l'instance de cluster Redis inclut les composants suivants :

• Trois instances répliquées de nœuds Redis : une instance maître et deux instances répliquées avec accès en lecture.
• Trois instances répliquées de nœuds Sentinel, formant un quorum.
• Allocation de ressources de processeur pour une requête de processeur et deux limites de processeur, avec 4 Go de mémoire et des limites pour Redis, et 100 m/500 m de processeur et 500 Mo pour Sentinel.
• Les tolérances, nodeAffinities et topologySpreadConstraints configurées pour chaque charge de travail, garantissant une répartition appropriée entre les nœuds Kubernetes, en utilisant leurs pools de nœuds respectifs et différentes zones de disponibilité.

Cette configuration représente la configuration minimale requise pour créer un cluster Redis prêt pour la production.

Créer un cluster Redis de base

1. Créez un secret avec des identifiants utilisateur :

   export PASSWORD=$(openssl rand -base64 12)
   kubectl create secret generic my-user -n redis \
       --from-literal=password="$PASSWORD"
   

   L'opérateur ne dispose pas d'une fonctionnalité permettant de générer des identifiants, et le mot de passe de la base de données doit être prégénéré.

2. Créez un cluster Redis en utilisant la configuration de base :

   kubectl apply -n redis -f manifests/01-basic-cluster/my-cluster.yaml
   

   Cette commande crée une ressource personnalisée RedisFailover de l'opérateur Spotahome qui spécifie les demandes et limites de processeurs et de mémoire, et les rejets et affinités pour répartir les instances répiquées de pods provisionnées sur les nœuds Kubernetes.

3. Attendez quelques minutes pendant que Kubernetes démarre les charges de travail requises :

   kubectl wait pods -l redisfailovers.databases.spotahome.com/name=my-cluster --for condition=Ready --timeout=300s -n redis
   

4. Vérifiez que les charges de travail Redis ont bien été créées :

   kubectl get pod,svc,statefulset,deploy,pdb -n redis
   

   Le résultat ressemble à ce qui suit :

   NAME                                READY   STATUS  RESTARTS   AGE
   pod/redis-operator-5dc65cb7cc-krlcs   1/1   Running   0         49m
   pod/rfr-my-cluster-0                2/2     Running   0         60s
   pod/rfr-my-cluster-1                2/2     Running   0         60s
   pod/rfr-my-cluster-2                2/2     Running   0         60s
   pod/rfs-my-cluster-8475dfd96c-h5zvw   1/1   Running   0         60s
   pod/rfs-my-cluster-8475dfd96c-rmh6f   1/1   Running   0         60s
   pod/rfs-my-cluster-8475dfd96c-shzxh   1/1   Running   0         60s
   
   NAME                    TYPE        CLUSTER-IP  EXTERNAL-IP   PORT(S)   AGE
   service/redis-my-cluster ClusterIP   10.52.14.87   <none>       6389/TCP    55s
   service/redis-operator   ClusterIP   10.52.13.217   <none>      9710/TCP    49m
   service/rfr-my-cluster   ClusterIP   None           <none>      9121/TCP    61s
   service/rfs-my-cluster   ClusterIP   10.52.15.197   <none>      26379/TCP   61s
   
   NAME                            READY   AGE
   statefulset.apps/rfr-my-cluster   3/3   61s
   
   NAME                            READY   UP-TO-DATE   AVAILABLE   AGE
   deployment.apps/redis-operator   1/1    1           1           50m
   deployment.apps/rfs-my-cluster   3/3    3           3           62s
   
   NAME                                        MIN AVAILABLE   MAX UNAVAILABLE   ALLOWED DISRUPTIONS   AGE
   poddisruptionbudget.policy/rfr-my-cluster   2               N/A             1                   64s
   poddisruptionbudget.policy/rfs-my-cluster   2               N/A             1                   63s
   

L'opérateur crée les ressources suivantes :

• Un déploiement StatefulSet Redis et Sentinel
• Trois instances répliquées de pods pour Redis
• Trois instances répliquées de pods pour Sentinel
• Deux PodDisruptionBudgets, assurant au moins deux instances répliquées disponibles pour la cohérence du cluster
• Le service rfr-my-cluster, qui expose les métriques Redis
• Le service redis-my-cluster, qui cible le nœud maître du cluster Redis
• Le service rfs-my-cluster, qui permet aux clients de se connecter au cluster via les Sentinels. La compatibilité avec Sentinel est requise pour les bibliothèques clientes.

Partager les identifiants Redis

Vous pouvez partager des identifiants Redis avec des clients à l'aide de l'ancienne méthode d'authentification de l'opérateur Spotahome.

Vous devez utiliser un mot de passe de base de données à l'aide du paramètre requirepass. Ce mot de passe est ensuite utilisé par tous les clients. Pour gérer des utilisateurs supplémentaires, utilisez les commandes CLI Redis.

apiVersion: databases.spotahome.com/v1
kind: RedisFailover
metadata:
  name: my-cluster
spec:
  ...
  auth:
    secretPath: my-user

Le partage des identifiants Redis avec des clients à l'aide de cette méthode présente les limites suivantes :

• Spotahome ne fournit pas de ressources personnalisées pour la gestion des utilisateurs. Vous pouvez stocker les identifiants dans des secrets et les référencer dans les spécifications auth.
• Il n'existe aucune méthode permettant de sécuriser les connexions avec le chiffrement TLS à l'aide de la ressource personnalisée.
• La mise à jour en direct des identifiants n'est pas compatible.

Se connecter à Redis

Vous pouvez déployer un client Redis et vous authentifier à l'aide d'un mot de passe stocké dans un secret Kubernetes.

1. Exécutez le pod client pour interagir avec votre cluster Redis :

   kubectl apply -n redis -f manifests/02-auth/client-pod.yaml
   

   La variable d'environnement PASS récupère le secret my-user à partir de Vault.

2. Attendez que le pod soit prêt, puis connectez-vous à celui-ci :

   kubectl wait pod redis-client --for=condition=Ready --timeout=300s -n redis
   kubectl exec -it redis-client -n redis -- /bin/bash
   

3. Vérifiez que la connexion fonctionne :

   redis-cli -h redis-my-cluster -a $PASS --no-auth-warning SET my-key "testvalue"
   

   Le résultat ressemble à ce qui suit :

   OK
   

4. Obtenez la valeur my-key :

   redis-cli -h redis-my-cluster -a $PASS --no-auth-warning GET my-key
   

   Le résultat ressemble à ce qui suit :

   "testvalue"
   

5. 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 port 9121
• Collecteurs basés sur Prometheus qui traitent les métriques à partir du pod Redis
• Une ressource PodMonitoring qui envoie des métriques à Cloud Monitoring

Le service Google Cloud Managed Service pour Prometheus accepte la collecte de métriques au format Prometheus. Cloud Monitoring utilise un tableau de bord intégré pour les métriques Redis.

L'opérateur Spotahome expose les métriques de cluster au format Prometheus en utilisant redis_exporter comme side-car.

1. Créez la ressource PodMonitoring pour récupérer les métriques par labelSelector:

   kubectl apply -n redis -f manifests/03-prometheus-metrics/pod-monitoring.yaml
   

2. Dans 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.

3. Dans la console Google Cloud, accédez à la page Tableaux de bord.

   Accéder à la page Tableaux de bord

4. Ouvrez le tableau de bord Redis Prometheus. Le tableau de bord affiche la quantité de connexions et de clés. Le provisionnement automatique du tableau de bord peut prendre plusieurs minutes.

5. Connectez-vous au pod client et préparez les variables :

   kubectl exec -it redis-client -n redis -- /bin/bash
   

6. Utilisez l'outil redis-cli pour créer des clés :

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

7. Actualisez la page et observez que les graphiques Commandes par seconde et Clés ont été mis à jour pour afficher l'état réel de la base de données.

8. Quittez l'interface système du pod.

   exit
   

Effectuer un nettoyage

Supprimer le projet

Attention : La suppression d'un projet entraîne les effets décrits ci-dessous :

• Tout le contenu du projet est supprimé. Si vous avez utilisé un projet existant pour les tâches décrites dans ce document et que vous le supprimez, vous supprimerez également tout autre travail effectué dans le projet.
• Les ID de projets personnalisés sont perdus. Lorsque vous avez créé ce projet, vous avez peut-être créé un ID de projet personnalisé que vous souhaitez utiliser à l'avenir. Pour conserver les URL qui utilisent l'ID de projet, telle qu'une URL appspot.com, supprimez les ressources sélectionnées dans le projet au lieu de supprimer l'ensemble du projet.

Si vous envisagez d'explorer plusieurs architectures, tutoriels et guides de démarrage rapide, réutiliser des projets peut vous aider à ne pas dépasser les limites de quotas des projets.

Delete a Google Cloud project:

gcloud projects delete PROJECT_ID

Supprimer des ressources individuelles

1. Définissez les variables d'environnement.

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

2. Exécutez la commande terraform destroy :

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

   Remplacez FOLDER par gke-autopilot ou gke-standard.

   Lorsque vous y êtes invité, saisissez yes.

3. Recherchez tous les disques non associés :

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

4. Supprimez les disques :

   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
   

Étapes suivantes

• Découvrez des architectures de référence, des schémas et des bonnes pratiques concernant Google Cloud. Consultez notre Centre d'architecture cloud.