Suivi de parcours de navigation (clickstream) en temps réel avec Amazon Kinesis Data Analytics, AWS Glue et Amazon Athena

Les événements de parcours de navigation (appelé “clickstreams”) sont de petites portions de données qui sont générées en continu avec une vitesse et un volume élevés. Souvent, les événements de parcours de navigation sont générés par des actions de l’utilisateur, et il est intéressant de les analyser.

Vous pouvez en effet détecter le comportement d’un utilisateur sur un site web ou dans une application en analysant la séquence de clics qu’il effectue, le temps qu’il passe, l’endroit où il commence habituellement la navigation et la façon dont celle-ci se termine. En suivant ce comportement de l’utilisateur en temps réel, vous pouvez mettre à jour les recommandations, effectuer de l’A/B Testing avancé, déclencher des notifications en fonction de la durée de la session, et bien plus encore. Pour suivre et analyser ces événements, vous devez identifier et créer des sessions à partir de ceux-ci. Le processus d’identification des événements dans les données et de création de sessions est connu sous le nom de “sessionalization” (terme anglo-saxon).

La capture et le traitement des événements de parcours de navigation de données en temps réel peuvent être difficiles. Le nombre d’utilisateurs et de ressources web et mobiles augmente, tout comme le volume de données. Amazon Kinesis vous fournit les fonctionnalités nécessaires pour ingérer ces données en temps réel et générer immédiatement des statistiques utiles afin que vous puissiez agir.

Lorsque vous exécutez une session sur des données de parcours de navigation, vous identifiez des événements et les affectez à une session avec une clé et une période de décalage spécifiées. Lorsque chaque événement a une clé, vous pouvez effectuer des analyses sur ces événements. Les cas d’utilisation de la “sessionalization” varient considérablement et ont des exigences différentes. Par exemple, vous auriez besoin d’identifier et de créer des sessions à partir des événements dans l’analyse web pour suivre les actions des utilisateurs. La “sessionalization” est également utilisée dans de nombreux domaines différents, tels que les données de log ou l’analyse de comportement pour des objets connectés.

Cet article montre comment identifier et créer des sessions à partir des événements de parcours de navigation en temps réel, puis comment les analyser à l’aide d’Amazon Kinesis Data Analytics.

Pourquoi avons-nous choisi Amazon Kinesis Data Analytics ?

Les données de parcours de navigation arrivent continuellement sous forme de milliers de messages par seconde recevant de nouveaux événements. Lorsque vous analysez l’efficacité de nouvelles fonctionnalités d’une application, de la présentation d’un site ou de campagnes de marketing, il est important de les analyser en temps réel afin de pouvoir agir plus rapidement.

Pour effectuer la “sessionalization” en mode batch, vous pouvez utiliser un outil tel que AWS Glue ou Amazon EMR. Mais avec des programmes, des requêtes et des agrégations quotidiennes, cela peut prendre plus de ressources et de temps car chaque agrégation implique de travailler avec de grandes quantités de données. L’exécution de la “sessionalization” dans Amazon Kinesis Data Analytics prend moins de temps et vous donne une latence plus faible entre la génération des sessions et leur utilisation. Vous pouvez déclencher alors des alertes en temps réel avec les fonctions AWS Lambda en fonction de conditions, telles qu’une durée de session inférieure à 20 secondes, ou appeler un endpoint (point de terminaison) de Machine Learning pour de la recommandation par exemple, etc

Identification d’une session parmi des milliers de clics

Une session est un échange interactif et de courte durée entre deux ou plusieurs appareils et/ou utilisateurs. Il s’agit, par exemple, d’un utilisateur qui navigue et quitte votre site web, ou d’un appareil connecté qui se réveille pour effectuer un travail et se rendort ensuite. Ces interactions donnent lieu à une série d’événements qui se succèdent et qui commencent et se terminent, c’est ce qu’on appelle une session. Le début et la fin d’une session peuvent être difficiles à déterminer, et sont souvent définis par une période de temps sans qu’un événement pertinent soit associé à un utilisateur ou à un appareil. Une session commence lorsqu’un nouvel événement arrive après qu’une période de « décalage » ou « sommeil » spécifiée se soit écoulée sans l’arrivée d’un événement. Une session se termine de la même manière, lorsqu’un nouvel événement n’arrive pas dans la période de décalage spécifiée.

