Création d'un référentiel de connaissances client 360 avec Amazon Neptune et Amazon Redshift: idk.dev – Bien choisir son serveur d impression

Les entreprises créent et déploient des plates-formes de données à grande échelle comme des lacs de données, des entrepôts de données et des entrepôts de données pour capturer et analyser une vue globale du parcours de leurs clients. L'objectif d'une telle plate-forme de données est de comprendre les modèles de comportement des clients qui influencent la satisfaction et suscitent plus d'engagement. Les applications capturent aujourd'hui chaque point de contact avec un client, mais ces données sont réparties sur différents sites (tels que des partenaires externes, des SaaS externalisés comme des chatbots ou des centres d'appels, des systèmes sur site ou des clouds publics comme Google Analytics) avec peu ou pas de liens entre les données capturées. Par conséquent, le défi consiste à connecter ces sources de données disparates au fur et à mesure que votre client navigue du contact initial à son état actuel au cours du voyage. Vous avez besoin d'une vue à 360 degrés de votre client grâce à une base de connaissances contenant les attributs clés de son parcours et des liens pointant vers des données détaillées. Cette base de connaissances doit être flexible, agile et extensible pour prendre en charge de nouveaux modèles de données à mesure que votre paysage de données évolue.

Amazon Neptune est une base de données graphique spécialement conçue pour stocker des modèles de données connectés, que vous pouvez utiliser pour créer une vue client 360 en capturant les données d'un parcours client en temps quasi réel. La solution de données connectées peut fournir des informations commerciales à vos représentants du service client, aider à de nouvelles ventes, fournir des recommandations aux clients, alimenter les tableaux de bord client 360 ou servir de référentiel de données pour effectuer des analyses basées sur l'apprentissage automatique (ML).

Cet article montre comment vous pouvez utiliser Neptune pour créer une solution de base de connaissances client 360 en utilisant un parcours client en assurance habitation. Vous parcourez les étapes suivantes:

1. Créez un environnement sandbox pour montrer la preuve de valeur (POV) pour la plate-forme de données connectée
2. Définissez les étapes du parcours client depuis le premier contact jusqu'à un client engagé et actif
3. Utilisez Amazon Redshift SQL et les fonctionnalités analytiques et comprenez les modèles de données et les liens associés entre les données de différentes sources impliquées dans un parcours client
4. Définir les entités d'état métier et la relation associée dans le diagramme de relation d'entité (ER)
5. Créez un modèle de graphique qui identifie les sommets, les arêtes et les propriétés à partir du diagramme ER et des données du bac à sable
6. Générez des fichiers de chargement Neptune sur Amazon S3 à partir d'Amazon Redshift
7. Effectuer un chargement en masse des données du graphique connecté dans Neptune
8. Créez des applications client 360 qui prouvent la valeur commerciale des données connectées
9. Intégrez Neptune au pipeline de données pour connecter les magasins de données et publier de nouveaux faits dans des bases de données spécialement conçues

Le diagramme suivant illustre ce processus.

Présentation de la solution

Une plate-forme de données d'entreprise ingère les données de parcours client en utilisant une variété de mécanismes de capture de données (frontaux Web, applications mobiles, centres d'appels, flux externes, agences de données externes et partenaires, fronts cloud et applications hébergées internes). Dans une plate-forme de données typique, pour comprendre les modèles de comportement des clients, vous absorbez, transformez et conservez toutes sortes de données dans différents types de magasins de données. Vous pouvez classer largement les modèles de source de données comme externe structuré, externe non structuré, interne structuré, et interne non structuré. Au fur et à mesure que les modèles de données se développent et changent avec des produits centrés sur le client nouveaux ou modifiés, les données du parcours client sont dissociées dans plusieurs magasins de données. La connexion de toutes les données associées à un client pour fournir un état de données holistique peut être difficile. Les informations deviennent obsolètes et la latence pour fournir les dernières informations axées sur le client commence à augmenter. Les lacs de données deviennent des marécages et vous devez nettoyer et construire de nouveaux magasins spécialement conçus pour relever les défis commerciaux non résolus et réduire l'insatisfaction des clients.

Vous pouvez capturer la relation entre les entités de données sous forme de sommets et d'arêtes associées dans la couche organisée du lac de données d'entreprise à l'aide du graphique de propriétés Tinkerpop. Avec les capacités Neptune de schéma variable (nouvelles propriétés) et l'extensibilité pour ajouter de nouvelles entités (sommet et bord), vous pouvez stocker les données client de nouveaux flux en temps quasi réel et publier plus rapidement les vues client 360. Le diagramme suivant compare ces architectures.

