Ce tutoriel explique comment migrer des données depuis Aerospike vers Bigtable. Il décrit les différences entre Aerospike et Bigtable, et explique comment transformer votre charge de travail pour qu'elle s'exécute dans Bigtable. Il s'adresse aux professionnels de base de données qui recherchent un service de base de données sur Google Cloud semblable à Aerospike. Ce tutoriel part du principe que vous maîtrisez les schémas de base de données, les types de données, les bases de NoSQL et les systèmes de bases de données relationnelles. Il repose sur l'exécution de tâches prédéfinies pour effectuer un exemple de migration. Une fois le tutoriel terminé, vous pouvez modifier le code fourni et les étapes en fonction de votre environnement.
Bigtable est un service de base de données NoSQL entièrement géré, à l'échelle du pétaoctet, pour les charges de travail analytiques et opérationnelles d'envergure. Vous pouvez l'utiliser comme moteur de stockage pour votre service à l'échelle du pétaoctet et à faible latence avec une disponibilité et une durabilité plus élevées. Vous pouvez analyser des données dans Bigtable à l'aide de services d'analyse de données Google Cloud tels que Dataproc et BigQuery.
Bigtable est la solution idéale pour les technologies publicitaires (ad tech), financières (fintech) et les services d'Internet des objets (IoT) mis en œuvre avec des bases de données NoSQL comme AeroSpike ou Cassandra. Si vous recherchez un service géré par NoSQL, utilisez Bigtable.
Architecture
Le schéma d'architecture de référence suivant montre les composants courants que vous pouvez utiliser pour migrer des données d'Aerospike vers Bigtable.
Dans le diagramme précédent, les données migrent à partir d'un environnement sur site utilisant Aerospike vers Bigtable sur Google Cloud à l'aide de deux méthodes différentes. La première méthode migre les données à l'aide du traitement par lot. Elle commence par déplacer les données de sauvegarde Aerospike dans un bucket Cloud Storage. Lorsque les données de sauvegarde arrivent dans Cloud Storage, Cloud Run déclenche un processus d'extraction, de transformation et de chargement (ETL) par lot à l'aide de Dataflow. La tâche Dataflow convertit les données de sauvegarde dans un format compatible avec Bigtable, puis les importe dans l'instance Bigtable.
La seconde méthode migre les données à l'aide du traitement par flux. Avec cette méthode, vous vous connectez à Aerospike à l'aide d'une file d'attente de messages, telle que Kafka à l'aide d'Aerospike Connect, puis vous transférez des messages en temps réel vers Pub/Sub sur Google Cloud. Lorsque le message arrive dans un sujet Pub/Sub, il est traité par la tâche de traitement Dataflow en temps réel qui convertit et importe les données dans l'instance Bigtable.
Le traitement par lot vous permet de migrer efficacement de grands fragments de données. Cependant, il nécessite souvent un temps d'arrêt de basculement suffisant pour effectuer la migration et la mise à jour du service pour les nouvelles bases de données. Pour réduire le temps d'arrêt de basculement, vous pouvez utiliser le traitement par flux, qui permet de migrer les données progressivement après un premier traitement par lot, afin de garantir la cohérence des données de sauvegarde jusqu'au basculement complet. Dans ce document, vous pouvez effectuer une migration depuis Aerospike à l'aide d'un traitement par lot et d'exemples d'applications, y compris le processus de basculement.
Comparaison d'Aerospike et de Bigtable
Avant de commencer la migration de données, il est essentiel de comprendre les différences entre les modèles de données d'Aerospike et de Bigtable.
Le modèle de données Bigtable est un mappage clé-valeur distribué, multidimensionnel et trié avec des lignes et des familles de colonnes. Quant au modèle de données Aerospike, il s'agit d'une base de données orientée ligne, où chaque enregistrement est identifié de manière unique par une clé. La différence entre ces modèles réside dans la façon dont ils regroupent les attributs d'une entité. Bigtable regroupe les attributs associés dans une famille de colonnes, tandis que Aerospike les regroupe dans un ensemble. Aerospike accepte davantage de types de données par rapport à Bigtable. Par exemple, Aerospike accepte des entiers, des chaînes, des listes et des mappages. Dans la plupart des cas, Bigtable traite toutes les données en tant que chaînes d'octets brutes.
Un schéma dans Aerospike est flexible, et les valeurs dynamiques dans des bins identiques peuvent avoir différents types. Les applications qui utilisent Aerospike ou Bigtable présentent une flexibilité et une responsabilité d'administration des données similaires : elles gèrent les types de données et les contraintes d'intégrité, au lieu de s'appuyer sur le moteur de base de données.
Migration vers Bookshelf
L'application Bookshelf est une application Web qui permet aux utilisateurs de stocker des informations sur les livres et de consulter la liste de tous les livres actuellement stockés dans la base de données. L'application utilise un identifiant de livre (ID) pour rechercher des informations sur un livre. L'application ou la base de données génère automatiquement ces ID. Lorsqu'un utilisateur sélectionne l'image d'un livre, le backend de l'application charge les détails de ce livre dans la base de données.
Dans ce tutoriel, vous allez migrer des données depuis l'application Bookshelf vers Bigtable à l'aide d'Aerospike. Après la migration, vous pouvez accéder aux livres depuis Bigtable.
Le schéma suivant montre comment les données sont migrées d'Aerospike vers Bigtable :
Dans le diagramme précédent, les données sont transférées de la manière suivante :
- Vous sauvegardez les données des livres à partir de la base de données Aerospike actuelle, puis vous les transférez vers un bucket Cloud Storage.
- Lorsque vous importez les données de sauvegarde dans le bucket, cela déclenche automatiquement la tâche Dataflow
as2bt
via des notifications de mise à jour Cloud Storage à l'aide de la fonction Cloud Run. - Une fois que la tâche Dataflow
as2bt
a terminé de migrer les données, vous remplacez le backend de base de données Aerospike par Bigtable de sorte que l'application Bookshelf charge les données des livres à partir du cluster Bigtable.
Objectifs
- Déployer un environnement de tutoriel pour effectuer une migration depuis Aerospike vers Bigtable
- Créer un ensemble de données de sauvegarde d'exemple d'application à partir d'Aerospike dans Cloud Storage
- Utiliser Dataflow pour transférer le schéma de données et le migrer vers Bigtable
- Modifier la configuration de l'exemple d'application afin d'utiliser Bigtable en tant que backend
- Vérifier que l'application Bookshelf s'exécute correctement avec Bigtable
Coûts
Dans ce document, vous utilisez les composants facturables suivants de Google Cloud :
Obtenez une estimation des coûts en fonction de votre utilisation prévue à l'aide du simulateur de coût.
Les frais Bigtable sont basés sur le nombre de nœuds-heure, la quantité de données stockées et la quantité de bande passante réseau que vous utilisez. Pour estimer le coût du cluster Bigtable et d'autres ressources, vous pouvez utiliser le simulateur de coût. La configuration de l'exemple du simulateur de coût utilise trois nœuds Bigtable au lieu d'un seul nœud. Le coût total estimé dans l'exemple précédent est supérieur au coût total réel de ce tutoriel.
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
-
In the Google Cloud console, on the project selector page, select or create a Google Cloud project.
-
Make sure that billing is enabled for your Google Cloud project.
-
Enable the Cloud Resource Manager API.
Terraform utilise l'API Cloud Resource Manager pour activer les API dont vous avez besoin pour ce tutoriel.
-
In the Google Cloud console, activate Cloud Shell.
Préparer l'environnement
Pour préparer l'environnement de la migration d'Aerospike vers Bigtable, exécutez les outils suivants directement à partir de Cloud Shell :
- Google Cloud CLI
- L'outil de ligne de commande Bigtable,
cbt
- Terraform
- Apache Maven
Ces outils sont déjà disponibles dans Cloud Shell. Vous n'avez donc pas besoin de les installer à nouveau.
Configurer votre projet
Dans Cloud Shell, vérifiez l'ID du projet configuré automatiquement par Cloud Shell. Votre invite de commande est mise à jour pour refléter le projet actuellement actif et s'affiche au format suivant :
USERNAME@cloudshell:~ (PROJECT_ID)$
.Si l'ID du projet n'est pas configuré correctement, vous pouvez le configurer manuellement en procédant comme suit :
gcloud config set project <var>PROJECT_ID</var>
Remplacez
PROJECT_ID
par l'ID de votre projet Google Cloud.Configurez
us-east1
comme région etus-east1-b
comme zone :gcloud config set compute/region us-east1 gcloud config set compute/zone us-east1-b
Pour en savoir plus sur les régions et les zones, consultez la section Zones géographiques et régions.
Déployer l'environnement de tutoriel
Dans Cloud Shell, clonez le dépôt de code :
git clone https://github.com/fakeskimo/as2bt.git/
Dans Cloud Shell, initialisez le répertoire de travail Terraform :
cd "$HOME"/as2bt/bookshelf/terraform terraform init
Configurez des variables d'environnement Terraform pour le déploiement :
export TF_VAR_gce_vm_zone="$(gcloud config get-value compute/zone)" export TF_VAR_gcs_bucket_location="$(gcloud config get-value compute/region)"
Examinez le plan d'exécution Terraform :
terraform plan
Le résultat ressemble à ce qui suit :
Terraform will perform the following actions: # google_bigtable_instance.bookshelf_bigtable will be created + resource "google_bigtable_instance" "bookshelf_bigtable" { + display_name = (known after apply) + id = (known after apply) + instance_type = "DEVELOPMENT" + name = "bookshelf-bigtable" + project = (known after apply) + cluster { + cluster_id = "bookshelf-bigtable-cluster" + storage_type = "SSD" + zone = "us-east1-b" } }
(Facultatif) Pour visualiser les ressources ayant des dépendances déployées par Terraform, tracez des graphes :
terraform graph | dot -Tsvg > graph.svg
Provisionnez l'environnement de tutoriel :
terraform apply
Vérifier l'environnement de tutoriel et l'application Bookshelf
Une fois que vous avez provisionné l'environnement et avant de démarrer la tâche de migration de données, vous devez vérifier que toutes les ressources ont été déployées et configurées. Cette section explique comment vérifier le processus de provisionnement et vous permet de comprendre quels composants sont configurés dans l'environnement.
Vérifier l'environnement de tutoriel
Dans Cloud Shell, vérifiez l'instance Compute Engine
bookshelf-aerospike
:gcloud compute instances list
Le résultat indique que l'instance est déployée dans la zone
us-east1-b
:NAME ZONE MACHINE_TYPE PREEMPTIBLE INTERNAL_IP EXTERNAL_IP STATUS bookshelf-aerospike us-east1-b n1-standard-2 10.142.0.4 34.74.72.3 RUNNING
Vérifiez l'instance Bigtable
bookshelf-bigtable
:gcloud bigtable instances list
Le résultat ressemble à ce qui suit :
NAME DISPLAY_NAME STATE bookshelf-bigtable bookshelf-bigtable READY
Cette instance Bigtable servira de cible de migration lors des prochaines étapes.
Vérifiez que le bucket Cloud Storage
bookshelf
se trouve dans la tâche de pipeline Dataflow :gcloud storage ls gs://bookshelf-* --buckets
Étant donné que les noms de buckets Cloud Storage doivent être uniques, le nom du bucket est créé avec un suffixe aléatoire. Le résultat ressemble à ce qui suit :
gs://bookshelf-616f60d65a3abe62/
Ajouter un livre dans l'application Bookshelf
Dans Cloud Shell, obtenez l'adresse IP externe de l'instance
bookshelf-aerospike
:gcloud compute instances list --filter="name:bookshelf-aerospike" \ --format="value(networkInterfaces[0].accessConfigs.natIP)"
Notez l'adresse IP, car vous en aurez besoin à l'étape suivante.
Pour ouvrir l'application Bookshelf, accédez à
http://IP_ADDRESS:8080
dans un navigateur Web.Remplacez
IP_ADDRESS
par l'adresse IP externe que vous avez copiée à l'étape précédente.Pour créer un livre, cliquez sur
Ajouter un livre.Dans la fenêtre Ajouter un livre, remplissez les champs suivants, puis cliquez sur Enregistrer :
- Dans le champ Title (Titre), saisissez
Aerospike-example
. - Dans le champ Author (Auteur), saisissez
Aerospike-example
. - Dans le champ Date de publication, saisissez la date du jour.
- Dans le champ Description, saisissez
Aerospike-example
.
Ce livre permet de vérifier que l'application Bookshelf utilise Aerospike en tant que stockage pour les livres.
- Dans le champ Title (Titre), saisissez
Dans l'URL de l'application Bookshelf, notez l'ID du livre. Par exemple, si l'URL est
34.74.80.160:8080/books/10000
, l'ID du livre est10000
.Dans Cloud Shell, utilisez SSH pour vous connecter à l'instance
bookshelf-aerospike
:gcloud compute ssh bookshelf-aerospike
Dans la session d'instance
bookshelf-aerospike
, vérifiez qu'un nouveau livre a été créé avec l'ID de livre que vous avez noté précédemment :aql -c 'select * from bookshelf.books where id = "BOOK_ID"'
Le résultat ressemble à ce qui suit :
+----------------------+----------------------+---------------+----------------------+----------+---------+ | title | author | publishedDate | description | imageUrl | id | +----------------------+----------------------+---------------+----------------------+----------+---------+ | " Aerospike-example" | " Aerospike-example" | "2000-01-01" | " Aerospike-example" | "" | "10000" | +----------------------+----------------------+---------------+----------------------+----------+---------+ 1 row in set (0.001 secs)
Si votre ID de livre ne figure pas dans la liste, répétez la procédure pour ajouter un livre.
Transférer des données de sauvegarde depuis Aerospike vers Cloud Storage
Dans Cloud Shell, créez un fichier de sauvegarde Aerospike à partir de la session d'instance
bookshelf-aerospike
:aql -c "select * from bookshelf.books" --timeout=-1 --outputmode=json \` | tail -n +2 | jq -c '.[0] | .[]' \ | gcloud storage cp - $(gcloud storage ls gs://bookshelf-* --buckets)bookshelf-backup.json
Cette commande traite les données et crée un fichier de sauvegarde selon le processus suivant :
- Sélectionne les informations de livre à partir d'Aerospike et les imprime au format JSON.
- Supprime les deux premiers en-têtes de la sortie et convertit les données au format JSON délimité par un retour à la ligne (ndjson) à l'aide de
jq
, un processeur JSON de ligne de commande. - Utilise la gcloud CLI pour importer les données dans le bucket Cloud Storage.
Vérifiez que le fichier de sauvegarde Aerospike est importé et qu'il existe dans le bucket Cloud Storage :
gcloud storage ls gs://bookshelf-*/bookshelf-*\ gs://bookshelf-616f60d65a3abe62/bookshelf-backup.json
(Facultatif) Vérifiez le contenu du fichier de sauvegarde à partir du bucket Cloud Storage :
gcloud storage cat -r 0-1024 gs://bookshelf-*/bookshelf-backup.json | head -n 2
Le résultat ressemble à ce qui suit :
{"title":"book_2507","author":"write_2507","publishedDate":"1970-01-01","imageUrl":"https://storage.googleapis.com/aerospike2bt-bookshelf/The_Home_Edit-2019-06-24-044906.jpg","description":"test_2507","createdBy":"write_2507","createdById":"2507_anonymous","id":"2507"} {"title":"book_3867","author":"write_3867","publishedDate":"1970-01-01","imageUrl":"https://storage.googleapis.com/aerospike2bt-bookshelf/The_Home_Edit-2019-06-24-044906.jpg","description":"test_3867","createdBy":"write_3867","createdById":"3867_anonymous","id":"3867"}
Quittez la session SSH et revenez à Cloud Shell :
exit
Migrer les données de sauvegarde vers Bigtable à l'aide de Dataflow
Vous pouvez maintenant migrer les données de sauvegarde depuis Cloud Storage vers une instance Bigtable. Cette section explique comment utiliser les pipelines Dataflow pour migrer des données compatibles avec un schéma Bigtable.
Configurer la tâche de migration Dataflow
Dans Cloud Shell, accédez au répertoire
dataflow
de l'exemple de dépôt de code :cd "$HOME"/as2bt/dataflow/
Configurez des variables d'environnement pour une tâche Dataflow :
export BOOKSHELF_BACKUP_FILE="$(gcloud storage ls gs://bookshelf*/bookshelf-backup.json)" export BOOKSHELF_DATAFLOW_ZONE="$(gcloud config get-value compute/zone)"
Vérifiez que les variables d'environnement sont correctement configurées :
env | grep BOOKSHELF
Si les variables d'environnement sont correctement configurées, le résultat ressemble à ce qui suit :
BOOKSHELF_BACKUP_FILE=gs://bookshelf-616f60d65a3abe62/bookshelf-backup.json BOOKSHELF_DATAFLOW_ZONE=us-east1-b
Exécuter la tâche Dataflow
Dans Cloud Shell, migrez les données de Cloud Storage vers l'instance Bigtable :
./run_oncloud_json.sh
Pour surveiller la tâche de migration des données de sauvegarde, accédez à la page Tâches dans Google Cloud Console.
Attendez la fin de la tâche. Une fois la tâche terminée, le résultat dans Cloud Shell est semblable à celui-ci :
Dataflow SDK version: 2.13.0 Submitted job: 2019-12-16_23_24_06-2124083021829446026 [INFO] ------------------------------------------------------------------------ [INFO] BUILD SUCCESS [INFO] ------------------------------------------------------------------------ [INFO] Total time: 08:20 min [INFO] Finished at: 2019-12-17T16:28:08+09:00 [INFO] ------------------------------------------------------------------------
Vérifier les résultats de la tâche de migration
Dans Cloud Shell, vérifiez que les données de sauvegarde ont été correctement transférées dans Bigtable :
cbt -instance bookshelf-bigtable lookup books 00001
Le résultat ressemble à ce qui suit :
---------------------------------------- 00001 info:author @ 2019/12/17-16:26:04.434000 "Aerospike-example" info:description @ 2019/12/17-16:26:04.434000 "Aerospike-example" info:id @ 2019/12/17-16:26:04.434000 "00001" info:imageUrl @ 2019/12/17-16:26:04.434000 "" info:publishedDate @ 2019/12/17-16:26:04.434000 "2019-10-01" info:title @ 2019/12/17-16:26:04.434000 "Aerospike-example"
Migrer la base de données "bookshelf" d'Aerospike vers Bigtable
Après avoir migré les données depuis Aerospike vers Bigtable, vous pouvez modifier la configuration de l'application Bookshelf pour qu'elle utilise Bigtable pour le stockage. Lorsque vous réalisez cette configuration, les nouveaux livres sont enregistrés dans les instances Bigtable.
Modifier la configuration de l'application Bookshelf
Dans Cloud Shell, utilisez SSH pour vous connecter à l'application
bookshelf-aerospike
:gcloud compute ssh bookshelf-aerospike
Vérifiez que la configuration
DATA_BACKEND
actuelle estaerospike
:grep DATA_BACKEND /opt/app/bookshelf/config.py
Le résultat est le suivant :
DATA_BACKEND = 'aerospike'
Remplacez la configuration de
DATA_BACKEND
aerospike
parbigtable
:sudo sed -i "s/DATA_BACKEND =.*/DATA_BACKEND = 'bigtable'/g" /opt/app/bookshelf/config.py
Vérifiez que la configuration de
DATA_BACKEND
est définie surbigtable
:grep DATA_BACKEND /opt/app/bookshelf/config.py
Le résultat est le suivant :
DATA_BACKEND = 'bigtable'
Redémarrez l'application Bookshelf qui utilise la nouvelle configuration de backend
bigtable
:sudo supervisorctl restart bookshelf
Vérifiez que l'application Bookshelf a redémarré et s'exécute correctement :
sudo supervisorctl status bookshelf
Le résultat ressemble à ce qui suit :
bookshelf RUNNING pid 18318, uptime 0:01:00
Vérifier que l'application Bookshelf utilise le backend Bigtable
- Dans un navigateur, accédez à
http://IP_ADDRESS:8080
. Ajouter un livre nommé
Bigtable-example
.Pour vérifier que le livre
Bigtable-example
a été créé dans une instance Bigtable à partir de l'application Bookshelf, copiez l'ID du livre à partir de la barre d'adresse du navigateur.Dans Cloud Shell, recherchez les données du livre
Bigtable-example
à partir d'une instance Bigtable :cbt -instance bookshelf-bigtable lookup books 7406950188
Le résultat ressemble à ce qui suit :
---------------------------------------- 7406950188 info:author @ 2019/12/17-17:28:25.592000 "Bigtable-example" info:description @ 2019/12/17-17:28:25.592000 "Bigtable-example" info:id @ 2019/12/17-17:28:25.592000 "7406950188" info:image_url @ 2019/12/17-17:28:25.592000 "" info:published_date @ 2019/12/17-17:28:25.592000 "2019-10-01" info:title @ 2019/12/17-17:28:25.592000 "Bigtable-example"
Vous avez effectué une migration de données depuis Aerospike vers Bigtable, et vous avez modifié la configuration de Bookshelf pour vous connecter à un backend Bigtable.
Effectuer un nettoyage
Le moyen le plus simple d'éviter la facturation consiste à supprimer le projet Google Cloud que vous avez créé pour le tutoriel. Vous pouvez également supprimer les différentes ressources.
Supprimer le projet
- In the Google Cloud console, go to the Manage resources page.
- In the project list, select the project that you want to delete, and then click Delete.
- In the dialog, type the project ID, and then click Shut down to delete the project.
Étape suivante
- Découvrez comment concevoir votre schéma.
- Découvrez comment démarrer la migration vers Google Cloud.
- Configurez un pipeline CI/CD pour votre workflow de traitement des données
- Découvrez les stratégies à votre disposition pour transférer des ensembles de données volumineux.
- Découvrez des architectures de référence, des schémas et des bonnes pratiques concernant Google Cloud. Consultez notre Cloud Architecture Center.