Déployer la migration à chaud RIOT pour migrer vers Redis Enterprise Cloud

Last reviewed 2024-01-29 UTC

Ce document explique comment déployer le service de migration à chaut RIOT pour migrer vers Redis Enterprise Cloud. Les architectes de base de données, les équipes DevOps et SRE ou les administrateurs réseau peuvent utiliser cette architecture pour fournir à leurs équipes des migrations avec un temps d'arrêt quasiment nul. Dans ce document, nous partons du principe que vous maîtrisez Google Cloud CLI et Compute Engine.

Architecture

Le schéma suivant illustre l'architecture de référence qui utilise le service de migration à chaud RIOT pour migrer des sources compatibles avec Redis vers Redis Enterprise Cloud.

Les sources compatibles avec Redis sont migrées via RIOT vers Redis Enterprise Cloud.

Pour en savoir plus sur l'architecture, consultez la page Migration à chaud RIOT pour migrer vers Redis Enterprise Cloud.

L'exemple de déploiement présenté dans ce document utilise l'architecture suivante, dans laquelle la source est un OSS Redis sur une VM Compute Engine :

Redis OSS est migré via un processus RIOT et l'appairage de VPC vers Redis Enterprise Cloud.

Dans le schéma, une instance Redis OSS et RIOT sont regroupés dans une seule VM Compute Engine pour des raisons de simplicité. Dans un environnement de production, nous recommandons que RIOT s'exécute toujours sur sa propre VM afin de garantir de meilleures performances.

L'exemple d'architecture de déploiement contient les composants suivants :

Source : instance Redis OSS s'exécutant sur une VM Compute Engine.
Cible : Redis Enterprise Cloud s'exécutant dans le VPC géré Redis.
Service de migration : RIOT exécuté sur la même VM Compute Engine que Redis OSS.
Configuration du réseau : appairage de VPC entre un VPC géré et le VPC géré Redis.

L'outil de migration RIOT présente un temps d'arrêt quasiment nul. Pendant la migration de Redis OSS (source) vers Redis Enterprise Cloud (cible), vos applications peuvent toujours accéder à Redis OSS sans impact ni interruption de service. Au cours du processus de migration, après le chargement initial des données depuis Redis OSS, la migration à chaud RIOT continue de migrer les modifications depuis Redis OSS au fur et à mesure qu'elles se produisent.

Objectifs

Configurer votre source Redis OSS en créant et en chargeant des données.
Configurer un cluster cible de migration dans Redis Enterprise Cloud.
Utiliser la migration à chaud RIOT pour migrer des données de Redis OSS vers Redis Enterprise Cloud.
Comprendre les stratégies de test, de bascule et de remplacement.

Coûts

Le déploiement de cette architecture utilise les composants facturables suivants de Google Cloud :

Coûts Compute Engine liés à l'exécution d'instances Redis OSS et RIOT
Coût d'acquisition de Redis Enterprise Cloud via Google Cloud Marketplace.
Frais de réseau liés au trafic de migration de données entre les zones et les régions

Avant de commencer

Pour configurer un environnement pour votre migration, procédez comme suit :

Dans Google Cloud Console, sur la page de sélection du projet, sélectionnez ou créez un projet Google Cloud.

Remarque : Si vous ne comptez pas conserver les ressources créées dans cette procédure, créez un projet au lieu de sélectionner un projet existant. Après avoir suivi ces étapes, vous pouvez supprimer le projet. Cela entraîne la suppression de toutes les ressources qui lui sont associées.

Accéder au sélecteur de projet
Vérifiez que la facturation est activée pour votre projet Google Cloud.
Activer les API BigQuery, Pub/Sub, Dataflow, and Compute Engine.
Activer les API
Pour obtenir les autorisations nécessaires pour effectuer ce déploiement, demandez à votre administrateur de vous accorder le rôle IAM d'administrateur de la facturation (roles/billing.admin) sur votre organisation. Pour en savoir plus sur l'attribution de rôles, consultez la section Gérer les accès.

Vous pouvez également obtenir les autorisations requises via des rôles personnalisés ou d'autres rôles prédéfinis.

Configurer une instance Redis OSS

Pour démarrer le déploiement, vous devez installer l'instance Redis OSS sur une VM Compute Engine. L'instance sert d'instance source.

Installer l'instance Redis OSS

Dans la console Google Cloud, activez Cloud Shell.

Activer Cloud Shell

En bas de la fenêtre de la console Google Cloud, une session Cloud Shell démarre et affiche une invite de ligne de commande. Cloud Shell est un environnement shell dans lequel Google Cloud CLI est déjà installé, et dans lequel des valeurs sont déjà définies pour votre projet actuel. L'initialisation de la session peut prendre quelques secondes.