Procédure pas à pas

Dans ce cas d'utilisation, votre compagnie d'assurance habitation souhaite comprendre le comportement de votre client dans un nouveau paradigme d'assurance qui utilise des applications modernes pour souscrire de nouveaux clients à une assurance habitation ou appartement. Vous devez comprendre l'état actuel du parcours d'un client en fonction du chemin emprunté (navigateur Web, application mobile ou centre d'appels) et vendre une police d'assurance au bon prix et à la bonne couverture, ce qui se traduit par une plus grande satisfaction pour une longue durée, client engagé.

Cet article examine les quatre différents modèles d'ingestion de données, les défis associés pour analyser les données non liées, comment utiliser Amazon Redshift pour analyser et créer des données de graphique, et comment Neptune peut ajouter de la valeur pour connecter les points entre les données afin de fournir un client holistique Vue 360 ​​en temps quasi réel. Le tableau suivant résume les quatre modèles d'ingestion.

Création de l'environnement sandbox

Vous créez un environnement sandbox avec des composants de plateforme AWS (Amazon S3, Amazon Redshift, Neptune) pour créer un PDV pour une plateforme de données connectée. Pour plus d'informations sur les commandes et les procédures, consultez la documentation AWS.

Pour créer votre environnement, procédez comme suit:

1. Créez un compartiment S3 (cjsandboxpov) avec les dossiers suivants pour stocker des exemples de données de la plateforme de données existante:
   • / landingarea – Dossier de la zone d'atterrissage pour collecter les données des quatre sources au format CSV ou Parquet
   • / neptune_vertex – Dossier de chargement de sommet Neptune pour vider les fichiers de chargement CSV pour les données de vidage concernant les sommets du graphique
   • / neptune_edge – Dossier Neptune Load Edge pour vider les fichiers de chargement CSV pour les données de vidage concernant les bords du graphique

   Ce message utilise le nom du compartiment S3 cjsandboxpov99999.

2. Laissez toutes les stratégies de compartiment sécurisé à leur valeur par défaut.
3. Créez un cluster Amazon Redshift dans votre environnement de bac à sable VPC pour télécharger les données source.
   • La taille du cluster doit prendre en charge le stockage de données deux fois la taille des données brutes (par exemple, sélectionnez un cluster ds2.xlarge à 2 nœuds pour jusqu'à 2 To de données brutes)
   • Associez le rôle IAM à Amazon Redshift pour lire et écrire dans les compartiments S3.

   Pour plus d'informations, voir Autorisation des opérations COPY, UNLOAD et CREATE EXTERNAL SCHEMA à l'aide des rôles IAM.

4. Utilisez l'éditeur de requêtes Amazon Redshift pour vous connecter à la base de données Amazon Redshift et créer le schéma sandbox cjsandbox pour définir les objets source entrants.
5. Créez un cluster Neptune pour capturer les attributs du graphique afin de créer une base de connaissances:
   • Choisissez la dernière version avec un cluster db.r5large sans réplique en lecture
   • Choisir cjsandbox comme identifiant de base de données et sélectionnez les valeurs par défaut comme options
   • Lancer la création du cluster Neptune

Découvrir le parcours client et capturer les états clés

Le diagramme suivant illustre les différentes voies qu'un client peut emprunter au cours de son voyage.

Dans le paysage de l'assurance habitation pour l'assurance habitation, appartement ou propriété, les individus ont plusieurs options pour s'engager avec un fournisseur d'assurance. Un voyage individuel pour acheter une police d'assurance pourrait être simple et rapide, en utilisant une application mobile pour un appartement, ou complexe en fonction de la taille et de l'emplacement de la propriété avec différents besoins de couverture.

Les compagnies d'assurance soutiennent la croissance du marché diversifié en offrant de multiples options (mobile, Web ou centre d'appels) pour le premier premier contact avec des clients potentiels. Votre objectif est de fournir la meilleure expérience client et de vous aider rapidement lorsqu'un client rencontre un défi ou décide d'abandonner sa demande.