Cet article s’appuie sur plusieurs autres articles concernant l’exécution d’analyses par batch SQL sur des données de sessions. Nos vous recommandons la lecture des articles de référence sur ce sujet que sont “Sessionization in SQL, Hive, Pig and Python” de Dataiku et “Finding User Session with SQL” de Benn Stancil chez Mode (en anglais). Les deux articles tirent parti des requêtes à fenêtres (“SQL window functions”) pour identifier et construire des sessions à partir d’événements de parcours de navigation.

L’ANSI a ajouté les requêtes à fenêtres à la norme SQL en 2003 et les a étendues depuis (“SQL window functions”). Les requêtes à fenêtres fonctionnent naturellement avec les données en continu et vous permettent de traduire facilement des exemples SQL fonctionnant en mode batch vers Amazon Kinesis Data Analytics.

Dans ce cas d’utilisation, nous regroupons les événements d’un utilisateur spécifique comme décrit dans l’exemple simplifié suivant. Dans cet exemple, nous utilisons des schémas de navigation distincts de trois utilisateurs pour analyser le comportement de ces utilisateurs. Pour commencer, nous regroupons les événements par ID utilisateur pour obtenir des statistiques à partir des données, comme indiqué ci-dessous :

Dans cet exemple, pour l’utilisateur « User ID 20 », l’horodatage minimum est 2018-11-29 23:35:10 et l’horodatage maximum est 2018-11-29 23:35:44. Cela donne une session de 34 secondes, qui commence par l’action « B_10 » et se termine par l’action « A_02 ». Ces « actions » sont l’identification des boutons de l’application dans cet exemple.

Supposons qu’après plusieurs minutes, de nouvelles actions « User ID 20 » arrivent. Diriez-vous qu’elles sont exécutées dans la même session? Un utilisateur peut interrompre une navigation ou en démarrer une nouvelle. De plus, les applications ont souvent des délais d’attente. Vous devez décider quelle est la durée maximale de la session pour la considérer comme une nouvelle session. Une session peut durer entre 20 et 50 secondes, ou entre 1 et 5 minutes, par exemple.

Il y a d’autres éléments que vous pouvez prendre en compte, comme l’adresse IP du client ou l’identifiant de la machine. Ces éléments vous permettent de séparer les sessions qui se déroulent sur des appareils différents.

Aperçu de la solution

Le scénario de bout en bout décrit dans cet article utilise Amazon Kinesis Data Streams pour capturer les données de parcours de navigation et Amazon Kinesis Data Analytics pour construire et analyser les sessions. Les analyses agrégées sont utilisées pour déclencher des événements en temps réel avec AWS Lambda et les envoyer ensuite à Amazon Kinesis Data Firehose. Amazon Kinesis Data Firehose envoie les données dans un bucket (compartiment) Amazon S3, où elles sont ingérées dans une table par un analyseur/crawler AWS Glue et mises à disposition pour des requêtes avec Amazon Athena. Vous pouvez utiliser cette table pour des analyses ad hoc.

Le schéma suivant montre une solution de “sessionalization” de bout en bout :

• Ingestion de données : Vous pouvez utiliser Amazon Kinesis Data Streams pour construire des applications personnalisées qui traitent ou analysent des données en streaming pour des besoins spécifiques. Amazon Kinesis Data Streams peut capturer et stocker en continu des téraoctets de données par heure provenant de centaines de milliers de sources, telles que les parcours de navigation de sites web, les transactions financières, les flux de médias sociaux, les journaux informatiques et les événements de suivi de localisation,
• “Sessionalization” des données : Amazon Kinesis Data Analytics est le moyen le plus simple de traiter des données en continu en temps réel avec du SQL standard sans avoir à apprendre de nouveaux langages de programmation ou de nouveaux frameworks de traitement. Avec Amazon Kinesis Data Analytics, vous pouvez faire des requêtes directement sur les données de streaming ou construire des applications de streaming complètes en utilisant SQL, afin d’obtenir des informations exploitables et ainsi répondre rapidement aux besoins de votre entreprise et de vos clients,
• Traitement et stockage des données : Le flux de “Sessionalization” est lu à partir d’Amazon Kinesis Data Analytics à l’aide d’une fonction AWS Lambda. La fonction déclenche deux événements : un premier pour le tableau de bord en temps réel dans Amazon CloudWatch et un second pour persister les données avec Amazon Kinesis Data Firehose,
• Analyse des données : AWS Glue est utilisé pour parcourir Amazon S3 et construire ou mettre à jour la définition des métadonnées des tables Amazon Athena. Amazon Athena est un service de requêtage interactif qui facilite l’analyse des données dans Amazon S3 en utilisant le langage SQL standard. Athena offre une connectivité à toute application utilisant des connecteurs JDBC ou ODBC,
• Visualisation des données : Amazon QuickSight est un outil de visualisation qui est utilisé pour construire des tableaux de bord sur les données d’Amazon Athena,
• Surveillance : Amazon CloudWatch est un outil qui vous permet de surveiller les activités de streaming, comme le nombre d’octets traités ou livrés par seconde, ou le nombre d’échecs.

