Tester l'intégration d'un fournisseur

Tout en Résolution des entités AWS hébergeant des services de mise en correspondance des données, l'intégration d'un fournisseur est un composant tiers crucial pour le flux de travail de end-to-end correspondance. Plusieurs tests ont Résolution des entités AWS été définis pour les fournisseurs afin d'ajouter une protection en cas d'échec de cette intégration. Cette approche permet aux prestataires de surveiller l'état de santé de leurs services en fonction de ces cas de end-to-end test.

Les fournisseurs peuvent utiliser leurs comptes de test et leurs propres données pour exécuter ces scénarios de end-to-end test à l'aide du kit de développement Résolution des entités AWS logiciel (SDK). En cas de problème de la part des fournisseurs, Résolution des entités AWS utilise le chemin d'escalade préféré pour aggraver le problème. En outre, les fournisseurs doivent mettre en œuvre leur propre surveillance des résultats des tests. Les fournisseurs doivent partager leurs Compte AWS IDs données utilisées pour exécuter ces tests Résolution des entités AWS.

Une exécution réussie signifie qu'un fournisseur peut configurer ses données, utiliser son propre service Résolution des entités AWS, et le statut de la tâche indique « Terminé » sans erreur. Cela peut être accompli par programmation à l'aide de la commande APIs fournie par. Résolution des entités AWS

Par exemple, les fournisseurs peuvent configurer leur compartiment S3, leur source d'entrée, leurs rôles, leur schéma et leurs flux de travail en fonction de leurs services. Une fois ces configurations terminées, les fournisseurs peuvent exécuter ces flux de travail une fois par jour avec 200 enregistrements pour tester leur service. Dans cette approche, les fournisseurs utilisent le SDK de leur choix et end-to-end testent les services proposés AWS Data Exchange via leurs comptes de test. Les fournisseurs sont tenus d'effectuer ces tests pour chacune de leurs offres ou services.

Note

Les fournisseurs doivent fournir Résolution des entités AWS l' Compte AWS ID (identifiant) accountId) qu'ils utilisent pour exécuter ces flux de travail à des fins de test. En outre, les fournisseurs doivent surveiller ces tests et s'assurer qu'ils sont réussis, ce qui signifie qu'ils doivent activer la notification en cas d'échec et résoudre le problème en conséquence.

Le schéma suivant montre un cas de test end-to-end de flux de travail typique.

Pour tester l'intégration d'un fournisseur

1. (Configuration unique) Configurez les ressources pour Résolution des entités AWS en suivant les procédures décrites dansConfigurez Résolution des entités AWS.

   Une fois que vous avez terminé les procédures de configuration uniques, vos rôles, vos données et votre source de données devraient être prêts. Vous êtes maintenant prêt à tester l'intégration du fournisseur à l'aide de la Résolution des entités AWS console ou APIs.

2. Testez l'intégration du fournisseur à l'aide de la console Résolution des entités AWS APIs or.

API

Pour tester l'intégration d'un fournisseur à l'aide du Résolution des entités AWS APIs

1. Créez un mappage de schéma à l'aide de l'CreateSchemaMapping API. Pour obtenir la liste complète des langages de programmation pris en charge, consultez la section Voir aussi de l'CreateSchemaMapping API.

   Le mappage de schéma est le processus par lequel vous indiquez Résolution des entités AWS comment interpréter vos données à des fins de correspondance. Vous définissez le schéma de la table de données d'entrée que vous souhaitez qu'AWS Entity Resolution lise dans un flux de travail correspondant.

   Lors de la création d'un mappage de schéma, un identifiant unique doit être désigné et attribué à chaque ligne de données d'entrée lue par AWS Entity Resolution. Par exemple, Primary_key, Row_ID, Record_ID.

   Exemple Création d'un mappage de schéma pour une source de données contenant id et email

   Voici un exemple de mappage de schéma pour une source de données contenant id et email :

   [
     {
       "fieldName": "id",
       "type": "UNIQUE_ID"
     },
     {
       "fieldName": "email",
       "type": "EMAIL_ADDRESS"
     }
   ]

   Exemple Création d'un mappage de schéma pour une source de données contenant id et email utilisant le SDK Java

   Voici un exemple de mappage de schéma pour une source de données contenant id et email utilisant le SDK Java :

   EntityResolutionClient.createSchemaMapping(
               CreateSchemaMappingRequest.builder()
                                         .schemaName(<schema-name>)
                                         .mappedInputFields([
                                               SchemaInputAttribute.builder().fieldName("id").type("UNIQUE_ID").build(),
                                               SchemaInputAttribute.builder().fieldName("email").type("EMAIL_ADDRESS").build()
                                          ])
                                         .build()
   
   )
   

