Migrer d'Aerospike vers Bigtable

Last reviewed 2024-10-16 UTC

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.

Composants du processus de transfert de données depuis 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 en flux continu. 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 :

Procédure de migration des données

Dans le diagramme précédent, les données sont transférées de la manière suivante :

  1. 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.
  2. 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.
  3. 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 nouveaux utilisateurs de Google Cloud peuvent bénéficier d'un essai gratuit.

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

  1. In the Google Cloud console, on the project selector page, select or create a Google Cloud project.

    Go to project selector

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

  3. Enable the Cloud Resource Manager API.

    Enable the API

    Terraform utilise l'API Cloud Resource Manager pour activer les API dont vous avez besoin pour ce tutoriel.

  4. In the Google Cloud console, activate Cloud Shell.

    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

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

  2. Configurez us-east1 comme région et us-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

  1. Dans Cloud Shell, clonez le dépôt de code :

     git clone https://github.com/fakeskimo/as2bt.git/

  2. Dans Cloud Shell, initialisez le répertoire de travail Terraform :

    cd "$HOME"/as2bt/bookshelf/terraform
terraform init

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

  4. 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"
    }
}

  5. (Facultatif) Pour visualiser les ressources ayant des dépendances déployées par Terraform, tracez des graphes :

    terraform graph | dot -Tsvg > graph.svg

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

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

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

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

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

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

  3. Pour créer un livre, cliquez sur Ajouter un livre.

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

  5. 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 est 10000.

    ID du livre dans l&#39;URL.

  6. Dans Cloud Shell, utilisez SSH pour vous connecter à l'instance bookshelf-aerospike :

    gcloud compute ssh bookshelf-aerospike

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

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

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

  3. (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"}

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

  1. Dans Cloud Shell, accédez au répertoire dataflow de l'exemple de dépôt de code :

    cd "$HOME"/as2bt/dataflow/

  2. 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)"

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

  1. Dans Cloud Shell, migrez les données de Cloud Storage vers l'instance Bigtable :

    ./run_oncloud_json.sh

  2. Pour surveiller la tâche de migration des données de sauvegarde, accédez à la page Tâches dans Google Cloud Console.

    Accéder aux tâches

    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

  1. Dans Cloud Shell, utilisez SSH pour vous connecter à l'application bookshelf-aerospike :

    gcloud compute ssh bookshelf-aerospike

  2. Vérifiez que la configuration actuelle de DATA_BACKEND est aerospike:

    grep DATA_BACKEND /opt/app/bookshelf/config.py

    Le résultat est le suivant :

    DATA_BACKEND = 'aerospike'

  3. Remplacez la configuration de DATA_BACKEND aerospike par bigtable :

    sudo sed -i "s/DATA_BACKEND =.*/DATA_BACKEND = 'bigtable'/g" /opt/app/bookshelf/config.py

  4. Vérifiez que la configuration de DATA_BACKEND est définie sur bigtable :

    grep DATA_BACKEND /opt/app/bookshelf/config.py

    Le résultat est le suivant :

    DATA_BACKEND = 'bigtable'

  5. Redémarrez l'application Bookshelf qui utilise la nouvelle configuration de backend bigtable :

    sudo supervisorctl restart bookshelf

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

  1. Dans un navigateur, accédez à http://IP_ADDRESS:8080.

  2. Ajouter un livre nommé Bigtable-example.

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

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

  1. In the Google Cloud console, go to the Manage resources page.

    Go to Manage resources

  2. In the project list, select the project that you want to delete, and then click Delete.
  3. In the dialog, type the project ID, and then click Shut down to delete the project.

Étape suivante