Une fois que vous avez terminé l’étape de “Sessionalization” dans Amazon Kinesis Data Analytics, vous pouvez sortir des données dans différents outils. Par exemple, vous pouvez utiliser une fonction AWS Lambda pour traiter les données à la volée et prendre des mesures telles que l’envoi d’alertes par SMS ou le retour en arrière d’un déploiement. Pour savoir comment mettre en œuvre de tels flux de travail basés sur la sortie Lambda d’AWS, vous pourrez lire l’article en anglais suivante : “Implement Log Analytics using Amazon Kinesis Data Analytics”. Dans la suite de cet article, nous envoyons des données à Amazon CloudWatch, et construisons un tableau de bord de monitoring temps réel.

Simuler du trafic de navigation avec AWS Lambda

Pour simuler du trafic, vous pouvez utiliser une fonction AWS Lambda en Python avec des valeurs aléatoires, simulant une application de vente de bière.

Le même identifiant d’utilisateur peut avoir des sessions sur différents appareils, tels qu’une tablette, un navigateur ou une application sur smartphone. Cette information est capturée par l’ID de l’appareil. Par conséquent, les données de payload de la fonction AWS Lambda ont les paramètres suivants : un ID d’utilisateur, un ID d’appareil, un événement client et un horodatage client, comme le montre l’exemple suivant.

Voici le code du générateur de trafic de la fonction AWS Lambda, qui est programmée à l’aide des événements programmés de Amazon CloudWatch Events :

...def getReferrer():
    x = random.randint(1,5)
    x = x*50 
    y = x+30 
    data = {}
    data['user_id'] = random.randint(x,y)
    data['device_id'] = random.choice(['mobile','computer', 'tablet', 'mobile','computer'])
    data['client_event'] = random.choice(['beer_vitrine_nav','beer_checkout','beer_product_detail','beer_products','beer_selection','beer_cart'])
    now = datetime.datetime.now()
    str_now = now.isoformat()
    data['client_timestamp'] = str_now
    return data
def lambda_handler(event, context):...
        data = json.dumps(getReferrer())
        kinesis.put_record(
                StreamName='sessionsclicks',
                Data=data,
                PartitionKey='partitionkey')

En conséquence, les évènements sont envoyées à Amazon Kinesis Data Analytics :

Utilisation des requêtes à fenêtres dans Amazon Kinesis Data Analytics

Le regroupement de sessions nous permet de combiner tous les événements d’un identifiant d’utilisateur donné ou d’un identifiant d’appareil qui se sont produits pendant une période spécifique. Les requêtes SQL d’Amazon Kinesis Data Analytics dans votre code applicatif s’exécutent en continu sur les flux internes de l’application. Vous devez spécifier des requêtes délimitées en utilisant une fenêtre définie en termes de temps ou de lignes. Ces requêtes sont appelées requêtes à fenêtres.

Il y a trois types de requêtes à fenêtres dans Amazon Kinesis Data Analytics : les fenêtres défilantes (sliding window), les fenêtres bascules (Tumbling window) et les fenêtres stagger (Stagger window). Nous utilisons la fenêtre stagger (stagger window) parce qu’elle présente quelques bonnes caractéristiques pour le cas d’usage de la “Sessionalization”, comme suit :

• les fenêtres stagger s’ouvrent lorsque le premier événement correspondant à une condition de clé de partition arrive. Ainsi, pour chaque clé, il évalue sa fenêtre particulière par opposition aux autres requêtes à fenêtres qui évaluent une fenêtre unique pour toutes les clés de partition correspondantes,
• lorsque vous traitez des parcours de navigation, vous ne pouvez pas vous fier à l’ordre dans lequel les événements arrivent dans le flux, mais à la date à laquelle le flux a été généré. Les fenêtres staggers (stagger window) gèrent bien l’arrivée d’événements ne respectant par leur ordre. Le moment où la fenêtre est ouverte et celui où elle se ferme sont pris en compte sur la base de l’âge spécifié, qui est mesuré à partir du moment où la fenêtre s’est ouverte.

