Avez-vous déjà eu envie d’exécuter des requêtes SQL sur Amazon DynamoDB tables sans impact sur vos charges de travail de production ? Ne serait-il pas formidable de le faire sans avoir à configurer une tâche ETL, puis à surveiller manuellement cette tâche ?

Dans ce blog, je vais expliquer comment Ensemble de fusée s’intègre à DynamoDB et met automatiquement à jour en permanence une collection à mesure que de nouveaux objets sont ajoutés à une table DynamoDB. Je vais expliquer les étapes à suivre pour configurer une intégration en direct entre Rockset et une table DynamoDB et y exécuter du SQL avec une latence de la milliseconde.

Intégration DynamoDB

Amazon DynamoDB est une base de données clé-valeur et documents dans laquelle la clé est spécifiée au moment de la création de la table. DynamoDB prend en charge les opérations d’analyse sur un ou plusieurs éléments et capture également l’activité des tables à l’aide de Flux DynamoDB. Grâce à ces fonctionnalités, Rockset ingère en continu les données de DynamoDB en deux étapes :

1. La première fois qu’un utilisateur crée une collection provenant de DynamoDB, Rockset effectue une analyse complète de la table DynamoDB.
2. Une fois l’analyse terminée, Rockset traite en continu les flux DynamoDB pour prendre en compte les enregistrements nouveaux ou modifiés.

Pour garantir que Rockset ne perd aucune nouvelle donnée enregistrée dans la table DynamoDB lors de l’analyse, Rockset active analyses fortement cohérentes dans le connecteur Rockset-DynamoDB, et crée également des flux DynamoDB (s’ils ne sont pas déjà présents) et enregistre les numéros de séquence des fragments existants. L’étape de traitement continu (étape 2 ci-dessus) traite les flux DynamoDB à partir du numéro de séquence enregistré avant l’analyse.

Les valeurs de clé primaire de la table DynamoDB sont utilisées pour construire le _id champ dans Rockset pour identifier de manière unique un document dans une collection Rockset. Cela garantit que les mises à jour d’un élément existant dans la table DynamoDB sont appliquées au document correspondant dans Rockset.

Connexion de DynamoDB à Rockset

Pour cet exemple, j’ai créé une table DynamoDB par programmation utilisant un Ensemble de données Hacker News. L’ensemble de données comprend des données sur chaque publication et commentaire sur le site Web. Chaque champ de l’ensemble de données est décrit ici. J’ai inclus un échantillon de cet ensemble de données dans notre référentiel de recettes.

Le tableau a été créé à l’aide de id comme clé de partition pour DynamoDB. De plus, j’ai dû masser l’ensemble de données car DynamoDB n’accepte pas les valeurs de chaîne vides. Avec Rockset, comme vous le verrez dans les prochaines étapes, vous n’avez pas besoin d’effectuer de telles opérations ETL ni de fournir des définitions de schéma pour créer une collection et la rendre immédiatement interrogeable via SQL.

Créer une collection Rockset

j’utiliserai le Client Python Rockset pour créer une collection soutenue par une table DynamoDB. Pour essayer cela dans votre environnement, vous devrez créer un L’intégration (un objet qui représente vos informations d’identification AWS) et configurez les autorisations sur la table DynamoDB, ce qui permet à Rockset d’effectuer certaines opérations de lecture sur cette table.

from rockset import Client
rs=Client(api_key=...)

aws_integration=rs.Integration.retrieve("aws-rockset")
sources=[
    rs.Source.dynamo(
        table_name="rockset-demo",
        integration=aws_integration)]
rockset_dynamodb_demo=rs.Collection.create("rockset-dynamodb-demo", sources=sources)

Alternativement, des collections provenant de DynamoDB peuvent également être créées à partir du Rockset consolecomme indiqué ci-dessous.

Exécuter SQL sur des données DynamoDB

Chaque document dans Rockset correspond à une ligne de la table DynamoDB. Rockset déduit automatiquement le schéma, comme indiqué ci-dessous.

rockset> describe "rockset-dynamodb-demo";
+---------------------------------+---------------+----------+-----------+
| field                           | occurrences   | total    | type      |
|---------------------------------+---------------+----------+-----------|
| ['_event_time']                 | 18926775      | 18926775 | timestamp |
| ['_id']                         | 18926775      | 18926775 | string    |
| ['_meta']                       | 18926775      | 18926775 | object    |
| ['_meta', 'dynamodb']           | 18926775      | 18926775 | object    |
| ['_meta', 'dynamodb', 'table']  | 18926775      | 18926775 | string    |
| ['by']                          | 18926775      | 18926775 | string    |
| ['dead']                        | 890827        | 18926775 | bool      |
| ['deleted']                     | 562904        | 18926775 | bool      |
| ['descendants']                 | 2660205       | 18926775 | string    |
| ['id']                          | 18926775      | 18926775 | string    |
| ['parent']                      | 15716204      | 18926775 | string    |
| ['score']                       | 3045941       | 18926775 | string    |
| ['text']                        | 18926775      | 18926775 | string    |
| ['time']                        | 18899951      | 18926775 | string    |
| ['title']                       | 18926775      | 18926775 | string    |
| ['type']                        | 18926775      | 18926775 | string    |
| ['url']                         | 18926775      | 18926775 | string    |
+---------------------------------+---------------+----------+-----------+