Dans Cloud Shell, créez une VM Ubuntu :

gcloud compute instances create redis-oss-riot-vm \
  --image-family=ubuntu-2004-lts \
    --image-project=ubuntu-os-cloud \
    --zone=us-central1-a \
    --machine-type=e2-medium \
    --network=VPC_NETWORK_NAME \
    --subnet=VPC_SUBNETWORK_NAME \
  --metadata=startup-script='#! /bin/bash
    apt-get update -y
    apt-get install redis-tools -y
    snap install redis'

Remplacez les éléments suivants :

VPC_NETWORK_NAME : nom de votre réseau VPC
VPC_SUBNETWORK_NAME : nom de votre sous-réseau VPC

Utilisez une connexion SSH pour vous connecter à l'instance Compute Engine qui exécute l'instance Redis OSS :

PROJECT_ID=$(gcloud info --format='value(config.project)')

gcloud compute ssh redis-oss-riot-vm --project $PROJECT_ID --zone us-central1-a

Activez la notification d'espace de clés pour la migration à chaud requise par RIOT :
```
redis-cli config set notify-keyspace-events KEA
```

Vérifier que l'instance Redis OSS est opérationnelle

Dans Cloud Shell, lancez la CLI Redis :
```
redis-cli
```
Définissez et obtenez une paire clé/valeur simple :
```
set my_key my_value
get my_key
unlink my_key
```
Le résultat est le suivant :
```
OK
"my_value"
(integer) 1
```
Vous avez maintenant créé votre instance Redis OSS, y avez accédé et avez vérifié qu'elle est opérationnelle.

Insérer des exemples de données

Dans cette section, vous allez insérer des exemples de données dans l'instance Redis OSS et vérifier que les données ont bien été insérées.

Dans Cloud Shell, lancez la CLI Redis :
```
redis-cli
```
Ajoutez les six paires clé/valeur suivantes en tant qu'ensemble de données initial. Saisissez chaque commande individuellement et attendez la sortie OK avant de saisir la paire clé/valeur suivante.
```
set tennis federer
```
```
set soccer ronaldo
```
```
set basketball curry
```
```
set football montana
```
```
set golf woods
```
```
set swimmer phelps
```
Vérifiez que vous avez bien ajouté six paires clé/valeur :
```
SCAN 0
```
Le résultat est le suivant :
```
"swimmer"
"soccer"
"football"
"golf"
"tennis"
"basketball"
```

Une fois que vous avez configuré et démarré la migration RIOT, les données sont migrées vers l'instance Cloud Redis Enterprise cible.

Installer RIOT sur la VM de l'instance Redis OSS

Pour exécuter RIOT, vous devez vous assurer que votre VM Compute Engine est de taille appropriée. En général, nous recommandons de dimensionner votre VM avec 8 vCPU ou plus, en fonction de la quantité de données à transporter et de la fréquence de mise à jour. Pour en savoir plus, consultez le Guide des ressources de familles de machines et guide comparatif.

Dans Cloud Shell, utilisez une connexion SSH pour vous connecter à l'instance Compute Engine qui exécute l'instance Redis OSS :

PROJECT_ID=$(gcloud info --format='value(config.project)')

gcloud compute ssh redis-oss-riot-vm --project $PROJECT_ID --zone us-central1-a

Installez le JDK pour RIOT :
```
sudo apt install default-jre -y
```

Téléchargez et installez RIOT :

sudo apt-get install unzip

wget https://github.com/redis-developer/riot/releases/download/v2.19.0/riot-redis-2.19.0.zip

unzip riot-redis-2.19.0.zip

Vérifiez que RIOT est correctement installé :
```
./riot-redis-2.19.0/bin/riot-redis -V
```
Le résultat ressemble à ce qui suit, qui affiche un logo RIOT et un numéro de version :

Vous avez maintenant installé l'outil de migration RIOT sur l'instance Redis OSS et avez confirmé qu'il est opérationnel.

Créer une instance Redis Enterprise Cloud

Redis Enterprise Cloud est disponible via Cloud Marketplace. Si vous n'avez pas de cluster Redis Enterprise configuré comme instance Redis Enterprise cible, suivez les étapes décrites dans cette section. Si vous avez déjà configuré un cluster Redis Enterprise en tant que base de données cible, vous pouvez ignorer cette section et passer à la section Démarrer la migration à chaud RIOT.

Dans Cloud Marketplace, accédez à la page Redis Enterprise Cloud Flexible – Paiement à l'usage.