Afin de partitionner par l’horodatage, nous avons écris deux fonctions pour vous montrer comment partitionner les données à l’intervalle de seconde et de minute.

Dans Amazon Kinesis Data Analytics, SOURCE_SQL_STREAM_001 est par défaut le flux principal de la source. Dans notre cas, il reçoit le trafic de la source d’ Amazon Kinesis Data Streams.

Kinesis Data Analytics SQL – Créer un flux

La fonction suivante crée un flux afin de recevoir le résultat de la requête d’agrégation :

-- Créer un flux pour recevoir le résultat d'agrégation de la requête.
CREATE OR REPLACE STREAM "DESTINATION_SQL_STREAM"(
  session_id VARCHAR(60),
  user_id INTEGER,
  device_id VARCHAR(10),
  timeagg timestamp,
  events INTEGER,
  beginnavigation VARCHAR(32),
  endnavigation VARCHAR(32),
  beginsession VARCHAR(25),
  endsession VARCHAR(25),
  duration_sec INTEGER);

Kinesis Data Analytics SQL – Utilisation de la fonction « STEP » avec un intervalle de SECOND

La fonction suivante crée la fonction POMPE qui permet d’insérer le résultat de la requête dans le flux de destination en mode continu :

-- Créer la fonction POMPE
    CREATE OR REPLACE PUMP "WINDOW_PUMP_SEC" AS INSERT INTO "DESTINATION_SQL_STREAM"
-- Insérer dans le flux avec des données selectionnées.
    SELECT  STREAM
-- Construire ID de la session en utilisant user_ID+device_ID et horodatage
    UPPER(cast("user_id" as VARCHAR(3))|| '_' ||SUBSTRING("device_id",1,3)||cast( UNIX_TIMESTAMP(STEP("client_timestamp" by interval '30' second))/1000 as VARCHAR(20))) as session_id,"user_id" , "device_id",
-- Créer un horodatage arrondi commun pour cette session 
    STEP("client_timestamp" by interval '30' second),
-- Compter le nombre d événements et de clics sur cette session
    COUNT("client_event") events,
-- Quelle a été la première action de navigation
    first_value("client_event") as beginnavigation,
-- Quelle a été la dernière action de navigation    
    last_value("client_event") as endnavigation,
-- La minute et la seconde du début  
    SUBSTRING(cast(min("client_timestamp") AS VARCHAR(25)),15,19) as beginsession,
-- La minute et la seconde de la fin
    SUBSTRING(cast(max("client_timestamp") AS VARCHAR(25)),15,19) as endsession,
-- durée de la session    
    TSDIFF(max("client_timestamp"),min("client_timestamp"))/1000 as duration_sec
-- depuis le flux de source   
    FROM "SOURCE_SQL_STREAM_001"
-- en utilisant les fenêtres stagger, avec STEP à seconde pour l intervalle à la seconde 
    WINDOWED BY STAGGER (PARTITION BY "user_id", "device_id", STEP("client_timestamp" by interval '30' second) 
                RANGE INTERVAL '30' SECOND );

Kinesis Data Analytics SQL – Utilisation de la fonction « FLOOR » avec un intervalle de MINUTE

La fonction suivante crée la POMPE qui permet d’insérer le résultat de la requête dans le flux destinataire en mode continu :

-- Créer la fonction POMPE
    CREATE OR REPLACE PUMP "WINDOW_PUMP_MIN" AS INSERT INTO "DESTINATION_SQL_STREAM"
-- Insérer dans le flux avec des données selectionnées.
    SELECT  STREAM
-- Construire ID de la session en utilisant user_ID+device_ID et horodatage
    UPPER(cast("user_id" as VARCHAR(3))|| '_' ||SUBSTRING("device_id",1,3)||cast(UNIX_TIMESTAMP(FLOOR("client_timestamp" TO MINUTE))/1000 as VARCHAR(20))) as session_id,"user_id" , "device_id",
-- Créer un horodatage arrondi commun pour cette session
    FLOOR("client_timestamp" TO MINUTE),
-- Compter le nombre d événements et de clics sur cette session
    COUNT("client_event") events,
-- Quelle a été la première action de navigation
    first_value("client_event") as beginnavigation,
-- Quelle a été la dernière action de navigation
    last_value("client_event") as endnavigation,