La meilleure expérience client nécessite de capturer l'état du parcours client le plus rapidement possible, afin que vous puissiez fournir des options pour des décisions plus rapides qui conduisent le client à signer une politique. L'objectif est de réduire les abandons dus à une mauvaise expérience de l'interface utilisateur, à la complexité de la sélection de la couverture, à la non-disponibilité des choix optimaux et des options de coût, ou à la complexité de la navigation dans l'interface fournie. En outre, vous devez donner aux représentants de votre entreprise (représentants des ventes et des services ou développeurs d'applications) les dernières tendances concernant l'état du client et les mesures pour guider le client vers un achat de stratégie réussi.

À partir du parcours client, vous capturez les états clés suivants:

• Informations client initiales – Email, adresse, téléphone
• Données du centre d'appels – Téléphone, agent, état
• Journaux des applications Web – Session, devis, dernier état
• Journaux d'analyse Web – Visites, pages vues, événements de page
• Données de base sur le trajet – Politique, devis, abandon ou rejet du client

Capture du diagramme ER du parcours client et du graphique du modèle avec des sommets et des bords

Après avoir défini les états du parcours client, identifiez les entités de transaction clés où les données sont capturées pour l'interaction. Construisez un diagramme ER des entités connues et des relations associées les unes avec les autres. Le diagramme suivant illustre quatre vues client isolées.

Chaque magasin de données se compose de tables de faits clés. Le tableau suivant résume les tables de faits et leurs attributs clés associés.

Après avoir examiné les données des tableaux et leurs relations associées, analysez le diagramme ER pour les entités clés du modèle de graphique. Chaque fait de table de clés agit comme la source des sommets principaux, tels que CLIENT, ADRESSE, APPEL, CITATION, SESSION, VISITE, PAGE_VIEW, et EVENEMENT DE PAGE. Identifiez d'autres entités clés en tant que sommets, qui sont des attributs clés pour connecter différentes entités, telles que TÉLÉPHONE et ZIP *: FRANÇAIS. Identifiez les arêtes entre les sommets en vous référant à la relation entre les tables. Le modèle de graphique suivant est basé sur les sommets et les arêtes identifiés.

La prochaine étape clé consiste à concevoir le modèle de graphe pour prendre en charge les exigences de graphe de propriété Neptune Tinkerpop. Votre base de données Neptune a besoin d'un ID unique pour chacune de ses entités de sommet et de bord. Vous pouvez générer l'ID avec une combinaison de la valeur de préfixe et de l'identifiant commercial unique actuel pour une entité. Le tableau suivant décrit quelques exemples des normes de dénomination des sommets et des arêtes utilisées pour créer des identités uniques pour la base de données Neptune. Les entités de sommet sont associées à des acronymes de trois lettres concaténés avec un identifiant unique de base de données. Le nom de l'arête est dérivé par la direction de l'arête __ décrivant une à plusieurs relations entre deux sommets. Étant donné que les valeurs de clé primaire sont uniques pour une entité, la concaténation avec un préfixe rend la valeur unique dans la base de données Neptune.

Analyse des données sélectionnées pour les relations dans Amazon Redshift

Amazon Redshift fournit une plateforme de traitement massivement parallèle (MPP) pour examiner les modèles de données dans de grandes quantités de données. Vous pouvez utiliser d'autres options de programmation comme AWS Glue pour créer des fichiers de chargement en masse Neptune pour les données stockées dans un lac de données organisé par Amazon S3. Cependant, Amazon Redshift propose une plate-forme de base de données pour analyser les modèles de données et trouver la connectivité entre des sources disparates, et une interface SQL pour générer les fichiers de chargement en bloc. Une interface SQL est préférée pour les analystes centrés sur la base de données et évite la courbe d'apprentissage pour la construction de bibliothèques basées sur PySpark. Cette publication suppose que les données sélectionnées pour les magasins de données sont publiées dans le lac de données basé sur Amazon S3 au format CSV ou Parquet. Vous pouvez charger des données sélectionnées dans un lac de données dans la base de données Amazon Redshift à l'aide de la COPIE commander.

Pour créer une table client dans le schéma sandbox, entrez le code suivant:

Créer une table sandbox.customer (
numéro client_id,
email. varchar (40),
téléphone varchar (20),
numéro_adresse,
..);

Pour copier des données d'Amazon S3 dans la table client, entrez le code suivant:

copier le client
de 's3: //cjsandboxpov9999/landingarea/customer.dat'
iam_role 'arn: aws: iam :: 0123456789012: role / MyRedshiftRole';

Vidage de sommets et d'arêtes vider des fichiers vers Amazon S3

La base de données Neptune prend en charge les chargements en masse à l'aide de fichiers CSV. Chaque fichier doit avoir un enregistrement d'en-tête. Le fichier de sommet doit avoir des attributs d'ID de sommet et des attributs d'étiquette selon les besoins. Les attributs de propriété restants doivent spécifier le format d'attribut pour chaque attribut dans l'en-tête. Le fichier de vidage de bord doit avoir un ID, de l'ID de sommet, à l'ID de sommet, et étiqueter comme attributs requis. Les données de bord peuvent avoir des attributs de propriété supplémentaires.

Le code suivant est un exemple d'enregistrement de vidage de sommet de session:

~ id, session_id: int, marketing_id: String, quote_id: int, date_created: String, ~ label
SES29557958,29557958,8016200001,16524635, "2019-02-04 21: 51: 33.229275", session
SES29557961,29557961, pgrcrp, 16524645, "2019-02-04 21: 51: 33.229275", session
SES29557963,29557963,, 16524639, "2019-02-04 21: 51: 33.229275", session
SES29557965,29557965, InternetW, 16524638, "2019-02-04 21: 51: 33.229275", session
SES29557966,29557966, pgrcrp, 16524637, "2019-02-04 21: 51: 33.229275", session
SES29557967,29557967,9003849004,16524642, "2019-02-04 21: 51: 33.229275", session
SES29557968,29557968,, 16524641, "2019-02-04 21: 51: 33.229275", session
SES29557969,29557969, OLS, 16524653, "2019-02-04 21: 51: 33.229275", session

Le code suivant est un exemple d'enregistrement de vidage de bord de citation de session:

~ id, ~ de, ~ à, ~ label
"SESQTE16524635", SES29557958, QTE16524635, has_quote
"SESQTE16524645", SES29557961, QTE16524645, has_quote
"SESQTE16524639", SES29557963, QTE16524639, has_quote
"SESQTE16524638", SES29557965, QTE16524638, has_quote
"SESQTE16524637", SES29557966, QTE16524637, has_quote
"SESQTE16524642", SES29557967, QTE16524642, has_quote

Étant donné que toutes les données associées résident dans Amazon Redshift, vous pouvez utiliser une définition de vue pour simplifier la création des fichiers de vidage pour les chargements en masse de Neptune. Une définition de vue garantit que l'enregistrement d'en-tête est toujours le premier enregistrement du fichier de vidage. Cependant, la création de fichiers de vidage sur Amazon S3 présente certaines limites:

• le NUL La valeur dans une colonne rend la chaîne entière nulle. La vue utilise le NVL pour éviter le défi de sauter des sommets dans le cas où l'un des attributs a un NUL
• Les virgules ou autres caractères uniques dans les données d'attributs invalident le format de données du fichier de vidage. La vue utilise le remplacer pour supprimer ces caractères dans le flux de données.
• le décharger La commande a une limite de 6 Go pour créer un seul fichier de vidage. Tout fichier de débordement ne possède pas l'enregistrement d'en-tête, ce qui invalide le format de chargement Neptune. View vous permet de trier les données par colonnes clés pour décharger les données en blocs, chaque bloc ayant l'en-tête au format Neptune.

L'exemple de code suivant est une définition de vue pour une vue source de vertex:

créer ou remplacer la vue sandbox.v_session en tant que
Sélectionnez * à partir de. --- FORMAT D'EN-TÊTE
(sélectionnez 'header: string,' ||. - triez la colonne pour vous assurer que l'en-tête est le premier enregistrement
~ id, ‘session_id: int, start_date: string ,, quote_id: string, '||.
‘Date_created: string, last_interaction_date: string, policy_effective_date: string,’ ||
'~ label' session_data - attribut LABEL
de sandbox.dummy. - Table DUMMY avec 1 rangée
union tout
sélectionnez "ligne" ||
«SES» || id || »,« || id || »,« || start_date || »,« || quote_id || »,« ||
date_created || ',' || last_interaction_date || ',' || policy_effective_date || ',' ||
'session'. - ÉTIQUETTE pour sommet
de sandbox.session
 )
commander par 1, ID;

L'exemple de code suivant est une définition de vue pour une vue de source d'arête:

créer ou remplacer la vue sandbox.v_session_quote comme
  SELECT * FROM (
    SELECT 'en-tête: chaîne, ~ id, ~ de, ~ à,' || '~ label' AS session_quote_data
    DE sandbox.dummy
    UNION ALL
    SELECT 'ligne, SESQTE' || sessionid || «, SES» || sessionid || «, QTE» || quote_id || ',' ||
    'sess_quote'
    FROM (SELECT c.sessionid, s.quote_id
          DE sandbox.customer c,
               sandbox.session s,
              sandbox.quote q
              OERE c.sessionid = s.id ET
                   q.quote_number = s.quote_id)
  ) OÙ
   COMMANDER PAR 1,2;

Pour créer les fichiers de vidage des sommets et des bords, utilisez le DÉCHARGER dans Amazon Redshift. Voir le code suivant:

décharger ('select * from sandbox.v_session')
à 's3: //cjsandboxpov9999/neptune_vertex/v_session.dat'
iam_role 'arn: aws: iam :: 0123456789012: role / MyRedshiftRole'
PARALLELE OFF;

décharger ('select * from sandbox.v_session_quote')
à 's3: //cjsandboxpov9999/neptune_edge/v_session_quote.dat'
iam_role 'arn: aws: iam :: 0123456789012: role / MyRedshiftRole'
NOPARALLEL OFF;

Chargement de fichiers de vidage de sommets et d'arêtes dans la base de données Neptune

Les fichiers de vidage des sommets et des bords sont créés dans deux dossiers Amazon S3 différents. Les fichiers de vidage de vertex sont chargés en premier en tant qu'arêtes, ce qui nécessite la présence de et vers une arête dans la base de données. Vous pouvez charger les fichiers un par un ou en tant que dossier. Le code suivant est la commande de chargement Neptune:

curl -X POST
-H 'Content-Type: application / json'
https: //> .us-east-1.neptune.amazonaws.com: 8182 / loader -d '

"source": "s3: // <<> ",
"format": "csv",
"iamRoleArn": "ARN pour le rôle IAM avec accès à la lecture depuis le compartiment S3",
"région": "us-east-1",
"failOnError": "FALSE",
"parallélisme": "ÉLEVÉ"
 »

Les travaux de chargement créent un ID de chargeur distinct pour chaque travail. Vous pouvez surveiller la progression du travail de chargement en transmettant l'ID du chargeur sous forme de variable au wget commander.

Pour vérifier l'état de l'état de la charge, entrez le code suivant:

wget https: // <.us-east-1.neptune.amazonaws.com: 8182 / loader / loader_id? details = true

Pour vérifier l'état de chargement avec des erreurs, entrez le code suivant:

wget «https: // <.us-east-1.neptune.amazonaws.com: 8182 / loader / loader_id? details = true & errors = true »

Exécution de POV de la base de données connectée

Vous devez vérifier les nouvelles solutions que vous avez mises en œuvre pour leur valeur afin de répondre aux résultats commerciaux. La base de données Neptune connectée peut désormais créer une vue globale pour un représentant du service client. Cette publication comprend un exemple de code Python pour décrire comment partager un client 360 des données connectées avec un utilisateur final. Effectuez les étapes suivantes:

1. À l'aide d'un ID client, comme un e-mail, identifiez le sommet de départ. Par exemple, le code suivant est une requête Gremlin:

   g.V (). hasLabel («client»).  sélectionner le sommet du client
   a (e-mail, «xxxx @ mail.com»).  identifier l'individu à travers les propriétés
   valueMap (). fold (). next ())  récupère toutes les propriétés