Accéder à Redis Enterprise dans Marketplace

Pour en savoir plus, consultez les instructions du document Redis Abonnement Flexible avec Cloud Marketplace.
Connectez-vous à la console Redis à l'aide des informations de compte Redis que vous avez fournies lors de votre abonnement à Redis Enterprise Cloud Flexible.
Créez un abonnement Flexible en suivant les instructions du document Redis Créer un abonnement Flexible. Choisissez Google Cloud comme fournisseur cloud et créez une base de données avec tous les paramètres par défaut.
Créez un appairage de VPC entre votre cloud privé virtuel Google et le VPC géré par Redis en suivant les instructions du document Redis Activer l'appairage de VPC.
Dans la console Redis, accédez à Abonnement, puis recherchez votre chaîne de connexion à la base de données Redis Enterprise :
1. Notez l'adresse IP et le port du point de terminaison privé au format suivant :
```
ENDPOINT_IP:ENDPOINT_PORT
```
  Les valeurs représentant les éléments suivants :
  - ENDPOINT_IP : adresse IP du point de terminaison privé de la base de données Redis Enterprise.
  - ENDPOINT_PORT : numéro de port du point de terminaison privé pour la base de données Redis Enterprise.
2. Notez le mot de passe de la base de données.

Démarrer la migration à chaud RIOT

Pour migrer les données de l'instance Redis OSS (source) vers l'instance Redis Enterprise Cloud (cible), procédez comme suit :

Dans Cloud Shell, utilisez une connexion SSH pour vous connecter à l'instance Compute Engine qui exécute l'instance Redis OSS :

PROJECT_ID=$(gcloud info --format='value(config.project)')

gcloud compute ssh redis-oss-riot-vm --project $PROJECT_ID --zone us-central1-a

Démarrez une migration à chaud entre la source et la cible. Si votre instance Redis OSS utilise Redis 7.2, vous devez utiliser une réplication basée sur le type. Pour plus d'informations sur l'utilisation de l'option --type, consultez la section Réplication basée sur le type de la documentation Redis.
```
./riot-redis-2.19.0/bin/riot-redis -u redis://localhost:6379 replicate  \
-u redis://ENDPOINT_IP:ENDPOINT_PORT \
  -a REDIS_ENTERPRISE_DB_PASSWORD \
  --mode live
```
Remplacez les éléments suivants par les valeurs que vous avez notées dans la section précédente :
- ENDPOINT_IP : adresse IP du point de terminaison privé pour la base de données du cluster Redis Enterprise.
- ENDPOINT_PORT : numéro de port du point de terminaison privé pour la base de données du cluster Redis Enterprise.
- REDIS_ENTERPRISE_DB_PASSWORD : mot de passe de la base de données du cluster Redis Enterprise.
Le résultat ressemble à ce qui suit :
```
Listening  ? % ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━0/? (0:00:00 / ?) ?/s\
Scanning 100% ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ 6/6 (0:00:00 / 0:00:00) ?/s
```

Vérifier la migration de la base de données

Il est important de concevoir et de mettre en œuvre une stratégie de vérification de migration de base de données pour vérifier que la migration a réussi. Bien que la stratégie de validation que vous utilisez dépende de votre cas d'utilisation spécifique, nous vous recommandons d'effectuer ces vérifications pour toutes les migrations :

Vérification d'exhaustivité : vérifiez que les paires clé/valeur initiales ont bien été migrées de Redis OSS vers Redis Enterprise (chargement initial).
Vérification dynamique : vérifiez que les modifications de la source sont transférées vers l'instance cible (migration en cours).

Chargement initial

Dans Cloud Shell, utilisez une connexion SSH pour vous connecter à l'instance Compute Engine qui exécute l'instance Redis OSS :

PROJECT_ID=$(gcloud info --format='value(config.project)')
$ gcloud compute ssh redis-oss-riot-vm --project $PROJECT_ID --zone us-central1-a

Lancez la CLI Redis :

redis-cli -u redis://ENDPOINT_IP:ENDPOINT_PORT \
-a REDIS_ENTERPRISE_DB_PASSWORD

Vérifiez que les six paires clé/valeur ont bien été migrées depuis Redis OSS vers l'instance Redis Enterprise :
```
SCAN 0
```
Le résultat est le suivant :
```
"swimmer"
"soccer"
"football"
"golf"
"tennis"
"basketball"
```
Obtenez la valeur de la clé Tennis :
```
get tennis
```
Le résultat est le suivant :
```
[return federer]
```
Quittez la CLI Redis :
```
exit
```