-- La minute et la seconde du début 
    SUBSTRING(cast(min("client_timestamp") AS VARCHAR(25)),15,19) as beginsession,
-- La minute et la seconde de la fin
    SUBSTRING(cast(max("client_timestamp") AS VARCHAR(25)),15,19) as endsession,
-- durée de la session
    TSDIFF(max("client_timestamp"),min("client_timestamp"))/1000 as duration_sec
-- depuis le flux de source
    FROM "SOURCE_SQL_STREAM_001"
-- en utilisant les fenêtres stagger, avec STEP à minute pour l intervalle à la minute
    WINDOWED BY STAGGER (PARTITION BY "user_id", "device_id", FLOOR("client_timestamp" TO MINUTE) 
            RANGE INTERVAL '1' MINUTE);

Sessions

Dans Amazon Kinesis Data Analytics, vous pouvez visualiser les données résultantes transformées par les requêtes SQL, avec l’identification et les informations des sessions. L’ID_session est calculé par l’ID_utilisateur + (3 caractères) de l’ID_appareil + l'horodatage Unix arrondi sans les millisecondes.

Déploiement automatisé avec AWS CloudFormation

Toutes les étapes de cette solution sont inclues dans un modèle AWS CloudFormation. Lancez le modèle, ajoutez le code sur votre serveur web, et voilà, vous obtenez la sessionalisation en temps réel.

Ce modèle AWS CloudFormation est destiné à être déployé uniquement dans la région us-east-1.

Afin de déployer la solution sur une autre région, vous pourrez télécharger l’ensemble des fichiers avec la commande ci-dessous :

aws s3 cp s3://aws-bigdata-blog/artifacts/realtime-clickstream-sessions-analytics-kinesis-glue-athena/ . --recursive

Ensuite, vous créez un compartiment S3 dans la région souhaitée et y ajoutez ces fichiers téléchargés. Vous devez aussi mettre à jour le lien vers les fichiers dans le modèle CloudFormation :

• S3Bucket : modifier la valeur avec le nouveau compartiment que vous venez de créer,
• S3Key : modifier la valeur avec le nouveau lien vers le fichier “createapp-lambda.zip”.

Création de la Stack

Étape 1 : Pour commencer, connectez-vous à la console AWS, puis ouvrez le modèle de fenêtre stagger.

Étape 2 : Dans la console AWS CloudFormation, choisissez “Next”, et complétez les paramètres AWS CloudFormation :

• Stack name : Le nom de la pile (blog-sessionnalisation ou sessions-blog)
• StreamName : sessionsblog
• Stream Shard Count : 1 ou 2 (1 MB/s) par partition.
• Bucket Name : Changer à un nom unique, par exemple session-n-bucket-hhug123121.
• Buffer Interval : 60-900 secondes de mise en mémoire tampon avant que les données soient envoyées à Amazon S3 par Kinesis Data Firehose.
• Buffer Size : 1-128 Mo par fichier, si l’intervalle n’est pas atteint avant.
• Destination Prefix : Agrégée (dossier interne du compartiment pour sauvegarder les données agrégées).
• Base sessions on seconds or minutes : Choisissez celle que vous voulez (les minutes commencent par 1 minute, les secondes par 30 secondes).

Étape 3 : Vérifiez si le lancement est terminé et, si ce n’est pas le cas, vérifiez s’il y a des erreurs.
L’erreur la plus courante est lorsque vous pointez vers un compartiment Amazon S3 qui existe déjà.

Traitement des données

Étape 1 : Après le déploiement, naviguez vers le service sur la console Amazon Kinesis.

Étape 2 : Allez sur la page des applications d’analyse, et choisissez AnalyticsApp-blog-sessionizationXXXXX, comme suit :

Étape 3 : Cliquez Exécuter l’application pour démarrer l’application :

Étape 4 : Attendez quelques secondes que l’application soit disponible, puis cliquez le nom de l’application pour aller sur la page du détail :

Étape 5 : Sur la page Détails de l’application, choisissez Accéder aux résultats SQL.

Étape 6 : Examinez le code SQL et SOURCE_SQL_STREAM, et modifiez l’INTERVALLE si vous le souhaitez.

Étape 7 : Choisissez l’onglet Analyse en temps réel pour vérifier les résultats de DESTINATION_SQL_STREAM

Étape 8 : Cochez l’onglet Destination pour afficher la fonction AWS Lambda comme destination de votre agrégation.