2. Accédez au sommet d'adresse connecté au sommet du client et obtenez toutes les informations d'adresse associées. Par exemple, consultez le code suivant:

   gV (). hasLabel ('client'). has ('email', 'xxxxxx@mail.com'). out (). hasLabel ('address'). project ('address', 'city', 'zip' , 'état'). par ('adresse'). par ('ville'). par ('zip'). par ('état'). toList ()

3. Accédez à tous les sommets du téléphone et capturez toutes les données d'appel dans l'ordre chronologique.
4. Accédez à la session et à la visite d'analyse Web pour capturer toutes les activités Web.
5. Accédez au devis associé et voyez le modèle de sélection d'assurance.
6. Identifiez l'état actuel du client.

La visualisation d'un univers connecté pour les données d'un client offre la plus grande valeur pour une base de données de graphes Neptune. Vous pouvez analyser le graphique pour découvrir de nouveaux ensembles de données et modèles de données. Vous pouvez ensuite utiliser ces nouveaux modèles comme entrée pour ML pour vous aider à optimiser le parcours client. La base de données graphique réduit le temps de découverte pour comprendre les modèles de données pour les données de départ pour construire des modèles ML.

Vous pouvez explorer la connectivité entre différentes entités à l'aide d'une interface de navigateur graphique pour une base de données de graphiques. le Afficher le quartier L'option dans la plupart des navigateurs graphiques vous permet de parcourir différents chemins empruntés par le client. Effectuez les étapes suivantes:

