Migration de Blazegraph vers Amazon Neptune

Si vous avez un graphe dans le triplestore RDF open source Blazegraph, vous pouvez migrer ses données vers Amazon Neptune en suivant les étapes ci-dessous :

• Provisionnez l'infrastructure AWS. Commencez par provisionner l'infrastructure Neptune requise à l'aide d'un modèle CloudFormation AWS (voir Créer un cluster de bases de données).

• Exportez les données à partir de Blazegraph. Il existe deux méthodes principales pour exporter des données à partir de Blazegraph : les requêtes SPARQL CONSTRUCT ou l'utilitaire d'exportation Blazegraph.

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

En règle générale, cette approche s'applique également à la migration à partir d'autres bases de données triplestore RDF.

Compatibilité entre Blazegraph et Neptune

Avant de migrer les données de votre graphe vers Neptune, il est important de connaître 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. Elles peuvent même compliquer la migration :

• 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. Le cas échéant, informez-vous 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.

• Query hints : Blazegraph et Neptune étendent SPARQL avec le concept d'indicateurs de requête. Au cours d'une migration, vous devez migrer tous les indicateurs de requête que vous utilisez. Pour en savoir plus sur les derniers indicateurs de requête pris en charge par Neptune, consultez Indicateurs de requête SPARQL.

• Inférence : Blazegraph prend en charge l'inférence en tant qu'option configurable en mode triplet, mais pas en mode quadruplet. 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 fonctionnalité n'est pas encore disponible dans Neptune.

• Architecture mutualisée : Blazegraph prend en charge l'architecture mutualisée au sein d'une base de données unique. Dans Neptune, l'architecture mutualisée 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 locataire.

• Fédération : Neptune prend actuellement en charge la fédération SPARQL 1.1 vers des emplacements accessibles à l'instance Neptune, par exemple au sein du VPC privé, entre des VPC ou vers des points de terminaisoniInternet 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 des normes Blazegraph : Blazegraph inclut plusieurs extensions aux normes d'API REST et SPARQL, tandis que Neptune n'est compatible qu'avec les spécifications de normes elles-mêmes. Cela peut nécessiter des modifications de votre application ou rendre la migration difficile.

Provisionnement de l'infrastructure AWS pour Neptune

Bien que vous puissiez construire l'infrastructure AWS requise manuellement via la AWS Management Console ou l'AWS CLI, il est souvent plus pratique d'utiliser un modèle CloudFormation à la place, comme décrit ci-dessous :

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

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

2. Choisissez Launcer la pile dans votre région préférée.

3. Définissez les paramètres obligatoires (nom de la pile et EC2SSHKeyPairName). 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 en bloc des données.

   • Définissez NotebookInstanceType sur le type d'instance que vous préférez. Ce paramètre crée un classeur Neptune que vous utiliserez pour exécuter le chargement en bloc dans Neptune et pour valider la migration.

4. Choisissez Suivant.

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

6. Choisissez Suivant.

7. Passez en revue les options qui s'offrent à vous et cochez les deux cases pour accepter qu'AWS CloudFormation puisse nécessiter des fonctionnalités supplémentaires.

8. Sélectionnez Créer la pile.

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

Exportation de données à partir de Blazegraph

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

En fonction de la manière dont les données sont stockées dans Blazegraph (triplets ou quadruplets) 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 quadruplets, vous pouvez choisir d'exporter les données au format N-Quads ou d'exporter chaque graphe nommé sous forme de triplets.

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

Si Blazegraph doit être en ligne et disponible pendant la migration, utilisez des requêtes SPARQL CONSTRUCT. Cela nécessite que vous installiez, configuriez et exécutiez une instance Blazegraph avec un point de terminaison SPARQL accessible.

Si vous n'avez pas besoin que Blazegraph soit en ligne, optez pour l'utilitaire BlazeGraph Export. 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 à partir de Blazegraph à l'aide de SPARQL CONSTRUCT

SPARQL CONSTRUCT est une fonctionnalité SPARQL qui renvoie un graphe RDF correspondant au modèle de requête spécifié. Dans ce cas d'utilisation, vous pouvez l'utiliser pour exporter les données un espace de noms à la fois, à l'aide d'une requête comme celle-ci :

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

