Migration de Blazegraph vers Amazon Neptune

Si vous avez un graphique dans le triplestore RDF open source de Blazegraph, vous pouvez migrer les données de votre graphe vers Amazon Neptune en suivant les étapes suivantes :

• AWSInfrastructure de fourniture. Commencez par provisionner l'infrastructure Neptune requise à l'aide d'unAWS CloudFormation modèle (voirCréer un cluster de bases de données).

• Exportez des données depuis Blazegraph. Il existe deux méthodes principales pour exporter des données depuis Blazegraph, à savoir l'utilisation de requêtes SPARQL CONSTRUCT ou l'utilitaire Blazegraph Export.

• Importez les données dans Neptune. Vous pouvez ensuite charger les fichiers de données exportés dans Neptune à l'aide du workbench Neptune etChargeur en vrac Neptune.

Cette approche est également généralement applicable à la migration depuis d'autres bases de données RDF Triplestore.

Compatibilité entre Blazegraph et Neptune

Avant de migrer les données de votre graphe vers Neptune, vous devez être conscient de plusieurs différences importantes entre Blazegraph et Neptune. Ces différences peuvent nécessiter des modifications des requêtes, de l'architecture de l'application, ou des deux, voire rendre la migration peu pratique :

• Full-text search— Dans Blazegraph, vous pouvez utiliser des fonctionnalités de recherche en texte intégral internes ou externes grâce à une intégration avec Apache Solr. Si vous utilisez l'une de ces fonctionnalités, restez informé des dernières mises à jour concernant les fonctionnalités de recherche en texte intégral prises en charge par Neptune. Consultez Recherche en texte intégral Neptune Recherche en texte intégral Neptune SQL.

• Query hints— Blazegraph et Neptune étendent SPARQL en utilisant le concept d'indices de requête. Au cours d'une migration, vous devez migrer tous les indices de requête que vous utilisez. Pour plus d'informations sur les derniers indices de requête pris en charge par Neptune, consultezIndicateurs de requête SPARQL.

• Inférence — Blazegraph prend en charge l'inférence en tant qu'option configurable en mode triples, mais pas en mode quads. Neptune ne prend pas encore en charge l'inférence.

• Recherche géospatiale — Blazegraph prend en charge la configuration d'espaces de noms qui permettent la prise en charge géospatiale. Cette fonction n'est pas disponible depuis Neptune.

• Multilocation — Blazegraph prend en charge la mutualisation au sein d'une seule base de données. Dans Neptune, la mutualisation est prise en charge soit en stockant les données dans des graphes nommés et en utilisant les clauses USING NAMED pour les requêtes SPARQL, soit en créant un cluster de bases de données distinct pour chaque client.

• Fédération : Neptune prend actuellement en charge la fédération SPARQL 1.1 vers des emplacements accessibles à l'instance Neptune, tels que le VPC privé, entre des VPC ou des points de terminaison Internet externes. En fonction de la configuration spécifique et des points de terminaison de fédération requis, vous aurez peut-être besoin d'une configuration réseau supplémentaire.

• Extensions aux normes Blazegraph — Blazegraph inclut plusieurs extensions aux normes d'API SPARQL et REST, tandis que Neptune n'est compatible qu'avec les spécifications des normes elles-mêmes. Cela peut nécessiter des modifications de votre application ou compliquer la migration.

Approvisionnement deAWS l'infrastructure pour Neptune

Bien que vous puissiez créer l'AWSinfrastructure requise manuellement via leAWS Management Console ouAWS CLI, il est souvent plus pratique d'utiliser un CloudFormation modèle, comme décrit ci-dessous :

Provisionnement de Neptune à l'aide d'un CloudFormation modèle :

1. Accédez à Utilisation d'uneAWS CloudFormation pile pour créer un cluster de base de données Neptune.

2. Choisissez Launch Stack dans la région de votre choix.

3. Définissez les paramètres requis (nom de la pile etEC2SSHKeyPairName). Définissez également les paramètres facultatifs suivants pour faciliter le processus de migration :

   • Définissez AttachBulkloadIAMRoleToNeptuneCluster sur true. Ce paramètre permet de créer et d'associer le rôle IAM approprié à votre cluster afin de permettre le chargement de données en masse.

   • DéfinissezNotebookInstanceType le type d'instance de votre choix. Ce paramètre crée un classeur Neptune que vous utilisez pour exécuter le chargement groupé dans Neptune et valider la migration.

4. Choisissez Suivant.

5. Définissez toutes les autres options de pile que vous souhaitez.

6. Choisissez Suivant.

7. Passez en revue vos options et cochez les deux cases pour reconnaître que des fonctionnalités supplémentairesAWS CloudFormation peuvent être nécessaires.

8. Sélectionnez Create stack (Créer une pile).