1. Commencez par une requête gremlin pour obtenir le sommet du client.
2. Pour afficher le téléphone, l'adresse, les sessions Web et les devis associés, choisissez Afficher le quartier pour le sommet du client.
3. Pour voir toutes les visites d'une session, choisissez Afficher le quartier pour une session.
4. Pour voir tous les appels associés à un client, choisissez Afficher le quartier pour un téléphone.
5. Pour voir toutes les politiques associées à un devis, choisissez Afficher le quartier pour un devis.
6. Pour afficher toutes les pages vues associées, choisissez Afficher le quartier pour une visite.

Vous pouvez utiliser la vue du parcours client connecté pour améliorer l'interface utilisateur (mobile ou Web) afin de définir les options de couverture par défaut en utilisant les options les plus largement sélectionnées pour une démographie (assurance en un clic). Pour un code postal ou une ville, lorsque vous parcourez le graphique, vous pouvez identifier les clients et les devis et politiques associés pour identifier le modèle des franchises et la couverture choisie par les clients satisfaits. Pour l'analyse d'abandon, vous pouvez sélectionner les devis sans politique pour naviguer vers l'analyse Web et trouver le formulaire ou l'événement qui déclenche l'abandon du client en raison d'une interface utilisateur complexe. Pour réduire les volumes d'appels vers le centre d'appels, parcourez le graphique pour capturer les tendances des événements qui déclenchent un appel client.