Bien que d'autres outils RDF permettent d'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 (version 3.6 ou ultérieure) 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'en-tête Accept pour exporter les données dans un format approprié (N-Triples, RDF/XML ou Turtle) en utilisant les valeurs spécifiées dans le référentiel GitHub de Blazegraph.

Exportation de données à l'aide de l'utilitaire d'exportation Blazegraph

Blazegraph contient une méthode d'utilitaire pour exporter les données, à savoir la classe ExportKB. ExportKB facilite l'exportation des données à partir de Blazegraph, mais contrairement à la méthode précédente, nécessite que le serveur soit hors ligne pendant l'exportation. Il s'agit de la méthode de choix lorsque vous pouvez mettre Blazegraph hors ligne pendant la migration ou lorsque la migration peut se faire à partir d'une sauvegarde des données.

Vous devez exécuter l'utilitaire à partir d'une ligne de commande Java sur un ordinateur sur lequel Blazegraph est installé, mais ne fonctionne pas. 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 : répertoire de sortie des données exportées. Les fichiers au format tar.gz se trouvent dans un sous-répertoire nommé comme indiqué dans la base de connaissances.

• format : format de sortie souhaité suivi de l'emplacement du fichier RWStore.properties. Si vous travaillez avec des triplets, vous devez remplacer le paramètre -format par N-Triples, Turtle ou RDF/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, la sortie ressemble à ce qui suit :

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éation d'un compartiment Amazon Simple Storage Service (Amazon S3) pour y copier les données exportées

Une fois que vous avez exporté vos données à partir de Blazegraph, créez un compartiment Amazon Simple Storage Service (Amazon S3) dans la même région que le cluster de bases de données Neptune cible pour que le chargeur en bloc Neptune puisse l'utiliser pour importer les données.

Pour obtenir des instructions sur la création d'un compartiment Amazon S3, consultez Comment créer un compartiment S3 ? dans le Guide de l'utilisateur Amazon Simple Storage Service, ainsi que des exemples de création d'un compartiment dans le Guide de l'utilisateur Amazon Simple Storage Service.

Pour obtenir des instructions sur la façon de copier les fichiers de données que vous avez exportés dans le nouveau compartiment Amazon S3, consultez la section Chargement d'un objet dans un compartiment dans le Guide de l'utilisateur Amazon Simple Storage Service ou la section Utilisation de commandes de haut niveau (A3) avec AWS CLI. 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')

Utilisation du chargeur en bloc Neptune pour importer les données dans Neptune

Après avoir exporté vos données à partir de Blazegraph et après les avoir copiées dans un compartiment Amazon S3, vous pouvez les importer dans Neptune. Neptune dispose d'un chargeur en bloc qui charge les données plus rapidement et à moindre coût par rapport aux opérations de chargement effectuées à l'aide de SPARQL. Le processus de chargement en bloc est lancé par un appel à l'API du point de terminaison du chargeur afin de charger dans Neptune les données stockées dans le compartiment S3 identifié.

Bien que vous puissiez effectuer un appel direct au point de terminaison REST du chargeur, vous devez avoir accès au VPC privé dans lequel s'exécute l'instance Neptune cible. Vous pourriez configurer un hôte bastion, l'associer avec une connexion SSH à cet ordinateur et exécuter la commande cURL, mais l'utilisation du workbench Neptune est plus simple.

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

Pour démarrer le processus de chargement en bloc, utilisez la magie %load, qui fournit une interface permettant d'exécuter la Commande de chargeur Neptune :

1. Connectez-vous à la console de gestion AWS et ouvrez la console Amazon Neptune à l'adresse https://console.aws.amazon.com/neptune/home.

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

3. Choisissez Ouvrir un bloc-notes.

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

5. Dans le bloc-notes, ouvrez une cellule, entrez %load, puis exécutez-la.

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

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

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

   3. Pour ARN du chargement, entrez l'ARN du rôle IAMBulkLoad (ces informations se trouvent dans la console IAM sous Rôles).

7. Sélectionnez Envoyer.

Le résultat contient le statut de la demande. Les chargements en bloc sont souvent des processus de longue durée. La réponse ne signifie donc pas que le chargement est terminé, mais seulement qu'il a commencé. Ces informations de statut sont mises à jour périodiquement jusqu'à ce qu'elles indiquent que la tâche est terminée.

Note

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