Étape 9 : Vérifiez le dashboard CloudWatch real-time correspondant. Ouvrez le tableau de bord Sessionization-<votre nom de la pile de cloudformation>.

Vérifiez le nombre d' »événements » pendant les sessions, et le comportement de la « durée de la session » par rapport à une période donnée. Vous pourrez alors prendre des décisions, par exemple pour savoir si vous devez revenir en arrière sur une nouvelle présentation du site ou sur de nouvelles fonctionnalités de votre application.

Étape 9 : Ouvrez la console AWS Glue et lancez l’analyseur que le modèle AWS CloudFormation a créé pour vous.
Choisissez l’analyseur, puis choisissez Exécuter un analyseur.

Analyse des données

Étape 1 : Une fois le travail terminé, ouvrez la console Amazon Athena et explorez les données.

Sur la console Athena, choisissez la base de données de “sessionalization” dans la liste. Vous devriez voir deux tables créées à partir des données dans Amazon S3 : rawdata et aggregated.

Étape 2 : Choisissez l’ellipse verticale (trois points) sur le côté droit pour explorer chacune des tables, comme le montrent les captures d’écran suivantes.

Étape 3 : Créez une vue dans la console Amazon Athena pour interroger uniquement les données du jour de votre table agrégée, comme suit :

CREATE OR REPLACE VIEW clicks_today AS
SELECT*
FROM "aggregated"
WHERE
cast(partition_0 as integer)=year(current_date) and
cast(partition_1 as integer)=month(current_date) and
cast(partition_2 as integer)=day(current_date) ;

L’interrogation réussie apparaît sur la console comme suit :

Étape 4 : Créez une vue pour interroger uniquement les données du mois en cours de votre table agrégée, comme dans l’exemple suivant :

CREATE OR REPLACE VIEW clicks_month AS
SELECT*
FROM "aggregated"
WHERE
cast(partition_0 as integer)=year(current_date) and
cast(partition_1 as integer)=month(current_date) ;

L’interrogation réussie apparaît sur la console comme suit :

Étape 5 : Interroger les données avec les sessions regroupées par durée de session ordonnée par sessions, comme suit :

SELECT duration_sec, count(1) sessions 
FROM "clicks_today"
where duration_sec>0
group by duration_sec
order by sessions desc;

L’interrogation apparaît comme suit :

Visualiser les données

Étape 1 : Ouvrez la console Amazon QuickSight. Si vous n’avez jamais utilisé Amazon QuickSight, effectuez d’abord cette configuration.

Étape 2 : Configurez les paramètres du compte Amazon QuickSight pour accéder à Amazon Athena et à votre bucket S3.
Tout d’abord, cochez la case Amazon Athena. Cochez la case Amazon S3 pour modifier l’accès Amazon QuickSight à vos compartiments S3.

Choisissez les buckets que vous souhaitez mettre à disposition, puis sélectionnez Sélectionner des compartiments Amazon S3.

Étape 3 : Choisissez Nouvelle analyse.

Étape 4 : Choisissez NEW DATASET.
Dans la liste des sources de données, choisissez Athena.

Étape 5 : Entrez daily_session comme le nom de source de données.

Étape 6 : Choisissez la vue que vous avez créée pour les sessions journalières, puis choisissez Selectionner.

Étape 7 : Ensuite, vous pouvez choisir d’utiliser soit SPICE (cache), soit l’accès direct aux requêtes.

Étape 8 : Choisissez beginnavigation et duration_sec comme paramètres.

Étape 9 : Choisissez +Ajouter pour ajouter une nouvelle visualisation.

Étape 10 : Dans Visual types, choisissez le type de graphique Tree map.

Étape 11 : Pour Regrouper par, choisissez device_id ; pour Taille, choisissez duration_sec (Somme) ; et pour Couleur, choisissez events (Somme).

Conclusion

Dans cet article, nous avons décrit comment effectuer la “sessionalization” des événements de parcours de navigation et les analyser dans une architecture sans serveur. L’utilisation d’une fenêtre de type stagger d’Amazon Kinesis Data Analytics rend le code SQL court et facile à écrire et à comprendre. L’intégration des services permet de créer un flux de données complet avec un minimum de développement et code.

Vous avez également appris à explorer et à visualiser ces données en utilisant Amazon Athena, AWS Glue et Amazon QuickSight.

Article original contribué par Hugo Rozestraten, Architecte de solutions spécialisé dans l’analytique et adapté en français par Weibo GU, Architecte de Solutions dans l’équipe AWS France.