Intégration du Data Lake avec Neptune

Après avoir établi la valeur des données connectées, vous pouvez améliorer le pipeline de données quotidiennes pour inclure la base de données Neptune connectée. Après avoir organisé les données et les avoir publiées dans le lac de données, vous pouvez glaner les données connectées pour ajouter de nouveaux sommets, arêtes et propriétés. Vous pouvez déclencher des travaux AWS Glue pour capturer de nouveaux clients, connecter de nouvelles sessions d'application aux clients et intégrer les données d'analyse Web incrémentielles aux informations de session et de client. Ce message comprend un exemple de travail AWS Glue pour maintenir les sommets et les bords.

Après avoir publié un nouveau fait de données organisé, déclenchez une fonction AWS Lambda pour démarrer un travail AWS Glue pour capturer les dernières entités ajoutées ou modifiées, assurez-vous que leurs données dépendantes sont déjà publiées, puis ajoutez ou modifiez le sommet, l'arête ou la propriété information. Par exemple, lorsque de nouvelles données de session arrivent dans la zone organisée de votre lac de données, lancez un travail pour ajouter des entités liées à la session client à la base de données Neptune.

Exemples de code

L'exemple de code suivant concerne un client 360 utilisant Python et Gremlin:

#! / usr / bin / python
from __future__ import print_function # Compatibilité Python 2/3
à partir de la statique d'importation gremlin_python
depuis gremlin_python.structure.graph import Graph
de gremlin_python.process.graph_traversal import __
depuis gremlin_python.process.traversal import *
de gremlin_python.process.strategies import *
de gremlin_python.driver.driver_remote_connection import DriverRemoteConnection
importer json
graph = Graph ()
### créer une connexion à la base de données
remoteConn = DriverRemoteConnection ('wss: //cjsandbox.xxxxx.us-east-1.neptune.amazonaws.com: 8182 / gremlin', 'g')
g = graph.traversal () .withRemote (DriverRemoteConnection ('wss: //cjsandbox.xxxxxx..us-east-1.neptune.amazonaws.com: 8182 / gremlin', 'g')))
### exécuter des requêtes Gremlin et stocker les détails dans les variables json
## obtenir les données client
vcust = gV (). hasLabel ('client'). has ('email', 'xxxxxxx@aol.com'). project ('email', 'dob'). by ('email'). by ('dob ').lister()
## obtenir les données de session
vcount = g.V (). hasLabel ('customer'). has ('email', 'xxxxxxx@aol.com'). out (). hasLabel ('session'). count (). toList ()
vqcount = g.V (). hasLabel ('customer'). has ('email', 'xxxxxxx@aol.com'). out (). hasLabel ('quote'). count (). toList ()
## obtenir le nombre d'adresses et les données
vaddcount = g.V (). hasLabel ('customer'). has ('email', 'xxxxxxxx@aol.com'). out (). hasLabel ('address'). count (). toList ()
vaddress = gV (). hasLabel ('customer'). has ('email', 'xxxxxx@aol.com'). out (). hasLabel ('address'). project ('address', 'city', ' zip ',' état '). par (' adresse '). par (' ville '). par (' zip '). par (' état '). toList ()
v_fullcust = format (g.V (). hasLabel ('customer'). has ('email', 'xxxxx@aol.com'). valueMap (). fold (). next ())
vsess = gV (). hasLabel ('customer'). has ('email', 'XXXX@aol.com'). out (). hasLabel ('session'). order (). by ('start_date'). project ('start_date', 'session_id', 'partner_id'). by ('start_date'). by ('session_id'). by ('partner_id'). toList ()
vcust_json = json.dumps (vcust[0])
vcount_json = json.dumps (vcount[0])
vaddcount_json = json.dumps (vaddcount[0])
vsesscount = json.loads (vcount_json)
vaddrcount = json.loads (vaddcount_json)
### imprimer les informations client
print ("====== Informations client =========================")
print ("====== Informations client =========================")
print ("Email:% s"% json.loads (vcust_json)['email'])
print ("Date de naissance:% s"% json.loads (vcust_json)['dob'])
print ("Nombre de sessions:% s sessions"% vsesscount)
print ("Nombre de propriétés:% s"% vaddcount)
print ("Détails de l'adresse de la propriété::")
pour i dans la plage (vaddrcount, 0, -1):
        address_json = json.dumps (vaddress[i-1])
        imprimer (address_json)