Le processus de création de la pile peut prendre quelques minutes.

Exportation de données depuis Blazegraph

L'étape suivante consiste à exporter les données depuis Blazegraph dans un format compatible avec le chargeur en masse Neptune.

En fonction de la manière dont les données sont stockées dans Blazegraph (triples ou quadruples) et du nombre de graphes nommés utilisés, Blazegraph peut vous demander d'effectuer le processus d'exportation plusieurs fois et de générer plusieurs fichiers de données :

• Si les données sont stockées sous forme de triplets, vous devez exécuter une exportation pour chaque graphe nommé.

• Si les données sont stockées sous forme de quads, vous pouvez choisir d'exporter les données au format N-Quads ou d'exporter chaque graphe nommé au format triples.

Ci-dessous, nous supposons que vous exportez un seul espace de noms en tant que N-Quads, mais vous pouvez répéter le processus pour des espaces de noms supplémentaires ou les formats d'exportation souhaités.

Si vous avez besoin que Blazegraph soit en ligne et disponible pendant la migration, utilisez les requêtes SPARQL CONSTRUCT. Cela nécessite l'installation, la configuration et l'exécution d'une instance Blazegraph avec un point de terminaison SPARQL accessible.

Si vous n'avez pas besoin que Blazegraph soit en ligne, utilisez l'utilitaire BlazeGraph d'exportation. Pour ce faire, vous devez télécharger Blazegraph. Le fichier de données et les fichiers de configuration doivent être accessibles, mais le serveur n'a pas besoin d'être en cours d'exécution.

Exportation de données depuis Blazegraph à l'aide de SPARQL CONSTRUCT

SPARQL CONSTRUCT est une fonctionnalité de SPARQL qui renvoie un graphe RDF correspondant au modèle de requête spécifié. Dans ce cas d'utilisation, vous l'utilisez pour exporter vos données un espace de noms à la fois, à l'aide d'une requête telle que la suivante :

CONSTRUCT WHERE { hint:Query hint:analytic "true" . hint:Query hint:constructDistinctSPO "false" . ?s ?p ?o }

Bien que d'autres outils RDF existent pour exporter ces données, le moyen le plus simple d'exécuter cette requête est d'utiliser le point de terminaison de l'API REST fourni par Blazegraph. Le script suivant montre comment utiliser un script Python (3.6+) pour exporter des données au format N-Quads :

import requests

# Configure the URL here: e.g. http://localhost:9999/sparql
url = "http://localhost:9999/sparql"
payload = {'query': 'CONSTRUCT WHERE { hint:Query hint:analytic "true" . hint:Query hint:constructDistinctSPO "false" . ?s ?p ?o }'}
# Set the export format to be n-quads
headers = {
'Accept': 'text/x-nquads'
}
# Run the http request
response = requests.request("POST", url, headers=headers, data = payload, files = [])
#open the file in write mode, write the results, and close the file handler
f = open("export.nq", "w")
f.write(response.text)
f.close()

Si les données sont stockées sous forme de triplets, vous devez modifier le paramètre d'Accepten-tête pour exporter les données dans un format approprié (N-Triples, RDF/XML ou Turtle) en utilisant les valeurs spécifiées dans le GitHub référentiel Blazegraph.

Utilisation de l'utilitaire d'exportation Blazegraph pour exporter des données

Blazegraph contient une méthode utilitaire pour exporter des données, à savoir laExportKB classe. ExportKBfacilite l'exportation de données depuis Blazegraph, mais contrairement à la méthode précédente, nécessite que le serveur soit hors ligne pendant l'exécution de l'exportation. Cela en fait la méthode idéale à utiliser lorsque vous pouvez mettre Blazegraph hors ligne pendant la migration, ou lorsque la migration peut avoir lieu à partir d'une sauvegarde des données.

Vous exécutez l'utilitaire à partir d'une ligne de commande Java sur une machine sur laquelle Blazegraph est installé mais qui n'est pas en cours d'exécution. Le moyen le plus simple d'exécuter cette commande est de télécharger la dernière version de blazegraph.jar située sur GitHub. L'exécution de cette commande nécessite plusieurs paramètres :

• log4j.primary.configuration— Emplacement du fichier de propriétés log4j.

• log4j.configuration— Emplacement du fichier de propriétés log4j.

• output— Le répertoire de sortie pour les données exportées. Les fichiers se trouventtar.gz dans un sous-répertoire nommé comme indiqué dans la base de connaissances.

• format— Le format de sortie souhaité suivi de l'emplacement duRWStore.properties fichier. Si vous travaillez avec des triplets, vous devez remplacer le-format paramètre parN-TriplesTurtle, ouRDF/XML.

Par exemple, si vous disposez du fichier journal et des fichiers de propriétés Blazegraph, exportez les données au format N-Quads à l'aide du code suivant :