2. Créez un flux de travail correspondant à l'aide de l'CreateMatchingWorkflow API. Pour obtenir la liste complète des langages de programmation pris en charge, consultez la section Voir aussi de l'CreateMatchingWorkflow API.

   Exemple Création d'un flux de travail correspondant à l'aide du SDK Java

   Voici un exemple de flux de travail correspondant utilisant le SDK Java :

   EntityResolutionClient.createMatchingWorkflow(
               CreateMatchingWorkflowRequest.builder()
                                            .workflowName(<workflow-name>)
                                            .inputSourceConfig(
                                                InputSource.builder().inputSourceARN(<glue-inputsource-from-step1>).schemaName(<schema-name-from-step2>).build()
                                            )
                                            .outputSourceConfig(OutputSource.builder().outputS3Path(<output-s3-path>).output(<output-1>, <output-2>, <output-3>).build())
                                            .resolutionTechniques(ResolutionTechniques.builder()
                                                                                      .resolutionType(PROVIDER)
                                                                                      .providerProperties(ProviderProperties.builder()
                                                                                                                            .providerServiceArn(<provider-arn>)
                                                                                                                            .providerConfiguration(<configuration-depending-on-service>)
                                                                                                                            .intermediateSourceConfiguration(<intermedaite-s3-path>)
                                                                                                                            .build())
                                                                                      .build()
                                            .roleArn(<role-from-step1>)
                                            .build()
   
   )

   Une fois le flux de travail correspondant configuré, vous pouvez exécuter un flux de travail.

3. Exécutez un flux de travail correspondant à l'aide de StartMatchingJob l'API. Pour exécuter un flux de travail correspondant, vous devez avoir créé un flux de travail correspondant à l'aide du CreateMatchingWorkflow point de terminaison.

   Pour obtenir la liste complète des langages de programmation pris en charge, consultez la section Voir aussi de l'StartMatchingJob API.

   Exemple Exécution d'un flux de travail correspondant à l'aide du SDK Java

   Voici un exemple de flux de travail correspondant en cours d'exécution à l'aide du SDK Java :

   EntityResolutionClient.startMatchingJob(StartMatchingJobRequest.builder()
                   .workflowName(<name-of-workflow-from-step3)
                   .build()
   )

4. Surveillez l'état d'un flux de travail à l'aide de l'GetMatchingJob API.

   Cette API renvoie le statut, les métriques et les erreurs (le cas échéant) associés à une tâche.

   Exemple Surveillance d'un flux de travail correspondant à l'aide du SDK Java

   Voici un exemple de surveillance d'une tâche de flux de travail correspondante à l'aide du SDK Java :

   EntityResolutionClient.getMatchingJob(GetMatchingJobRequest.builder()
                   .workflowName(<name-of-workflow-from-step3)
                   .jobId(jobId-from-startMatchingJob)
                   .build()
   )

   Le end-to-end test est terminé si le flux de travail s'est terminé avec succès.

Console

Pour tester l'intégration d'un fournisseur à l'aide de la Résolution des entités AWS console

1. Créez un mappage de schéma en suivant les étapes décrites dansCréation d'un mappage de schéma.

   Le mappage de schéma est le processus par lequel vous indiquez Résolution des entités AWS comment interpréter vos données à des fins de correspondance. Vous définissez le schéma de la table de données d'entrée que vous Résolution des entités AWS souhaitez lire dans un flux de travail correspondant.

   Lors de la création d'un mappage de schéma, un identifiant unique doit être désigné et attribué à chaque ligne de données d'entrée Résolution des entités AWS lue. Par exemple, Primary_key, Row_ID, Record_ID.

   Exemple Mappage de schéma pour une source de données contenant id et email

   Voici un exemple de mappage de schéma pour une source de données contenant id et email :

   [
     {
       "fieldName": "id",
       "type": "UNIQUE_ID"
     },
     {
       "fieldName": "email",
       "type": "EMAIL_ADDRESS"
     }
   ]

2. Créez et exécutez un flux de travail correspondant en suivant les étapes décrites dansCréation d'un flux de travail de correspondance basé sur les services des fournisseurs.

   La création d'un flux de travail correspondant est le processus que vous configurez pour spécifier les données d'entrée à associer et la manière dont la correspondance doit être effectuée. Dans le flux de travail basé sur le fournisseur, si un compte dispose d'un abonnement auprès d'un fournisseur de services AWS Data Exchange, vous pouvez associer vos identifiants connus à ceux de votre fournisseur préféré. En fonction du fournisseur et du service que vous utilisez pour effectuer un test de bout en bout, vous pouvez configurer votre flux de travail correspondant en conséquence.

   La Résolution des entités AWS console combine les actions de création et d'exécution dans un seul bouton. Après avoir sélectionné Créer et exécuter, un message apparaît, indiquant que le flux de travail correspondant a été créé et que le travail a commencé.

3. Surveillez l'état du flux de travail sur la page des flux de travail correspondants.

   Le end-to-end test est terminé si le flux de travail s'est terminé avec succès (le statut du Job est terminé).

   Dans l'onglet Mesures de la page détaillée du flux de travail correspondant, vous pouvez consulter les informations suivantes sous Statistiques relatives à la dernière tâche :

   • Le Job ID.

   • État de la tâche de flux de travail correspondante : En file d'attente, en cours, terminée, échouée

   • Durée d'exécution de la tâche de flux de travail.

   • Le nombre d'enregistrements traités.

   • Le nombre d'enregistrements non traités.

   • La correspondance unique IDs générée.

   • Le nombre d'enregistrements en entrée.

   Vous pouvez également consulter les statistiques des tâches correspondant aux tâches de flux de travail précédemment exécutées dans l'historique des tâches.