imprimer ("Détails divers du client:")
imprimer (v_fullcust)
impression("----------------------------------------------- ------ nn ")
print ("====== Custoner session Information ===== trié par date de création décroissante ==========")
### session d'impression en boucle
pour i dans la plage (vsesscount, 0, -1):
        vsess_json = json.dumps (vsess[i-1])
        print ("Session:")
        vsessid = json.loads (vsess_json)['session_id']
        imprimer (vsess_json)
        vsessinfo = g.V (). has ('session', 'session_id', vsessid) .valueMap (). select ('date_created', 'policy_effective_date', 'marketing_id', 'form_number'). fold (). next ()
        imprimer (vsessinfo)
        imprimer ("-------------------------- n")
remoteConn.close ()

L'exemple de code suivant est un programme AWS Glue qui crée un fichier CSV Neptune lors de la conservation des données incrémentielles:

importer sys
importer boto3
journalisation d'importation
### awsglue libs
depuis awsglue.utils, importez getResolvedOptions
depuis awsglue.transforms, importez ApplyMapping
de awsglue.transforms import RenameField
depuis awsglue.transforms, importez SelectFields
depuis awsglue.dynamicframe, importez DynamicFrame
depuis awsglue.context importez GlueContext
à partir du travail d'importation awsglue.job
## pyspark libs
à partir de pyspark.context, importez SparkContext
depuis pyspark.sql.functions import allumé
à partir de pyspark.sql.functions import format_string
## add lib
sc = SparkContext ()
# sc.addPyFile ("s3: //aws-glue-scripts-999999-us-east-1/glue_neptune/glue_neptune.zip")
### gremlin / glue_neptune a besoin d'une bibliothèque zip
à partir de la statique d'importation gremlin_python
depuis gremlin_python.structure.graph import Graph
de gremlin_python.process.graph_traversal import __
de gremlin_python.process.strategies import *
de gremlin_python.driver.driver_remote_connection import DriverRemoteConnection
depuis gremlin_python.process.traversal import *
de glue_neptune.NeptuneConnectionInfo import NeptuneConnectionInfo
de glue_neptune.NeptuneGremlinClient import NeptuneGremlinClient
de glue_neptune.GremlinCsvTransforms importer GremlinCsvTransforms
####
### Contexte de journalisation
MSG_FORMAT = '% (asctime) s% (levelname) s% (name) s:% (message) s'
DATETIME_FORMAT = '% Y-% m-% d% H:% M:% S'
logging.basicConfig (format = MSG_FORMAT, datefmt = DATETIME_FORMAT)
logger = logging.getLogger ("cjsandboxglue")
logger.setLevel (logging.INFO)
logger.info ("Bonjour du message de colle")
####
args = getResolvedOptions (sys.argv, ['JOB_NAME', 'S3_OUTPUT_PATH','DATABASE_NAME','TABLE_NAME','PIPELINE_ID','PIPELINE_JOB_ID"])
glueContext = GlueContext (sc)
job = Job (glueContext)
job.init (args['JOB_NAME'], args)
nodes_path = ' nodes'.format (args['S3_OUTPUT_PATH'])
bords_chemin = ' bords'.format (args['S3_OUTPUT_PATH'])
jobname = args['JOB_NAME']
base de données = args['DATABASE_NAME']
session_table = args['TABLE_NAME']
pipelinename = args['PIPELINE_ID']
jpbid = args['PIPLEINE_JOB_ID']
def writeCsvFile (source de données, chemin):
    dataframe = DynamicFrame.toDF (source de données) .repartition (1)
    datasource = DynamicFrame.fromDF (dataframe, glueContext, 'write-csv')
    glueContext.write_dynamic_frame.from_options (frame = source de données, connection_type = "s3", connection_options = "path": path, format = "csv", transformation_ctx = "write-csv")
# Arguments
impression ("nom du travail =", nom du travail)
print ("s3 path =", nodes_path)
print ("table prefix =", session_table)
print ("catalogue database =", base de données)
print ("pipeline =", pipelinename)
print ("job id =", jobid)
datasource0 = glueContext.create_dynamic_frame.from_catalog (base de données = base de données, table_name = session_table, transformation_ctx = "datasource0")
applymapping1 = ApplyMapping.apply (frame = datasource0, mappings = [("session_id", "bigint", "session_id:int", "int"), ("marketing_id", "string", "marketing_id:String", "string"), ("quote_id", "bigint", "quote_id:int", "int"), ("date_created", "string", "date_created:String", "string")], transformation_ctx = "applymapping1")
applymapping1 = GremlinCsvTransforms.create_prefixed_columns (applymapping1, [('~id', 'session_id:int', 'SES'),('~to', 'quote_id:int', 'QTE')])
selectfields1 = SelectFields.apply (frame = applymapping1, chemins = ["~id", "session_id:int", "marketing_id:String", "quote_id:int", "date_created:String"], transformation_ctx = "selectfields1")
writeCsvFile (GremlinCsvTransforms.addLabel (selectfields1, 'session'), node_path)
# Bords
applymapping1 = RenameField.apply (applymapping1, "~ id", "~ from")
applymapping1 = GremlinCsvTransforms.create_edge_id_column (applymapping1, '~ from', '~ to')
selectfields2 = SelectFields.apply (frame = applymapping1, chemins = ["~id", "~from", "~to"], transformation_ctx = "selectfields2")
writeCsvFile (GremlinCsvTransforms.addLabel (selectfields2, 'has_quote'), edge_path)
# Fin
job.commit ()

Conclusion

Vous pouvez utiliser Neptune pour créer une base de connaissances d'entreprise pour une solution client 360 qui connecte des sources de données disparates pour les tableaux de bord d'état client, des analyses améliorées, des moteurs de recommandation en ligne et une analyse des tendances de cohorte.

Une solution client 360 avec une base de données Neptune offre les avantages suivants:

• Accès à toutes les activités en temps quasi réel effectuées par un client au cours de son voyage. Vous pouvez parcourir le graphique pour mieux accompagner le client
• Capacité à créer un moteur de recommandation pour aider les clients pendant leur voyage avec des commentaires basés sur les préférences de cohortes similaires basées sur la démographie, l'emplacement et les préférences
• Analyse de segmentation basée sur la géographie et la démographie pour comprendre les défis du marché actuel et les opportunités pour de nouveaux marchés
• Analyse de rentabilisation pour réduire un défi en traversant le quartier jusqu'aux facteurs de triage affectant votre entreprise
• Test et validation de l'efficacité du déploiement de nouvelles applications pour améliorer l'expérience de parcours client

Vous pouvez appliquer cette solution à des bases de connaissances similaires, telles que des véhicules ou des comptes. For example, a vehicle 360 knowledge base can track a journey of an automobile customer from pre-sales, dealer interactions, regular maintenance, warranty, recalls, and resell to calculate the best incentive value for a vehicle.

A propos de l'auteur

Ram Bhandarkar is a Sr Data Architect with AWS Professional Services. Ram specializes in designing and deploying large-scale AWS data platforms (Data Lake, NoSQL, Amazon Redshift). He also assists in migrating large-scale legacy Oracle databases and DW platforms to AWS Cloud.