java -cp blazegraph.jar \
    com.bigdata.rdf.sail.ExportKB \
    -outdir ~/temp/ \
    -format N-Quads \
    ./RWStore.properties

Si l'exportation réussit, vous devez voir une sortie similaire à la suivante :

Exporting kb as N-Quads on /home/ec2-user/temp/kb
Effective output directory: /home/ec2-user/temp/kb
Writing /home/ec2-user/temp/kb/kb.properties
Writing /home/ec2-user/temp/kb/data.nq.gz
Done

Créez un compartiment Amazon Simple Storage Service (Amazon S3) et copiez-y les données exportées

Une fois que vous avez exporté vos données depuis Blazegraph, créez un compartiment Amazon Simple Storage Service (Amazon S3) dans la même région que le cluster de base de données Neptune cible que le chargeur en masse Neptune utilisera pour importer les données.

Pour de plus amples informations sur la création d'un compartiment Amazon S3, consultez Comment créer un compartiment S3 ? dans le Guide de l'utilisateur d'Amazon Simple Storage Service, et des exemples de création d'un compartiment dans le Guide de l'utilisateur d'Amazon Simple Storage Service.

Pour obtenir des instructions sur la manière de copier les fichiers de données que vous avez exportés dans le nouveau compartiment Amazon S3, consultez Chargement d'un objet vers un compartiment dans le guide de l'utilisateur d'Amazon Simple Storage Service ou Utilisation de commandes de haut niveau (s3) avec l'AWSinterface de ligne de commande. Vous pouvez également utiliser le code Python suivant pour copier les fichiers un par un :

import boto3

region = 'region name'
bucket_name = 'bucket name'
s3 = boto3.resource('s3')
s3.meta.client.upload_file('export.nq', bucket_name, 'export.nq')

Utilisez le chargeur en masse Neptune pour importer les données dans Neptune

Après avoir exporté vos données depuis Blazegraph et les avoir copiées dans un compartiment Amazon S3, vous êtes prêt à importer les données dans Neptune. Neptune dispose d'un chargeur en masse qui charge les données plus rapidement et avec moins de frais que l'exécution d'opérations de chargement à l'aide de SPARQL. Le processus de chargement en bloc est lancé par un appel à l'API du point de terminaison du chargeur pour charger les données stockées dans le compartiment S3 identifié dans Neptune.

Bien que vous puissiez le faire en appelant directement le point de terminaison REST du chargeur, vous devez avoir accès au VPC privé dans lequel s'exécute l'instance Neptune cible. Vous pouvez configurer un hôte bastion, connecter SSH à cette machine et exécuter la commande cURL, mais l'utilisation de Neptune Workbench est plus simple.

Neptune Workbench est un bloc-notes Jupyter préconfiguré fonctionnant comme un SageMaker bloc-notes Amazon, sur lequel sont installées plusieurs fonctionnalités de bloc-notes spécifiques à Neptune. Ces magies simplifient les opérations courantes de Neptune, telles que la vérification de l'état du cluster, l'exécution des traversées SPARQL et Gremlin et l'exécution d'une opération de chargement groupé.

Pour démarrer le processus de chargement groupé, utilisez la%load magie, qui fournit une interface pour exécuterCommande Neptune Loader :

1. Connectez-vous à la Console deAWS gestion et ouvrez la console Amazon Neptune via https://console.aws.amazon.com/neptune/home.

2. Sélectionnez aws-neptune-blazegraph-to-neptune.

3. Choisissez Ouvrir le bloc-notes.

4. Dans l'instance en cours d'exécution de Jupyter, sélectionnez un bloc-notes existant ou créez-en un nouveau à l'aide du noyau Python 3.

5. Dans votre bloc-notes, ouvrez une cellule%load, saisissez-la et exécutez-la.

6. Définissez les paramètres du chargeur en vrac :

   1. Dans le champ Source, entrez l'emplacement du fichier source à importer :s3://{bucket_name}/{file_name}.

   2. Pour Format, choisissez le format approprié, qui est dans cet exemplenquads.

   3. Pour Load ARN, entrez l'ARN duIAMBulkLoad rôle (ces informations se trouvent sur la console IAM sous Rôles).

7. Sélectionnez Submit (Envoyer).

Le résultat contient le statut de la requête. Les chargements en vrac sont souvent des processus de longue haleine, de sorte que la réponse ne signifie pas que le chargement est terminé, mais seulement qu'il a commencé. Ces informations d'état sont mises à jour régulièrement jusqu'à ce qu'elles indiquent que la tâche est terminée.

Note

Ces informations sont également disponibles dans le billet de blog intitulé Moving to the cloud : Migrating Blazegraph to Amazon Neptune.