Migration en cours

Vérifiez que les modifications en cours apportées à Redis OSS source sont répercutées dans l'instance Redis Enterprise cible:

Dans Cloud Shell, utilisez une connexion SSH pour vous connecter à la VM Redis OSS.
Lancez la CLI Redis :
```
redis-cli
```
Ajoutez de nouvelles paires clé/valeur :
1. Ajoutez une nouvelle paire runner bolt :
```
set runner bolt
```
2. Effectuez un upsert sur une nouvelle paire tennis alcaraz :
```
set tennis alcaraz
```
Le résultat de chacune de ces commandes est le suivant :
```
OK
```
Dans l'instance Redis Enterprise, observez que de nouvelles paires clé/valeur ont été ajoutées :
```
get runner
```
Le résultat est le suivant :
```
[return bolt]
```
Pour vous assurer que toutes les paires clé/valeur sont présentes, vérifiez le nombre de clés :
```
redis-cli info keyspace and redis-cli -u <REMOTE> info keyspace
```
Le résultat est le suivant :
```
# Keyspace
db0:keys=7,expires=0,avg_ttl=0
```

Vous avez maintenant vérifié que la migration à chaud RIOT a migré automatiquement toutes les paires clé/valeur de l'instance Redis OSS source et toutes les modifications en cours vers la source.

Basculer de la source vers la cible

Après avoir vérifié la migration de la base de données, vous pouvez effectuer un basculement de l'instance Redis OSS source vers l'instance Redis Enterprise cible :

Suspendez l'accès en écriture du client à l'instance Redis OSS source à l'aide de la liste de contrôle d'accès Redis.
Sauf si vous devez conserver la base de données source pour votre stratégie de remplacement, mettez hors service la base de données Redis OSS source en supprimant l'instance de VM.
Migrez le client vers la même région que l'instance de base de données Redis Enterprise. Pour en savoir plus, consultez la documentation de votre hôte client.
Dans la console Redis, localisez le point de terminaison privé de l'instance de base de données Redis Enterprise et mettez à jour la connexion Redis de votre client vers le point de terminaison privé. Pour en savoir plus, consultez la page Afficher et modifier des bases de données dans la documentation Redis.
Dans Cloud Shell, arrêtez le processus RIOT en appuyant sur Ctrl+C.

Préparer une stratégie de remplacement

Une fois la bascule terminée, l'instance Redis Enterprise cible est le système d'enregistrement. L'instance Redis OSS source est obsolète et finalement supprimée. Cependant, vous pouvez revenir à l'instance Redis OSS source en cas de défaillances graves de la nouvelle instance Redis Enterprise cible.

Pour éviter toute perte après ces défaillances, vous pouvez maintenir l'instance Redis OSS source d'origine à jour avec les modifications de la base de données cible. Lorsque vous êtes sûr que la nouvelle instance cible est fiable, vous pouvez arrêter l'instance source.

Effectuer un nettoyage

Les sections suivantes expliquent comment éviter les frais futurs pour votre projet Google Cloud et pour les ressources Redis que vous avez utilisées dans ce déploiement.

Supprimer le projet

Attention : La suppression d'un projet aura les effets suivants :

Tout le contenu du projet est supprimé. Si vous avez utilisé un projet existant pour les tâches de ce document, lorsque vous le supprimez, vous supprimez é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.

Dans la console Google Cloud, accédez à la page Gérer les ressources.
Accéder à la page Gérer les ressources
Dans la liste des projets, sélectionnez le projet que vous souhaitez supprimer, puis cliquez sur Supprimer.
Dans la boîte de dialogue, saisissez l'ID du projet, puis cliquez sur Arrêter pour supprimer le projet.

Supprimer la base de données Redis Enterprise

Pour supprimer la base de données Redis Enterprise, consultez la section Supprimer une base de données dans la documentation Redis.

Étapes suivantes

Découvrez comment définir le champ d'application de votre migration vers Redis Enterprise Cloud.
Consultez le contenu concernant la migration des données Google Cloud.
Pour une documentation plus détaillée et sur les bonnes pratiques, consultez la documentation RIOT.
Pour découvrir d'autres architectures de référence, schémas et bonnes pratiques, consultez le Centre d'architecture cloud.

Contributeurs

Auteurs :

Saurabh Kumar | ISV Partner Engineer
Gilbert Lau | Architecte cloud principal, Redis

Autres contributeurs :

Chris Mague | Ingénieur client, gestion des données
Gabe Weiss | Responsable Developer Advocacy
Marco Ferrari | Architecte de solutions cloud