Nous sommes maintenant prêts à exécuter du SQL rapide sur les données de notre table DynamoDB. Écrivons quelques requêtes pour obtenir des informations sur cet ensemble de données.

Puisque nous sommes clairement intéressés par le sujet des données, voyons à quelle fréquence les gens ont discuté ou partagé des « données » sur Hacker News au fil des ans. Dans cette requête, je tokenise le titleen extrayant l’année du time champ, et renvoyant le nombre d’occurrences de « données » dans les jetons, regroupés par année.

with title_tokens as (
    select rows.tokens as token, subq.year as year
      from (
        select tokenize(title) as title_tokens,
               EXTRACT(YEAR from DATETIME(TIMESTAMP_SECONDS(time::int))) as year
        from "rockset-dynamodb-demo"
    ) subq, unnest(title_tokens as tokens) as rows
)
select year, count(token) as stories
from title_tokens
where lower(token) = 'data'
group by year order by year

+-----------+------+
| stories   | year |
|-----------+------|
| 176       | 2007 |
| 744       | 2008 |
| 1371      | 2009 |
| 2192      | 2010 |
| 3624      | 2011 |
| 4621      | 2012 |
| 6164      | 2013 |
| 6020      | 2014 |
| 7224      | 2015 |
| 7878      | 2016 |
| 8159      | 2017 |
| 8438      | 2018 |
+-----------+------+

En utilisant Intégration d’Apache Superset avec Rockset, j’ai tracé un graphique avec les résultats. (Il est possible d’utiliser des outils de visualisation de données comme Tableau, Redashet Grafana aussi.)

Le nombre d’histoires concernant les données a clairement augmenté au fil du temps.

Ensuite, exploitons l’ensemble de données Hacker News pour des observations sur l’une des technologies les plus discutées des deux dernières années, la blockchain. Vérifions d’abord l’évolution de l’engagement des utilisateurs autour de la blockchain et des crypto-monnaies.

with title_tokens as (
    select rows.tokens as token, subq.year as year
      from (
        select tokenize(title) as title_tokens,
               EXTRACT(YEAR from DATETIME(TIMESTAMP_SECONDS(time::int))) as year
        from "rockset-dynamodb-demo"
    ) subq, unnest(title_tokens as tokens) as rows
)
select year, count(token) as count
from title_tokens
where lower(token) = 'crypto' or lower(token) = 'blockchain'
group by year order by year

+---------------+--------+
| count         | year   |
|---------------+--------|
| 6             | 2008   |
| 26            | 2009   |
| 35            | 2010   |
| 43            | 2011   |
| 75            | 2012   |
| 278           | 2013   |
| 431           | 2014   |
| 750           | 2015   |
| 1383          | 2016   |
| 2928          | 2017   |
| 5550          | 2018   |
+-----------+------------+

Comme vous pouvez le constater, l’intérêt pour la blockchain a énormément augmenté en 2017 et 2018. Les résultats vont également dans ce sens. étudequi estime que le nombre d’utilisateurs de crypto a doublé en 2018.

En plus de la blockchain, des centaines de crypto-monnaies ont également vu le jour. Trouvons les pièces les plus populaires dans notre ensemble de données.

with crypto_text_tokens as (
    select rows.tokens as token
      from (
        select tokenize(text) as text_tokens
        from (
            select text as text
            from "rockset-dynamodb-demo" 
            where text like '%crypto%' or text like '%blockchain%'
        ) subq
    ) subq, unnest(text_tokens as tokens) as rows
)
select token, count(token) as count
from crypto_text_tokens
where token like '_%coin'
group by token
order by count desc
limit 10;

+---------+------------+
| count   | token      |
|---------+------------|
| 29197   | bitcoin    |
| 512     | litecoin   |
| 454     | dogecoin   |
| 433     | cryptocoin |
| 362     | namecoin   |
| 239     | altcoin    |
| 219     | filecoin   |
| 122     | zerocoin   |
| 81      | stablecoin |
| 69      | peercoin   |
+---------+------------+

Bitcoincomme on aurait pu le deviner, semble être la crypto-monnaie la plus populaire dans nos données Hacker News.

Résumé

Dans tout ce processus, j’ai simplement créé une collection Rockset avec une source DynamoDB, sans aucune transformation de données ni modélisation de schéma, et j’ai immédiatement exécuté des requêtes SQL dessus. En utilisant Rockset, vous aussi pouvez joindre des données sur différentes tables DynamoDB ou autre sources pour alimenter vos applications en direct.

Autres ressources DynamoDB :