Les traductions sont fournies par des outils de traduction automatique. En cas de conflit entre le contenu d'une traduction et celui de la version originale en anglais, la version anglaise prévaudra. # Chargement de données dans Amazon Neptune Il existe plusieurs façons de charger des données de graphe dans Amazon Neptune : + Si vous n'avez besoin de charger qu'une quantité relativement faible de données, vous pouvez utiliser des requêtes telles que les `INSERT` instructions SPARQL ou Gremlin `mergeV` et `mergeE` les étapes. OpenCypher inclut également des clauses and. `CREATE` `MERGE` + Vous pouvez profiter des avantages offerts par [Chargeur en bloc Neptune](bulk-load.md) pour ingérer de grandes quantités de données résidant dans des fichiers externes. La commande de chargement en bloc est plus rapide et demande moins de ressources que les commandes de langage de requête. Elle est optimisée pour les jeux de données volumineux et prend en charge les données RDF (Resource Description Framework) et les données Gremlin. + Vous pouvez utiliser AWS Database Migration Service (AWS DMS) pour importer des données depuis d'autres magasins de données (voir [Utilisation AWS Database Migration Service pour charger des données dans Amazon Neptune à partir d'un autre magasin de données](dms-neptune.md) et [Guide de AWS Database Migration Service l'utilisateur](https://docs.aws.amazon.com/dms/latest/userguide/)). + Pour les petits ensembles de données contenus dans un ou plusieurs fichiers Amazon S3, vous pouvez utiliser des fonctions de chargement basées sur des requêtes pour lire et traiter les données directement dans vos requêtes. Pour plus d’informations, consultez [Chargement de données dans Amazon Neptune à l'aide de requêtes](load-data-via-query.md). **Topics** + [Utilisation du chargeur en vrac Amazon Neptune pour ingérer des données](bulk-load.md) + [Utilisation AWS Database Migration Service pour charger des données dans Amazon Neptune à partir d'un autre magasin de données](dms-neptune.md) + [Chargement de données dans Amazon Neptune à l'aide de requêtes](load-data-via-query.md) # Utilisation du chargeur en vrac Amazon Neptune pour ingérer des données Amazon Neptune fournit une commande `Loader` pour le chargement de données depuis des fichiers externes directement dans un cluster de bases de données Neptune. Vous pouvez utiliser cette commande au lieu d'exécuter un grand nombre de déclarations `INSERT`, d'étapes `addV` et `addE` ou d'autres appels d'API. La commande Neptune **Loader** est plus rapide, nécessite moins de ressources, est optimisée pour les jeux de données volumineux et prend en charge à la fois les données RDF (Resource Description Framework) et Gremlin utilisées par SPARQL. Le diagramme suivant présente un aperçu du processus de chargement. ![\[Schéma illustrant les étapes de base impliquées dans le chargement de données dans Neptune.\]](http://docs.aws.amazon.com/fr_fr/neptune/latest/userguide/images/load-diagram.png) Voici les étapes du processus de chargement : 1. Chargez le fichier de données dans un compartiment Amazon Simple Storage Service (Amazon S3). 1. Créer un rôle IAM avec un accès en lecture et de type Liste au compartiment. 1. Créez un point de terminaison de VPC Amazon S3 1. Pour démarrer le chargeur Neptune, envoyez une demande via HTTP à l'instance de base de données Neptune. 1. L'instance de base de données Neptune endosse le rôle IAM pour charger les données à partir du compartiment. **Note** Vous pouvez charger des données chiffrées depuis Amazon S3 si elles ont été chiffrées à l'aide du mode Amazon S3 `SSE-S3` ou `SSE-KMS`, à condition que le rôle que vous utilisez pour le chargement en bloc ait accès à l'objet Amazon S3 et, dans le cas de SSE-KMS, à `kms:decrypt`. Neptune pourra ainsi emprunter vos informations d'identification et émettre des appels `s3:getObject` en votre nom. Cependant, à ce stade, Neptune ne permet pas lle chargement de données chiffrées avec le mode `SSE-C`. Les sections suivantes fournissent des instructions pour la préparation et le chargement des données dans Neptune. **Topics** + [Prérequis : rôle IAM et accès à Amazon S3](bulk-load-tutorial-IAM.md) + [Formats de chargement de données](bulk-load-tutorial-format.md) + [Exemple : chargement de données dans une instance de base de données Neptune](bulk-load-data.md) + [Optimisation d'un chargement en bloc sur Amazon Neptune](bulk-load-optimize.md) + [Référence du chargeur Neptune](load-api-reference.md) # Prérequis : rôle IAM et accès à Amazon S3 Le chargement de données depuis un compartiment Amazon Simple Storage Service (Amazon S3) nécessite Gestion des identités et des accès AWS un rôle (IAM) ayant accès au compartiment. Amazon Neptune endossera ce rôle pour charger les données. **Note** Vous pouvez charger des données chiffrées à partir d'Amazon S3 si elles ont été chiffrées avec le mode `SSE-S3` d'Amazon S3. Dans ce cas, Neptune peut emprunter vos informations d'identification et émettre des appels `s3:getObject` en votre nom. Vous pouvez également charger les données chiffrées à l'aide du mode `SSE-KMS` à partir d'Amazon S3, à condition que votre rôle IAM implique les autorisations nécessaires pour accéder à AWS KMS. Sans AWS KMS autorisations appropriées, l'opération de chargement en bloc échoue et renvoie une `LOAD_FAILED` réponse. Neptune ne permet actuellement pas le chargement des données chiffrées Amazon S3 avec le mode `SSE-C`. Les sections suivantes montrent comment utiliser une politique IAM gérée pour créer un rôle IAM permettant d'accéder aux ressources Amazon S3, puis attacher le rôle à votre cluster Neptune. **Topics** + [Création d'un rôle IAM pour autoriser Amazon Neptune à accéder aux ressources Amazon S3](bulk-load-tutorial-IAM-CreateRole.md) + [Ajout du rôle IAM à un cluster Amazon Neptune](bulk-load-tutorial-IAM-add-role-cluster.md) + [Création du point de terminaison de VPC Amazon S3](bulk-load-tutorial-vpc.md) + [Chaînage des rôles IAM dans Amazon Neptune](bulk-load-tutorial-chain-roles.md) **Note** Pour ces instructions, vous devez disposer d'un accès à la console IAM et des autorisations nécessaires pour gérer les rôles et les politiques IAM. Pour plus d'informations, consultez la section [Autorisations de travail dans la console AWS de gestion](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_permissions-required.html#Credentials-Permissions-overview-console) dans le *guide de l'utilisateur IAM*. La console Amazon Neptune a besoin que l'utilisateur dispose des autorisations IAM suivantes pour attacher le rôle au cluster Neptune : ``` iam:GetAccountSummary on resource: * iam:ListAccountAliases on resource: * iam:PassRole on resource: * with iam:PassedToService restricted to rds.amazonaws.com ``` # Création d'un rôle IAM pour autoriser Amazon Neptune à accéder aux ressources Amazon S3 Utilisez la politique IAM gérée `AmazonS3ReadOnlyAccess` pour créer un rôle IAM qui permet à Amazon Neptune d'accéder aux ressources Amazon S3. **Pour créer un rôle IAM autorisant Neptune à accéder à Amazon S3** 1. Ouvrez la console IAM à l’adresse [https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/). 1. Dans le panneau de navigation, choisissez **Rôles**. 1. Sélectionnez **Create role** (Créer un rôle). 1. Sous **Service AWS **, sélectionnez **S3**. 1. Choisissez **Suivant : Autorisations**. 1. Utilisez le champ de filtre pour filtrer par le terme **S3** et cochez la case à côté d'**AmazonS3 ReadOnlyAccess**. **Note** Cette stratégie accorde les autorisations `s3:Get*` et `s3:List*` à tous les compartiments. Les étapes ultérieures limitent l'accès au rôle à l'aide de la stratégie d'approbation. Le chargeur requiert uniquement les autorisations `s3:Get*` et `s3:List*` au niveau du compartiment à partir duquel vous effectuez le chargement. Vous pouvez donc également restreindre ces autorisations par la ressource Amazon S3. Si votre compartiment S3 est chiffré, vous devez ajouter les autorisations `kms:Decrypt` 1. Choisissez **Suivant : Vérification**. 1. Dans **Nom du rôle**, attribuez un nom au rôle IAM (par exemple, `NeptuneLoadFromS3`). Vous pouvez également ajouter une valeur facultative dans le champ **Description du rôl)** (par exemple, « Autorise Neptune à accéder aux ressources S3 en votre nom »). 1. Choisissez **Create Role** (Créer un rôle). 1. Dans le panneau de navigation, choisissez **Rôles**. 1. Dans le champ **Search (Rechercher)**, saisissez le nom du rôle que vous avez créé, puis choisissez celui-ci quand il s'affiche dans la liste. 1. Dans l'onglet **Trust Relationships (Relations d'approbation)**, choisissez **Edit trust relationship (Modifier la relation d'approbation)**. 1. Dans la zone de texte, copiez la stratégie d'approbation suivante. ------ #### [ JSON ] **** ``` { "Version":"2012-10-17", "Statement": [ { "Sid": "", "Effect": "Allow", "Principal": { "Service": [ "rds.amazonaws.com" ] }, "Action": "sts:AssumeRole" } ] } ``` ------ 1. Choisissez **Update Trust Policy (Mettre à jour la stratégie d’approbation)**. 1. Suivez les étapes de [Ajout du rôle IAM à un cluster Amazon Neptune](bulk-load-tutorial-IAM-add-role-cluster.md). # Ajout du rôle IAM à un cluster Amazon Neptune Utilisez la console pour ajouter le rôle IAM à un cluster Amazon Neptune. Cela permet à toute instance de base de données Neptune du cluster d'endosser le rôle et d'effectuer un chargement depuis Amazon S3. **Note** La console Amazon Neptune a besoin que l'utilisateur dispose des autorisations IAM suivantes pour attacher le rôle au cluster Neptune : ``` iam:GetAccountSummary on resource: * iam:ListAccountAliases on resource: * iam:PassRole on resource: * with iam:PassedToService restricted to rds.amazonaws.com ``` **Pour ajouter un rôle IAM à un cluster Amazon Neptune** 1. [Connectez-vous à la console AWS de gestion et ouvrez la console Amazon Neptune à https://console.aws.amazon.com/neptune/ la maison.](https://console.aws.amazon.com/neptune/home) 1. Dans le panneau de navigation, choisissez **Databases (Bases de données)**. 1. Choisissez l'identifiant du cluster que vous souhaitez modifier. 1. Choisissez l'onglet **Connectivité et sécurité**. 1. Dans la section Rôles IAM, choisissez le rôle que vous avez créé dans la section précédente. 1. Choisissez **Ajouter un rôle**. 1. Attendez que le rôle IAM devienne accessible au cluster avant de l'utiliser. # Création du point de terminaison de VPC Amazon S3 Le chargeur Neptune a besoin d'un point de terminaison de VPC de type passerelle pour Amazon S3. **Pour configurer l'accès à Amazon S3** 1. Connectez-vous à la console Amazon VPC AWS Management Console et ouvrez-la à l'adresse. [https://console.aws.amazon.com/vpc/](https://console.aws.amazon.com/vpc/) 1. Dans le panneau de navigation, choisissez **Points de terminaison**. 1. Choisissez **Create Endpoint** (Créer un point de terminaison). 1. Choisissez le **nom de service** `com.amazonaws.region.s3` pour le point de terminaison de type passerelle. **Note** Si la région dans ce champ est incorrecte, assurez-vous que la région de la console est correcte. 1. Choisissez le VPC qui contient l'instance de base de données Neptune (vous le trouverez dans la console Neptune). 1. Cochez la case en regard des tables de routage associées aux sous-réseaux liés à votre cluster. Si vous n'avez qu'une seule table de routage, vous devez cocher cette case. 1. Choisissez **Créer un point de terminaison**. Pour plus d'informations sur la création du point de terminaison, consultez [Points de terminaison de VPC](https://docs.aws.amazon.com/vpc/latest/userguide/vpc-endpoints.html#create-vpc-endpoint) dans le *Guide de l'utilisateur Amazon VPC*. Pour plus d'informations sur les limites qui s'appliquent aux points de terminaison d'un VPC, consultez [Points de terminaisons de VPC pour Amazon S3](https://docs.aws.amazon.com/vpc/latest/userguide/vpc-endpoints-s3.html). **Étapes suivantes** Maintenant que vous avez accordé l'accès au compartiment Amazon S3, vous pouvez préparer le chargement des données. Pour plus d'informations sur les formats pris en charge, consultez [Formats de chargement de données](bulk-load-tutorial-format.md). # Chaînage des rôles IAM dans Amazon Neptune **Important** La nouvelle fonctionnalité de chargement en bloc entre comptes, introduite dans la [version 1.2.1.0.R3 du moteur](engine-releases-1.2.1.0.R3.md), tire parti du chaînage des rôles IAM et peut dans certains cas entraîner une dégradation des performances de chargement en bloc. Par conséquent, les mises à niveau vers les versions du moteur prenant en charge cette fonctionnalité ont été temporairement suspendues jusqu'à ce que le problème soit résolu. Lorsque vous attachez un rôle à un cluster, ce dernier peut endosser ce rôle afin d'accéder aux données stockées dans Amazon S3. À partir de la [version 1.2.1.0.R3 du moteur](engine-releases-1.2.1.0.R3.md), si ce rôle n'a pas accès à toutes les ressources dont vous avez besoin, vous pouvez enchaîner un ou plusieurs rôles supplémentaires que votre cluster endossera pour accéder à d'autres ressources. Chaque rôle de la chaîne passe au rôle suivant, jusqu'à ce que le cluster endosse le dernier rôle à la fin de la chaîne. Pour enchaîner des rôles, vous devez établir une relation d'approbation entre eux. Par exemple, pour enchaîner `RoleB` à `RoleA`, `RoleA` doit disposer d'une politique d'autorisations lui permettant d'endosser `RoleB`, et `RoleB` d'une politique d'approbation lui permettant de retransmettre ses autorisations à `RoleA`. Pour plus d'informations, consultez [Utilisation de rôles IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_use.html). Le premier rôle de la chaîne doit être attaché au cluster qui charge les données. Le premier rôle, ainsi que chaque rôle ultérieur qui endosse le rôle suivant dans la chaîne, doivent avoir les éléments suivants : + Une politique qui inclut une déclaration spécifique ayant un effet `Allow` sur l'action `sts:AssumeRole`. + L'Amazon Resource Name (ARN) du rôle dans un élément `Resource`. **Note** Le compartiment Amazon S3 cible doit se trouver dans la même AWS région que le cluster. ## Accès intercompte à l'aide de rôles enchaînés Vous pouvez accorder un accès intercompte en enchaînant un ou plusieurs rôles appartenant à un autre compte. Lorsque votre cluster endosse temporairement un rôle appartenant à un autre compte, il peut accéder aux ressources qui s'y trouvent. Supposons, par exemple, que le **compte A** souhaite accéder à des données dans un compartiment Amazon S3 appartenant au **compte B** : + Le **compte A** crée un rôle de AWS service nommé pour Neptune `RoleA` et l'attache à un cluster. + Le **compte B** crée un rôle nommé `RoleB` qui est autorisé à accéder aux données du compartiment du **compte B**. + Le **compte A** attache une politique d'autorisation à `RoleA` qui lui permet d'endosser `RoleB`. + Le **compte B** attache une politique d'approbation à `RoleB` qui lui permet de retransmettre ses autorisations à `RoleA`. + Pour accéder aux données dans le compartiment du **compte B**, le **compte A** exécute une commande de chargeur à l'aide d'un paramètre `iamRoleArn` qui enchaîne les rôles `RoleA` et `RoleB`. Pendant la durée de l'opération de chargeur, `RoleA` endosse temporairement `RoleB` pour accéder au compartiment Amazon S3 dans le **compte B**. ![\[Schéma illustrant l'accès intercompte à l'aide de rôles enchaînés\]](http://docs.aws.amazon.com/fr_fr/neptune/latest/userguide/images/cross-account-bulk-load.png) Par exemple, `RoleA` a une politique d'approbation établissant une relation d'approbation avec Neptune : ------ #### [ JSON ] **** ``` { "Version":"2012-10-17", "Statement": [ { "Effect": "Allow", "Principal": { "Service": "rds.amazonaws.com" }, "Action": "sts:AssumeRole" } ] } ``` ------ `RoleA` a également une politique d'autorisation lui permettant d'endosser `RoleB`, qui appartient au **compte B** : ------ #### [ JSON ] **** ``` { "Version":"2012-10-17", "Statement": [ { "Sid": "Stmt1487639602000", "Effect": "Allow", "Action": [ "sts:AssumeRole" ], "Resource": "arn:aws:iam::111122223333:role/RoleB" } ] } ``` ------ Inversement, `RoleB` a une politique d'approbation établissant une relation d'approbation avec `RoleA` : ------ #### [ JSON ] **** ``` { "Version":"2012-10-17", "Statement": [ { "Effect": "Allow", "Action": "sts:AssumeRole", "Principal": { "AWS": "arn:aws:iam::111122223333:role/RoleA" } } ] } ``` ------ `RoleB` a également besoin d'une autorisation pour accéder aux données du compartiment Amazon S3 situé dans le **compte B**. ## Création d'un point de terminaison VPC AWS Security Token Service (STS) Le chargeur Neptune nécessite un point de terminaison VPC AWS STS lorsque vous chaînez des rôles IAM pour un accès privé via des adresses IP privées. AWS STS APIs Vous pouvez vous connecter directement d'un Amazon VPC à un point AWS STS de terminaison VPC de manière sécurisée et évolutive. Lorsque vous utilisez un point de terminaison de VPC d'interface, votre niveau de sécurité s'en trouve amélioré, car vous n'avez pas besoin d'ouvrir de pare-feu pour le trafic sortant. Vous bénéficiez en outre d'autres avantages liés à l'utilisation des points de terminaison Amazon VPC. Lorsque vous utilisez un point de terminaison VPC, le trafic vers AWS STS n'est pas transmis via Internet et ne quitte jamais le réseau Amazon. Votre VPC est connecté en toute sécurité, AWS STS sans risques de disponibilité ni contraintes de bande passante pour le trafic réseau. Pour plus d'informations, consultez [Utilisation des points de terminaison de VPC d'interface AWS STS](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_sts_vpce.html). **Pour configurer l'accès pour AWS Security Token Service (STS)** 1. Connectez-vous à la console Amazon VPC AWS Management Console et ouvrez-la à l'adresse. [https://console.aws.amazon.com/vpc/](https://console.aws.amazon.com/vpc/) 1. Dans le panneau de navigation, choisissez **Points de terminaison**. 1. Choisissez **Create Endpoint** (Créer un point de terminaison). 1. Choisissez le **nom de service** : `com.amazonaws.region.sts` pour le point de terminaison de type interface. 1. Choisissez le **VPC** qui contient votre instance de base de données Neptune et votre instance EC2. 1. Cochez la case située à côté du sous-réseau dans lequel se trouve votre instance EC2. Il n’est pas possible de sélectionner plusieurs sous-réseaux dans la même zone de disponibilité. 1. Pour IP address type (Type d'adresse IP), choisissez l'une des options suivantes : + **IPv4**— Attribuez IPv4 des adresses aux interfaces réseau de vos terminaux. Cette option n'est prise en charge que si tous les sous-réseaux sélectionnés possèdent des plages d' IPv4 adresses. + **IPv6**— Attribuez IPv6 des adresses aux interfaces réseau de vos terminaux. Cette option n'est prise en charge que si tous les sous-réseaux sélectionnés sont des sous-réseaux IPv6 réservés. + **Dualstack** — Attribuez à la fois des IPv6 adresses IPv4 et des adresses aux interfaces réseau de vos terminaux. Cette option n'est prise en charge que si tous les sous-réseaux sélectionnés possèdent à la fois des plages d' IPv6 adresses IPv4 et des plages d'adresses. 1. Pour **Security groups** (Groupes de sécurité), sélectionnez les groupes de sécurité à associer aux interfaces réseau du point de terminaison pour le point de terminaison d'un VPC. Vous devez sélectionner tous les groupes de sécurité attachés à votre instance de base de données Neptune et à votre instance EC2. 1. Pour **Policy** (Politique), sélectionnez **Full access** (Accès complet) pour autoriser toutes les opérations de tous les principaux sur toutes les ressources via le point de terminaison de VPC. Sinon, sélectionnez **Custom** (Personnalisé) pour joindre une politique de point de terminaison de VPC qui contrôle les autorisations dont disposent les principaux pour effectuer des actions sur les ressources via le point de terminaison de VPC. Cette option n’est disponible que si le service prend en charge les politiques de points de terminaison de VPC. Pour plus d'informations, consultez [Utilisation des politiques de point de terminaison](https://docs.aws.amazon.com/vpc/latest/privatelink/vpc-endpoints-access.html). 1. (*Facultatif*) Pour ajouter une balise, choisissez **Ajouter une nouvelle balise** et saisissez la clé et la valeur de cette balise. 1. Choisissez **Créer un point de terminaison**. Pour plus d'informations sur la création du point de terminaison, consultez [Points de terminaison de VPC](https://docs.aws.amazon.com/vpc/latest/privatelink/create-interface-endpoint.html) dans le Guide de l'utilisateur Amazon VPC. Notez que le point de terminaison de VPC Amazon STS est un prérequis pour le chaînage des rôles IAM. Maintenant que vous avez accordé l'accès au AWS STS point de terminaison, vous pouvez vous préparer à charger les données. Pour en savoir plus sur les formats de données pris en charge, consultez [Formats de chargement de données](bulk-load-tutorial-format.md). ## Chaînage des rôles dans une commande de chargeur Vous pouvez spécifier le chaînage des rôles lorsque vous exécutez une commande de chargeur en incluant une liste de rôles séparée par des virgules ARNs dans le paramètre. `iamRoleArn` Bien que vous n'ayez généralement besoin que de deux rôles dans une chaîne, il est possible d'en enchaîner trois ou plus. Par exemple, cette commande de chargeur enchaîne trois rôles : ``` curl -X POST https://localhost:8182/loader \ -H 'Content-Type: application/json' \ -d '{ "source" : "s3://(the target bucket name)/(the target date file name)", "iamRoleArn" : "arn:aws:iam::(Account A ID):role/(RoleA),arn:aws:iam::(Account B ID):role/(RoleB),arn:aws:iam::(Account C ID):role/(RoleC)", "format" : "csv", "region" : "us-east-1" }' ``` # Formats de chargement de données L'API Amazon Neptune `Load` permet le chargement de données dans différents formats. **Formats de chargement de graphes de propriétés** Les données chargées dans l'un des formats de graphes de propriétés suivants peuvent être interrogées à l'aide de Gremlin et d'openCypher : + [Format de chargement de données Gremlin](bulk-load-tutorial-format-gremlin.md) (`csv`) : format CSV (valeurs séparées par une virgule). + [Format de chargement de données openCypher (`opencypher`) :](bulk-load-tutorial-format-opencypher.md) format CSV (valeurs séparées par des virgules). **Formats de chargement RDF** Pour charger des données RDF (Resource Description Framework) à interroger avec SPARQL, vous pouvez utiliser l'un des formats standard suivants comme spécifié par W3C (World Wide Web Consortium) : + N-Triples (`ntriples`) de la spécification à l'adresse [https://www.w3.org/TR/n-triples/](https://www.w3.org/TR/n-triples/) + N-Quads (`nquads`) de la spécification à l'adresse [https://www.w3.org/TR/n-quads/](https://www.w3.org/TR/n-quads/) + RDF/XML (`rdfxml`) de la spécification à l'adresse [https://www.w3.org/TR/rdf-syntax-grammar/](https://www.w3.org/TR/rdf-syntax-grammar/) + Turtle (`turtle`) de la spécification à l'adresse [https://www.w3.org/TR/turtle/](https://www.w3.org/TR/turtle/) **Les données de chargement doivent utiliser l'encodage UTF-8** **Important** Tous les fichiers de chargement de données doivent être encodés au format UTF-8. Si un fichier n'est pas au format UTF-8, Neptune essaie de le charger dans ce format. Pour les données N-Quads et N-triples comprenant des caractères Unicode, les séquences d'échappement `\uxxxxx` sont prises en charge. Toutefois, Neptune ne prend pas en charge la normalisation. Si une valeur nécessitant une normalisation est présente, elle ne correspondra pas byte-to-byte lors de la requête. Pour plus d'informations sur la normalisation, consultez la page [Normalization](https://unicode.org/faq/normalization.html) sur [Unicode.org](https://unicode.org). Si vos données ne sont pas dans un format pris en charge, vous devez les convertir avant de les charger. Un outil permettant de convertir GraphML au format Neptune CSV est disponible dans le projet [Graph ML2](https://github.com/awslabs/amazon-neptune-tools/blob/master/graphml2csv/README.md) CSV sur. [GitHub](https://github.com/) ## Prise en charge de la compression des fichiers de chargement de données Neptune prend en charge la compression des fichiers individuels au format `gzip` ou `bzip2`. Le fichier compressé doit avoir une extension `.gz` ou `.bz2` et doit être un fichier texte encodé unique au format UTF-8. Vous pouvez charger plusieurs fichiers, mais chacun d'entre eux doit être un fichier `.gz`, `.bz2` ou non compressé distinct. Les fichiers d'archive portant des extensions telles que `.tar`, `.tar.gz` et `.tgz` ne sont pas pris en charge. Les sections suivantes décrivent les formats de façon plus détaillée. **Topics** + [Prise en charge de la compression des fichiers de chargement de données](#bulk-load-tutorial-format-compression) + [Format de chargement de données Gremlin](bulk-load-tutorial-format-gremlin.md) + [Format de chargement des données openCypher](bulk-load-tutorial-format-opencypher.md) + [Formats de chargement de données RDF](bulk-load-tutorial-format-rdf.md) # Format de chargement de données Gremlin Pour charger des données TinkerPop Apache G705 au format CSV, vous devez spécifier les sommets et les arêtes dans des fichiers séparés. Le chargeur peut effectuer le chargement depuis plusieurs fichiers de sommet et plusieurs fichiers d'arc en une seule tâche de chargement. Pour chaque commande de chargement, l'ensemble de fichiers à charger doit être dans le même dossier au sein du compartiment Amazon S3, et vous devez spécifier le nom du dossier pour le paramètre `source`. Les noms de fichier et les extensions de nom de fichier ne sont pas importants. Le format CSV Amazon Neptune respecte la spécification CSV RFC 4180. Pour plus d'informations, consultez [Common Format and MIME Type for CSV Files](https://tools.ietf.org/html/rfc4180) sur le site web Internet Engineering Task Force (IETF). **Note** Tous les fichiers doivent être encodés au format UTF-8. Chaque fichier comporte une ligne d'en-têtes séparés par des virgules. La ligne d'en-tête se compose d'en-têtes de colonne système et d'en-têtes de colonne de propriété. ## En-têtes de colonne système Les en-têtes de colonne système obligatoires et autorisés sont différents pour les fichiers de sommet et les fichiers d'arc. Chaque colonne système ne peut apparaître qu'une seule fois dans un en-tête. Toutes les étiquettes sont sensibles à la casse. **En-têtes de sommet** + `~id` - **Obligatoire** Un ID pour le sommet. + `~label` Une étiquette pour le sommet. Plusieurs valeurs d'étiquette sont autorisées, séparées par des points-virgules (`;`). S'il n'`~label`est pas présent, TinkerPop fournit une étiquette avec la valeur`vertex`, car chaque sommet doit avoir au moins une étiquette. **En-têtes d'arc** + `~id` - **Obligatoire** Un ID pour l'arc. + `~from` - **Obligatoire** ID de sommet du sommet *from*. + `~to` - **Obligatoire** ID de sommet du sommet *to*. + `~label` Étiquette de l'arête. Les arêtes ne peuvent avoir qu'une seule étiquette. S'il n'`~label`est pas présent, TinkerPop fournit une étiquette avec la valeur`edge`, car chaque arête doit avoir une étiquette. ## En-têtes de colonne de propriété Vous pouvez spécifier une colonne (`:`) pour une propriété à l'aide de la syntaxe suivante. Les noms de type ne sont pas sensibles à la casse. Notez toutefois que si le signe deux-points figure dans le nom d'une propriété, faites-le précéder d'une barre oblique inverse comme caractère d'échappement : `\:`. ``` propertyname:type ``` **Note** Les espaces, les virgules, le retour en chariot et les caractères de nouvelle ligne ne sont pas autorisés dans les en-têtes de colonne. Les noms de propriétés ne peuvent donc pas inclure ces caractères. Vous pouvez spécifier une colonne pour un type de tableau en ajoutant `[]` au type : ``` propertyname:type[] ``` **Note** Les propriétés d'arc ne peuvent avoir qu'une seule valeur et provoquent une erreur si un type de tableau ou une seconde valeur est spécifié. L'exemple suivant montre l'en-tête de colonne pour une propriété nommée `age` de type `Int`. ``` age:Int ``` Chaque ligne du fichier doit obligatoirement avoir un nombre entier dans cette position ou rester vide. Les tableaux de chaînes sont autorisés, mais les chaînes d'un tableau ne peuvent pas inclure le point-virgule (`;`), à moins qu'une barre oblique inverse n'y soit ajoutée comme caractère d'échappement (`\;`, par exemple). **Spécification de la cardinalité d'une colonne** L'en-tête de colonne peut être utilisé pour spécifier la *cardinalité* pour la propriété identifiée par la colonne. Ceci permet au chargeur en bloc de respecter la cardinalité de manière similaire à la façon dont le font les requêtes Gremlin. Vous spécifiez la cardinalité d'une colonne comme suit : ``` propertyname:type(cardinality) ``` La *cardinality* valeur peut être `single` soit`set`. La valeur par défaut est supposée être `set`, ce qui signifie que la colonne peut accepter plusieurs valeurs. Dans le cas des fichiers d'arête, la cardinalité est toujours unique (« single ») et si vous spécifiez une autre cardinalité, le chargeur déclenche une exception. Si la cardinalité est `single`, le chargeur déclenche une erreur si une valeur précédente est déjà présente pendant le chargement d'une valeur ou si plusieurs valeurs sont chargées. Ce comportement peut être ignoré afin qu'une valeur existante soit remplacée lorsqu'une nouvelle valeur est chargée à l'aide de l'indicateur `updateSingleCardinalityProperties`. Consultez [Commande Loader](load-api-reference-load.md). Il est possible d'utiliser un paramètre de cardinalité de type tableau, même si ce n'est généralement pas nécessaire. Voici les combinaisons possibles : + `name:type` : la cardinalité est `set`, et le contenu est à valeur unique. + `name:type[]` : la cardinalité est `set`, et le contenu est à valeurs multiples. + `name:type(single)` : la cardinalité est `single`, et le contenu est à valeur unique. + `name:type(set)` : la cardinalité est `set`, ce qui est identique à la valeur par défaut, et le contenu est à valeur unique. + `name:type(set)[]` : la cardinalité est `set`, et le contenu est à valeurs multiples. + `name:type(single)[]` : ce paramètre est contradictoire et génère une erreur. La section suivante répertorie tous les types de données Gremlin disponibles. ## Types de données Gremlin Il s'agit d'une liste des types de propriété autorisés, avec une description de chaque type. **Bool (ou booléen)** Indique un champ booléen. Valeurs autorisées : `false`, `true` **Note** Toute valeur autre que `true` sera traitée comme false. **Types de nombres entiers** Les valeurs en dehors des plages définies entraînent une erreur. | | | Type | Range | | --- |--- | | Octet | -128 à 127 | | Court | -32768 à 32767 | | Int | -2^31 à 2^31-1 | | Long | -2^63 à 2^63-1 | **Types de nombre décimal** Prend en charge la notation décimale ou la notation scientifique. Autorise également les symboles tels que (\$1/-) Infinity ou NaN. La clause INF n'est pas prise en charge. | | | Type | Range | | --- |--- | | Float | Virgule flottante IEEE 754 32 bits | | Double | Virgule flottante IEEE 754 64 bits | Les valeurs à virgule flottante et doubles qui sont trop longues sont chargées et arrondie à la valeur la plus proche pour la précision 24 bits (virgule flottante) et 53 bits (double). Une valeur du milieu est arrondie à 0 pour le dernier chiffre restant au niveau du bit. **String** Les guillemets sont facultatifs. Les virgules, et les caractères de saut de ligne et de retour à la ligne font automatiquement l'objet d'un échappement s'ils sont inclus dans une chaîne entourée de guillemets (`"`). *Exemple* : `"Hello, World"` Pour inclure des guillemets dans une chaîne entre guillemets, vous pouvez échapper les guillemets en utilisant deux guillemets dans une ligne : *Exemple :* `"Hello ""World"""` Les tableaux de chaînes sont autorisés, mais les chaînes d'un tableau ne peuvent pas inclure le point-virgule (`;`), à moins qu'une barre oblique inverse n'y soit ajoutée comme caractère d'échappement (`\;`, par exemple). Si vous souhaitez placer des chaînes d'un tableau entre guillemets, vous devez entourer la totalité du tableau par un ensemble de guillemets. *Exemple* : `"String one; String 2; String 3"` **Date** Date Java au format ISO 8601. Supporte les formats suivants :`yyyy-MM-dd`,`yyyy-MM-ddTHH:mm`,`yyyy-MM-ddTHH:mm:ss`,`yyyy-MM-ddTHH:mm:ssZ`. Les valeurs sont converties en heure d'époque et stockées. **Datetime** Date Java au format ISO 8601. Supporte les formats suivants :`yyyy-MM-dd`,`yyyy-MM-ddTHH:mm`,`yyyy-MM-ddTHH:mm:ss`,`yyyy-MM-ddTHH:mm:ssZ`. Les valeurs sont converties en heure d'époque et stockées. ## Format de ligne Gremlin **Délimiteurs** Les champs dans une ligne sont séparés par une virgule. Les enregistrements sont séparés par un saut de ligne ou par un saut de ligne suivi d'un retour chariot. **Champs vides** Des champs vides sont autorisés pour les colonnes non obligatoires (comme des propriétés définies par l'utilisateur). Un champ vide a quand même besoin d'une virgule comme séparateur. Les champs vides sur les colonnes obligatoires entraîneront une erreur d'analyse. Les valeurs de chaîne vides sont interprétées comme des valeurs de chaîne vides pour le champ, et non comme un champ vide. L'exemple de la section suivante comporte un champ vide dans chaque exemple de sommet. **Sommet IDs** Les valeurs `~id` doivent être uniques pour tous les sommets dans chaque fichier de sommets. Plusieurs lignes de sommet avec des valeurs `~id` identiques sont appliquées à un seul sommet dans le graphique. Une chaîne vide (`""`) est un identifiant valide, et le sommet est créé avec une chaîne vide comme identifiant. **Bord IDs** En outre, les valeurs `~id` doivent être uniques pour toutes les arêtes dans chaque fichier d'arête. Plusieurs lignes d'arête avec des valeurs `~id` identiques sont appliquées à la seule arête du graphe. La chaîne vide (`""`) est un identifiant valide, et le bord est créé avec une chaîne vide comme identifiant. **Étiquettes** Les étiquettes distinguent les majuscules et minuscules et ne peuvent pas être vides. Une valeur de `""` provoquera une erreur. **Valeurs de chaîne** Les guillemets sont facultatifs. Les virgules, et les caractères de saut de ligne et de retour à la ligne font automatiquement l'objet d'un échappement s'ils sont inclus dans une chaîne entourée de guillemets (`"`). `("")`Les valeurs de chaîne vides sont interprétées comme une valeur de chaîne vide pour le champ, et non comme un champ vide. ## Spécification du format CSV Le format CSV Neptune respecte la spécification CSV RFC 4180, y compris les exigences suivantes. + Les fins de ligne de style Unix et Windows sont prises en charge (\$1n ou \$1r\$1n). + Tout champ peut être placé entre guillemets. + Les champs contenant un saut de ligne, des guillemets ou des virgules doivent être placés entre guillemets. (Si ce n'est pas le cas, le chargement s'interrompt immédiatement.) + Les guillemets (`"`) dans un champ doit être représentés par des guillemets doubles. Par exemple, une chaîne `Hello "World"` doit figurer sous la forme `"Hello ""World"""` dans les données. + Les espaces entre les délimiteurs sont ignorés. Si une ligne est présente sous forme`value1, value2`, elle est stockée sous forme `"value1"` et`"value2"`. + Tous les autres caractères d'échappement sont stockés tels quels. Par exemple, `"data1\tdata2"` est stocké comme suit : `"data1\tdata2"`. Aucun autre échappement n'est nécessaire dans la mesure où ces caractères sont placés entre guillemets. + Les champs vides sont autorisés. Un champ vide est considéré comme une valeur vide. + Plusieurs valeurs pour un champ sont spécifiées séparées par un point-virgule (`;`). Pour plus d'informations, consultez [Common Format and MIME Type for CSV Files](https://tools.ietf.org/html/rfc4180) sur le site web Internet Engineering Task Force (IETF). ## Exemple Gremlin Le schéma suivant montre un exemple de deux sommets et d'une arête extraits du graphe TinkerPop moderne. ![\[Schéma décrivant deux sommets et une arête, contenant marko age 29 et le logiciel lop avec lang:java.\]](http://docs.aws.amazon.com/fr_fr/neptune/latest/userguide/images/tiny-modern-graph.png) Voici le graphe au format de chargement CSV Neptune. Fichier de sommets : ``` ~id,name:String,age:Int,lang:String,interests:String[],~label v1,"marko",29,,"sailing;graphs",person v2,"lop",,"java",,software ``` Vue tabulaire du fichier de sommets : | | | | | | | | --- |--- |--- |--- |--- |--- | | \$1id | name:String | age:Int | lang:String | Intérêts:string [] | \$1étiquette | | v1 | "marko" | 29 | | ["navigation », « graphes"] | personne | | v2 | "lop" | | "java" | | logiciel | Fichier d'arête : ``` ~id,~from,~to,~label,weight:Double e1,v1,v2,created,0.4 ``` Vue tabulaire du fichier d'arête : | | | | | | | --- |--- |--- |--- |--- | | \$1id | \$1de | \$1sur | \$1étiquette | weight:Double | | e1 | v1 | v2 | créé | 0.4 | **Étapes suivantes** Maintenant que vous en savez plus sur les formats de chargement, consultez [Exemple : chargement de données dans une instance de base de données Neptune](bulk-load-data.md). # Format de chargement des données openCypher Pour charger des données openCypher à l'aide du format CSV openCypher, vous devez spécifier les nœuds et les relations dans des fichiers séparés. Le chargeur peut charger les données à partir de plusieurs de ces fichiers de nœuds et fichiers de relations en une seule tâche de chargement. Pour chaque commande de chargement, l'ensemble de fichiers à charger doit avoir le même préfixe de chemin dans un compartiment Amazon Simple Storage Service. Vous spécifiez ce préfixe dans le paramètre source. Les noms et les extensions de fichier ne sont pas importants. Dans Amazon Neptune, le format CSV openCypher est conforme à la spécification CSV RFC 4180. Pour plus d'informations, consultez [Common Format et type MIME pour les fichiers CSV](https://tools.ietf.org/html/rfc4180) (https://tools.ietf.org/html/rfc4180) sur le site Web de l'Internet Engineering Task Force (IETF). **Note** Ces fichiers DOIVENT être encodés au format UTF-8. Chaque fichier possède une ligne d'en-têtes séparés par des virgules, qui contient à la fois les en-têtes de colonne système et les en-têtes de colonne des propriétés. ## En-têtes de colonne système dans les fichiers de chargement de données openCypher Une colonne système spécifique ne peut apparaître qu'une seule fois dans chaque fichier. Toutes les étiquettes d'en-tête de colonne système sont sensibles à la casse. Les en-têtes de colonne système obligatoires et autorisés sont différents pour les fichiers de chargement de nœuds et les fichiers de chargement de relations openCypher : ### En-têtes de colonnes système dans les fichiers de nœuds + **`:ID`** : (obligatoire) ID du nœud. Un espace d'ID facultatif peut être ajouté à l'en-tête de colonne du nœud `:ID` comme ceci : `:ID(ID Space)`. Par exemple : `:ID(movies)`. Lorsque vous chargez des relations qui connectent les nœuds de ce fichier, utilisez les mêmes espaces d'identification dans les `:START_ID` and/or `:END_ID` colonnes des fichiers de relations. La colonne du nœud `:ID` peut éventuellement être stockée en tant que propriété sous la forme `property name:ID`. Par exemple : `name:ID`. Le nœud IDs doit être unique parmi tous les fichiers de nœuds des chargements actuels et précédents. Si un espace d'identification est utilisé, le nœud IDs doit être unique parmi tous les fichiers de nœuds qui utilisent le même espace d'identification lors des chargements actuels et précédents. + **`:LABEL`** : étiquette du nœud. Lorsque vous utilisez plusieurs valeurs d'étiquette pour un seul nœud, chaque étiquette doit être séparée par des points-virgules (). `;` ### En-têtes de colonnes système dans les fichiers de relations + **`:ID`** : ID de la relation. Obligatoire lorsque `userProvidedEdgeIds` est défini sur true (valeur par défaut), mais non valide quand `userProvidedEdgeIds` indique `false`. La relation IDs doit être unique dans tous les fichiers de relations des chargements actuels et précédents. + **`:START_ID`** : (*obligatoire*) ID du nœud à partir duquel cette relation commence. Un espace d'ID peut être associé à la colonne d'ID de départ sous la forme `:START_ID(ID Space)`. L'espace d'ID attribué à l'ID du nœud de départ doit correspondre à l'espace d'ID attribué au nœud dans son fichier de nœud. + **`:END_ID`** : (*obligatoire*) ID du nœud où cette relation se termine. Un espace d'ID peut être associé à la colonne d'ID de fin sous la forme `:END_ID(ID Space)`. L'espace d'ID attribué à l'ID du nœud de fin doit correspondre à l'espace d'ID attribué au nœud dans son fichier de nœud. + **`:TYPE`** : type de relation. Les relations ne peuvent avoir qu'un seul type. **Note** Consultez [Chargement de données openCypher](load-api-reference-load.md#load-api-reference-load-parameters-opencypher) pour plus d'informations sur la façon dont les nœuds ou IDs les relations dupliqués sont gérés par le processus de chargement en bloc. ### En-têtes de colonnes de propriétés dans les fichiers de chargement de données openCypher Vous pouvez spécifier qu'une colonne contient les valeurs d'une propriété particulière à l'aide d'un en-tête de colonne de propriété sous la forme suivante : ``` propertyname:type ``` Les espaces, les virgules, le retour en chariot et les caractères de nouvelle ligne ne sont pas autorisés dans les en-têtes de colonne. Les noms de propriétés ne peuvent donc pas inclure ces caractères. Voici un exemple d'en-tête de colonne pour une propriété nommée `age` de type `Int` : ``` age:Int ``` La colonne avec `age:Int` comme en-tête de colonne devrait alors contenir un entier ou une valeur vide sur chaque ligne. ## Types de données dans les fichiers de chargement de données Neptune openCypher + **`Bool`** ou **`Boolean`** : champ booléen. Les valeurs autorisées sont `true` et `false`. Toute valeur autre que `true` qui est traitée comme `false`. + **`Byte`** : nombre entier compris entre `-128` et `127`. + **`Short`** : nombre entier compris entre `-32,768` et `32,767`. + **`Int`** : nombre entier compris entre `-2^31` et `2^31 - 1`. + **`Long`** : nombre entier compris entre `-2^63` et `2^63 - 1`. + **`Float`** : nombre à virgule flottante IEEE 754 32 bits. La notation décimale et la notation scientifique sont toutes deux prises en charge. `Infinity`, `-Infinity`, et `NaN` sont tous reconnus, mais pas `INF`. Les valeurs contenant trop de chiffres sont arrondies à la valeur la plus proche (une valeur intermédiaire est arrondie à 0 pour le dernier chiffre restant au niveau du bit). + **`Double`** : nombre à virgule flottante IEEE 754 64 bits. La notation décimale et la notation scientifique sont toutes deux prises en charge. `Infinity`, `-Infinity`, et `NaN` sont tous reconnus, mais pas `INF`. Les valeurs contenant trop de chiffres sont arrondies à la valeur la plus proche (une valeur intermédiaire est arrondie à 0 pour le dernier chiffre restant au niveau du bit). + **`String`** : les guillemets sont facultatifs. Les virgules et les caractères de saut de ligne et de retour à la ligne font automatiquement l'objet d'un échappement s'ils sont inclus dans une chaîne entourée de guillemets doubles (`"`) comme `"Hello, World"`. Vous pouvez inclure des guillemets dans une chaîne qui contient déjà des guillemets en utilisant deux guillemets d'affilée comme `"Hello ""World"""`. + **`DateTime`** : date Java dans l'un des formats ISO 8601 suivants : + `yyyy-MM-dd` + `yyyy-MM-ddTHH:mm` + `yyyy-MM-ddTHH:mm:ss` + `yyyy-MM-ddTHH:mm:ssZ` ### Types de données diffusées automatiquement dans les fichiers de chargement de données Neptune openCypher Les types de données diffusées automatiquement sont fournis pour charger des types de données qui ne sont pas actuellement pris en charge nativement par Neptune. Les données de ces colonnes sont stockées sous forme de chaînes, mot pour mot, sans vérification par rapport au format prévu. Voici les types de données diffusées automatiquement qui sont autorisés : + **`Char`** : champ `Char`. Stocké sous forme de chaîne. + **`Date`**, **`LocalDate`**, et **`LocalDateTime`** : consultez [Instants temporels Neo4j](https://neo4j.com/docs/cypher-manual/current/values-and-types/temporal/#cypher-temporal-instants) pour obtenir une description des types `date`, `localdate` et `localdatetime`. Les valeurs sont chargées telles quelles sous forme de chaînes, sans validation. + **`Duration`** : consultez le [format de durée Neo4j](https://neo4j.com/docs/cypher-manual/current/values-and-types/temporal/#cypher-temporal-durations). Les valeurs sont chargées telles quelles sous forme de chaînes, sans validation. + **Point** : champ de point destiné au stockage de données spatiales. Consultez [Instants spatiaux](https://neo4j.com/docs/cypher-manual/current/values-and-types/spatial/#spatial-values-spatial-instants). Les valeurs sont chargées telles quelles sous forme de chaînes, sans validation. ## Exemple de format de chargement openCypher Le schéma suivant, tiré du TinkerPop Modern Graph, montre un exemple de deux nœuds et d'une relation : ![\[Schéma de deux nœuds et d'une relation entre eux.\]](http://docs.aws.amazon.com/fr_fr/neptune/latest/userguide/images/tinkerpop-2-nodes-and-relationship.png) Voici le graphe au format de chargement Neptune openCypher normal. **Fichier de nœud :** ``` :ID,name:String,age:Int,lang:String,:LABEL v1,"marko",29,,person v2,"lop",,"java",software ``` **Fichier de relation :** ``` :ID,:START_ID,:END_ID,:TYPE,weight:Double e1,v1,v2,created,0.4 ``` Vous pouvez également utiliser les espaces d'ID et l'ID en tant que propriétés, comme suit : **Fichier du premier nœud :** ``` name:ID(person),age:Int,lang:String,:LABEL "marko",29,,person ``` **Fichier du deuxième nœud :** ``` name:ID(software),age:Int,lang:String,:LABEL "lop",,"java",software ``` **Fichier de relation :** ``` :ID,:START_ID(person),:END_ID(software),:TYPE,weight:Double e1,"marko","lop",created,0.4 ``` # Formats de chargement de données RDF Pour charger des données RDF (Resource Description Framework), vous pouvez utiliser l'un des formats standard suivants comme spécifié par W3C (World Wide Web Consortium) : + N-Triples (`ntriples`) de la spécification à l'adresse [https://www.w3.org/TR/n-triples/](https://www.w3.org/TR/n-triples/) + N-Quads (`nquads`) de la spécification à l'adresse [https://www.w3.org/TR/n-quads/](https://www.w3.org/TR/n-quads/) + RDF/XML (`rdfxml`) de la spécification à l'adresse [https://www.w3.org/TR/rdf-syntax-grammar/](https://www.w3.org/TR/rdf-syntax-grammar/) + Turtle (`turtle`) de la spécification à l'adresse [https://www.w3.org/TR/turtle/](https://www.w3.org/TR/turtle/) **Important** Tous les fichiers doivent être encodés au format UTF-8. Pour les données N-Quads et N-triples comprenant des caractères Unicode, les séquences d'échappement `\uxxxxx` sont prises en charge. Toutefois, Neptune ne prend pas en charge la normalisation. Si une valeur nécessitant une normalisation est présente, elle ne correspondra pas byte-to-byte lors de la requête. Pour plus d'informations sur la normalisation, consultez la page [Normalization](https://unicode.org/faq/normalization.html) sur [Unicode.org](https://unicode.org). **Étapes suivantes** Maintenant que vous en savez plus sur les formats de chargement, consultez [Exemple : chargement de données dans une instance de base de données Neptune](bulk-load-data.md). # Exemple : chargement de données dans une instance de base de données Neptune Cet exemple montre comment charger des données dans Amazon Neptune. Sauf indication contraire, vous devez suivre ces étapes à partir d'une instance Amazon Elastic Compute Cloud (Amazon EC2) située dans le même Amazon Virtual Private Cloud (VPC) que l'instance de base de données Neptune. ## Prérequis pour l'exemple de chargement de données Avant de commencer, les prérequis suivants doivent être remplis : + Vous devez disposer d'une instance de base de données Neptune. Pour plus d'informations sur le lancement d'une instance de base de données Neptune, consultez [Création d'un cluster Amazon Neptune](get-started-create-cluster.md). + Vous devez disposer d'un compartiment Amazon Simple Storage Service (Amazon S3) dans lequel stocker les fichiers de données : Vous pouvez utiliser un compartiment existant. Si vous n'avez pas de compartiment S3, consultez [Création d'un compartiment](https://docs.aws.amazon.com/AmazonS3/latest/userguide/CreatingABucket.html) dans le *[Guide de démarrage Amazon S3](https://docs.aws.amazon.com/AmazonS3/latest/userguide/)*. + Vous devez disposer des données de graphe à charger, dans un des formats compatibles avec le chargeur  : Si vous utilisez Gremlin pour interroger votre graphe, Neptune peut charger les données dans comma-separated-values un format `CSV` (), comme décrit dans. [Format de chargement de données Gremlin](bulk-load-tutorial-format-gremlin.md) Si vous utilisez openCypher pour interroger le graphe, Neptune peut également charger les données dans un format `CSV` spécifique à openCypher, comme décrit dans [Format de chargement des données openCypher](bulk-load-tutorial-format-opencypher.md). Si vous utilisez SPARQL, Neptune peut charger les données dans divers formats RDF, comme décrit dans [Formats de chargement de données RDF](bulk-load-tutorial-format-rdf.md). + Vous devez disposer d'un rôle IAM pour l'instance de base de données Neptune, avec une politique IAM qui autorise l'accès aux fichiers de données dans le compartiment S3. La stratégie doit accorder des autorisations de lecture et de type Liste. Pour plus d'informations sur la création d'un rôle ayant accès à Amazon S3 et sur son association à un cluster Neptune, consultez [Prérequis : rôle IAM et accès à Amazon S3](bulk-load-tutorial-IAM.md). **Note** L'API `Load` Neptune nécessite un accès en lecture aux fichiers de données uniquement. La politique IAM n'a pas besoin d'autoriser un accès en écriture ou un accès au compartiment complet. + Vous devez disposer d'un point de terminaison de VPC Amazon S3. Pour plus d’informations, consultez la section [Création d'un point de terminaison de VPC Amazon S3](#bulk-load-prereqs-s3). ### Création d'un point de terminaison de VPC Amazon S3 Le chargeur Neptune a besoin d’un point de terminaison d’un VPC pour Amazon S3. **Pour configurer l'accès à Amazon S3** 1. Connectez-vous à la console Amazon VPC AWS Management Console et ouvrez-la à l'adresse. [https://console.aws.amazon.com/vpc/](https://console.aws.amazon.com/vpc/) 1. Dans le panneau de navigation de gauche, sélectionnez **Points de terminaison**. 1. Choisissez **Créer un point de terminaison**. 1. Pour **Nom du service**, choisissez `com.amazonaws.region.s3`. **Note** Si la région dans ce champ est incorrecte, assurez-vous que la région de la console est correcte. 1. Choisissez le VPC qui contient votre instance de base de données Neptune. 1. Cochez la case en regard des tables de routage associées aux sous-réseaux liés à votre cluster. Si vous n'avez qu'une seule table de routage, vous devez cocher cette case. 1. Choisissez **Créer un point de terminaison**. Pour plus d'informations sur la création du point de terminaison, consultez [Points de terminaison de VPC](https://docs.aws.amazon.com/vpc/latest/userguide/vpc-endpoints.html#create-vpc-endpoint) dans le *Guide de l'utilisateur Amazon VPC*. Pour plus d'informations sur les limites qui s'appliquent aux points de terminaison d'un VPC, consultez [Points de terminaisons de VPC pour Amazon S3](https://docs.aws.amazon.com/vpc/latest/userguide/vpc-endpoints-s3.html). **Pour charger des données dans une instance de base de données Neptune** 1. Copiez les fichiers de données dans un compartiment Amazon S3. Le compartiment S3 doit se trouver dans la même AWS région que le cluster qui charge les données. Vous pouvez utiliser la AWS CLI commande suivante pour copier les fichiers dans le compartiment. **Note** Cette commande n'a pas besoin d'être exécutée à partir de l'instance Amazon EC2. ``` aws s3 cp data-file-name s3://bucket-name/object-key-name ``` **Note** Dans Amazon S3, le **nom de la clé d'objet** est le chemin d'accès complet d'un fichier, y compris le nom du fichier. *Exemple :* Dans la commande `aws s3 cp datafile.txt s3://examplebucket/mydirectory/datafile.txt`, le nom de la clé d'objet est **`mydirectory/datafile.txt`**. Vous pouvez également utiliser le AWS Management Console pour télécharger des fichiers dans le compartiment S3. Ouvrez la console Amazon S3 à [https://console.aws.amazon.com/s3/](https://console.aws.amazon.com/s3/)l'adresse et choisissez un compartiment. Dans le coin supérieur gauche, choisissez **Upload (Charger)** pour charger les fichiers. 1. Dans une fenêtre de ligne de commande, entrez ce qui suit pour exécuter le chargeur Neptune en utilisant les valeurs correctes pour votre point de terminaison, le chemin Amazon S3, le format et l'ARN du rôle IAM. Le paramètre `format` peut avoir l'une des valeurs suivantes : `csv` pour Gremlin, `opencypher` pour openCypher ou `ntriples`, `nquads`, `turtle`, et `rdfxml` pour RDF. Pour plus d'informations sur les autres paramètres, consultez [Commande de chargeur Neptune](load-api-reference-load.md). Consultez la section [Connexion aux points de terminaison Amazon Neptune](feature-overview-endpoints.md) pour découvrir comment trouver le nom d'hôte de votre instance de base de données Neptune. Le paramètre de région doit correspondre à la région du cluster et au compartiment S3. Amazon Neptune est disponible dans les régions suivantes : AWS + USA Est (Virginie du Nord) : `us-east-1` + USA Est (Ohio) : `us-east-2` + USA Ouest (Californie du Nord) : `us-west-1` + USA Ouest (Oregon) : `us-west-2` + Canada (Centre) : `ca-central-1` + Canada-Ouest (Calgary) : `ca-west-1` + Amérique du Sud (São Paulo) : `sa-east-1` + Europe (Stockholm) : `eu-north-1` + Europe (Espagne) : `eu-south-2` + Europe (Irlande) : `eu-west-1` + Europe (Londres) : `eu-west-2` + Europe (Paris) : `eu-west-3` + Europe (Francfort) : `eu-central-1` + Moyen-Orient (Bahreïn) : `me-south-1` + Moyen-Orient (EAU) : `me-central-1` + Israël (Tel Aviv) : `il-central-1` + Afrique (Le Cap) : `af-south-1` + Asie-Pacifique (Hong Kong) : `ap-east-1` + Asie-Pacifique (Tokyo) : `ap-northeast-1` + Asie-Pacifique (Séoul) : `ap-northeast-2` + Asie-Pacifique (Osaka) : `ap-northeast-3` + Asie-Pacifique (Singapour) : `ap-southeast-1` + Asie-Pacifique (Sydney) : `ap-southeast-2` + Asie-Pacifique (Jakarta) : `ap-southeast-3` + Asie-Pacifique (Melbourne) : `ap-southeast-4` + Asie-Pacifique (Malaisie) : `ap-southeast-5` + Asie-Pacifique (Mumbai) : `ap-south-1` + Asie-Pacifique (Hyderabad) : `ap-south-2` + Chine (Beijing) : `cn-north-1` + Chine (Ningxia) : `cn-northwest-1` + AWS GovCloud (US-Ouest) : `us-gov-west-1` + AWS GovCloud (USA Est) : `us-gov-east-1` ``` curl -X POST \ -H 'Content-Type: application/json' \ https://your-neptune-endpoint:port/loader -d ' { "source" : "s3://bucket-name/object-key-name", "format" : "format", "iamRoleArn" : "arn:aws:iam::account-id:role/role-name", "region" : "region", "failOnError" : "FALSE", "parallelism" : "MEDIUM", "updateSingleCardinalityProperties" : "FALSE", "queueRequest" : "TRUE", "dependencies" : ["load_A_id", "load_B_id"] }' ``` Pour plus d'informations sur la création et l'association d'un rôle IAM à un cluster Neptune, consultez [Prérequis : rôle IAM et accès à Amazon S3](bulk-load-tutorial-IAM.md). **Note** Pour de plus amples informations sur les paramètres de demande de chargement, veuillez consulter [Paramètres de demande du chargeur Neptune](load-api-reference-load.md#load-api-reference-load-parameters). En bref : Le paramètre `source` accepte un URI Amazon S3 qui pointe vers un seul fichier ou vers un dossier. Si vous spécifiez un dossier, Neptune y charge chaque fichier de données. Le dossier peut contenir plusieurs fichiers de sommet et plusieurs fichiers d'arc. L'URI peut être à l'un des formats suivants. `s3://bucket_name/object-key-name` `https://s3.amazonaws.com/bucket_name/object-key-name` `https://s3-us-east-1.amazonaws.com/bucket_name/object-key-name` Ce paramètre `format` peut être l'un des suivants : Format CSV Gremlin (`csv`) pour les graphes de propriétés Gremlin Format CSV openCypher (`opencypher`) pour les graphes de propriétés openCypher Format N -Triples (`ntriples`) pour RDF/SPARQL Format N-Quads (`nquads`) pour RDF/SPARQL Format RDF/XML (`rdfxml`) pour RDF/SPARQL Format Turtle (`turtle`) pour RDF/SPARQL Le paramètre facultatif `parallelism` vous permet de limiter le nombre de threads utilisés dans le processus de chargement en bloc. Il peut être défini sur `LOW`, `MEDIUM`, `HIGH` ou `OVERSUBSCRIBE`. Lorsque la valeur `updateSingleCardinalityProperties` est définie sur `"FALSE"`, le chargeur renvoie une erreur si plusieurs valeurs sont fournies dans un fichier source en cours de chargement pour une propriété de sommet d'une arête ou d'une seule cardinalité. Si `queueRequest` est défini sur `"TRUE"`, la demande de chargement est placée dans une file d'attente lorsqu'une tâche de chargement est déjà en cours d'exécution. Avec le paramètre `dependencies`, l'exécution de la demande de chargement dépend de la réussite d'une ou de plusieurs tâches de chargement qui ont déjà été placées dans la file d'attente. 1. Le chargeur Neptune renvoie un `id` de tâche qui vous permet de vérifier le statut ou d'annuler le processus de chargement, par exemple : ``` { "status" : "200 OK", "payload" : { "loadId" : "ef478d76-d9da-4d94-8ff1-08d9d4863aa5" } } ``` 1. Saisissez la commande suivante pour obtenir le statut du chargement avec le paramètre `loadId` de l'**étape 3** : ``` curl -G 'https://your-neptune-endpoint:port/loader/ef478d76-d9da-4d94-8ff1-08d9d4863aa5' ``` Si le statut du chargement signale une erreur, vous pouvez demander un statut plus détaillé et une liste des erreurs. Pour plus d’informations et d’exemples, consultez [API Neptune Loader Get-Status](load-api-reference-status.md). 1. (Facultatif) Annulez la tâche `Load`. Saisissez la commande suivante pour supprimer (`Delete`) la tâche de chargement (loader) avec l'`id` de tâche de l'**étape 3** : ``` curl -X DELETE 'https://your-neptune-endpoint:port/loader/ef478d76-d9da-4d94-8ff1-08d9d4863aa5' ``` La commande `DELETE` renvoie le code HTTP `200 OK` lorsque l'annulation a réussi. Les données des fichiers de la tâche de chargement qui ont fini de se charger ne sont pas annulées. Les données restent dans l'instance de base de données Neptune. # Optimisation d'un chargement en bloc sur Amazon Neptune Utilisez les stratégies suivantes pour réduire au minimum le temps d'un chargement en bloc Neptune : + **Nettoyez vos données :** + Assurez-vous de convertir vos données dans un [format de données compatible](bulk-load-tutorial-format.md) avant de les charger. + Supprimez les doublons ou les erreurs connues. + Réduisez le nombre de prédicats uniques (tels que les propriétés des arêtes et des sommets) autant que possible. + **Optimisez vos fichiers :** + Si vous chargez des fichiers volumineux tels que des fichiers CSV à partir d'un compartiment Amazon S3, le chargeur gère pour vous la simultanéité en les analysant en fragments qu'il peut charger en parallèle. L'utilisation d'un très grand nombre de petits fichiers peut ralentir ce processus. + Si vous chargez plusieurs fichiers à partir d'un préfixe Amazon S3, le chargeur charge automatiquement d'abord les fichiers de sommets, puis les fichiers de périphérie. Toutefois, si vous savez que vous ne chargerez que des fichiers de périphérie, vous `edgeOnlyLoad` pouvez configurer cette option `TRUE` pour ignorer la première passe au cours de laquelle tous les fichiers sont analysés afin de déterminer leur contenu (sommets ou arêtes) afin que tous les fichiers de sommets trouvés soient chargés avant les fichiers de périphérie. Cela peut accélérer considérablement le temps de chargement, en particulier lorsque de nombreux fichiers Edge sont impliqués. Si certains fichiers de sommets sont également présents dans le même préfixe (`source`paramètre) Amazon S3, ils seront chargés mais sans aucune garantie de commande par rapport aux autres fichiers. En outre, si certains `from` ou plusieurs `to` sommets ne sont pas présents dans la base de données, l'insertion du bord peut signaler des erreurs dans le message`FROM_OR_TO_VERTEX_ARE_MISSING`. Il est recommandé de placer les nœuds et les arêtes dans un préfixe Amazon S3 distinct. + **Vérifiez les paramètres du chargeur :** + Si vous n'avez pas besoin d'effectuer d'autres opérations pendant le chargement, utilisez le paramètre [`parallelism``OVERSUBSCRIBE`](load-api-reference-load.md#load-api-reference-load-syntax). Ce paramètre oblige le chargeur en bloc à utiliser toutes les ressources de CPU disponibles lors de son exécution. Il faut généralement 60 % à 70 % de la capacité du processeur pour que l'opération fonctionne aussi I/O rapidement que les contraintes le permettent. **Note** Lorsque `parallelism` est défini sur `OVERSUBSCRIBE` ou `HIGH` (paramètre par défaut), le chargement des données openCypher risque de provoquer une condition de concurrence et un blocage des threads, ce qui entraîne une erreur `LOAD_DATA_DEADLOCK`. Dans ce cas, définissez `parallelism` sur une valeur inférieure et réessayez le chargement. + Si la tâche de chargement inclut plusieurs demandes de chargement, utilisez le paramètre `queueRequest`. Définir `queueRequest` sur `TRUE` permet à Neptune de mettre en file d'attente les demandes afin que vous n'ayez pas à attendre que l'une soit terminée avant d'en émettre une autre. + Si les demandes de chargement sont mises en file d'attente, vous pouvez définir des niveaux de dépendance à l'aide du paramètre `dependencies`, de sorte que l'échec d'une tâche entraîne l'échec des tâches dépendantes. Cette approche permet d'éviter toute incohérence des données chargées. + Si une tâche de chargement implique la mise à jour de valeurs précédemment chargées, veillez à définir le paramètre `updateSingleCardinalityProperties` sur `TRUE`. Dans le cas contraire, le chargeur traitera une tentative de mise à jour d'une valeur de cardinalité unique existante comme une erreur. Pour les données Gremlin, la cardinalité est également spécifiée dans les en-têtes des colonnes de propriétés (voir [En-têtes de colonne de propriété](bulk-load-tutorial-format-gremlin.md#bulk-load-tutorial-format-gremlin-propheaders)). **Note** Le paramètre `updateSingleCardinalityProperties` n’est pas disponible pour les données RDF (Resource Description Framework). + Vous pouvez utiliser le paramètre `failOnError` pour déterminer si les opérations de chargement en bloc doivent échouer ou se poursuivre en cas d'erreur. Vous pouvez également utiliser le paramètre `mode` pour vous assurer qu'une tâche de chargement reprendra le chargement à partir du point où une tâche précédente a échoué plutôt que de traiter à nouveau des données déjà chargées. + **Augmentation de la capacité** : configurez la taille maximale de l'instance d'enregistreur de votre cluster de bases de données avant le chargement en bloc. Notez que si vous procédez de la sorte, vous devez également augmenter la capacité de toutes les instances de réplica en lecture dans le cluster de bases de données ou les supprimer jusqu'à ce que vous ayez fini de charger les données. Lorsque le chargement en bloc est terminé, veillez à réduire à nouveau la taille de l'instance d'enregistreur. **Important** Si vous êtes confronté à un cycle de redémarrages répétés des réplicas en lecture en raison d'un retard de réplication lors d'un chargement en bloc, les réplicas ne parviendront probablement pas à suivre le rythme de l'enregistreur du cluster de bases de données. Vous pouvez soit mettre à l'échelle les lecteurs pour qu'ils soient plus grands que l'enregistreur, soit les supprimer temporairement pendant le chargement en bloc, puis les recréer une fois le chargement terminé. Consultez [Paramètres de demande](load-api-reference-load.md#load-api-reference-load-parameters) pour plus d'informations sur la définition des paramètres de demande du chargeur. # Référence du chargeur Neptune Cette section décrit les informations disponibles `Loader` APIs pour Amazon Neptune depuis le point de terminaison HTTP d'une instance de base de données Neptune. **Note** Consultez [Message d'erreur et de flux liés au chargeur Neptune](loader-message.md) pour obtenir la liste des messages d'erreur et de flux renvoyés par le chargeur en cas d'erreur. **Contents** + [Commande de chargeur Neptune](load-api-reference-load.md) + [Syntaxe des demandes du chargeur Neptune](load-api-reference-load.md#load-api-reference-load-syntax) + [Paramètres de demande du chargeur Neptune](load-api-reference-load.md#load-api-reference-load-parameters) + [Considérations spéciales relatives au chargement de données openCypher](load-api-reference-load.md#load-api-reference-load-parameters-opencypher) + [Syntaxe de la réponse du chargeur Neptune](load-api-reference-load.md#load-api-reference-load-return) + [Erreurs du chargeur Neptune](load-api-reference-load-errors.md) + [Exemples de chargeur Neptune](load-api-reference-load-examples.md) + [API Neptune Loader Get-Status](load-api-reference-status.md) + [Demandes de Neptune Loader Get-Status](load-api-reference-status-requests.md) + [Syntaxe de Get-Status demande du chargeur](load-api-reference-status-requests.md#load-api-reference-status-request-syntax) + [Paramètres de demande du Neptune Loader Get-Status](load-api-reference-status-requests.md#load-api-reference-status-parameters) + [Réponses du Neptune Loader Get-Status](load-api-reference-status-response.md) + [Disposition JSON du Neptune Loader Get-Status Response](load-api-reference-status-response.md#load-api-reference-status-response-layout) + [Neptune Loader Get-Status `overallStatus` et `failedFeeds` objets de réponse](load-api-reference-status-response.md#load-api-reference-status-response-objects) + [Objet de réponse Neptune Loader Get-Status `errors`](load-api-reference-status-response.md#load-api-reference-status-errors) + [Objet de réponse Neptune Loader Get-Status `errorLogs`](load-api-reference-status-response.md#load-api-reference-error-logs) + [Exemples de chargeurs Neptune Get-Status](load-api-reference-status-examples.md) + [Exemple de demande de statut de chargement](load-api-reference-status-examples.md#load-api-reference-status-examples-status-request) + [Exemple de demande d'ID de chargement](load-api-reference-status-examples.md#load-api-reference-status-examples-loadId-request) + [Exemple de demande de statut de détaillé](load-api-reference-status-examples.md#load-api-reference-status-examples-details-request) + [Exemples de Neptune Loader Get-Status `errorLogs`](load-api-reference-error-logs-examples.md) + [Exemple de réponse de statut détaillée en cas d'erreur](load-api-reference-error-logs-examples.md#load-api-reference-status-examples-details-request-errors) + [Exemple d'erreur `Data prefetch task interrupted`](load-api-reference-error-logs-examples.md#load-api-reference-status-examples-task-interrupted) + [Tâche d'annulation du chargeur Neptune](load-api-reference-cancel.md) + [Syntaxe de la demande d'annulation de tâche](load-api-reference-cancel.md#load-api-reference-cancel-syntax) + [Paramètres de demande d'annulation de tâche](load-api-reference-cancel.md#load-api-reference-cancel-parameters) + [Syntaxe de la réponse d'annulation de tâche](load-api-reference-cancel.md#load-api-reference-cancel-parameters-response) + [Erreurs d'annulation de tâche](load-api-reference-cancel.md#load-api-reference-cancel-parameters-errors) + [Messages d'erreur d'annulation de tâche](load-api-reference-cancel.md#load-api-reference-cancel-parameters-errors-messages) + [Exemples d'annulation de tâche](load-api-reference-cancel.md#load-api-reference-cancel-examples) # Commande de chargeur Neptune Charge les données d'un compartiment Amazon S3 dans une instance de base de données Neptune. Pour charger des données, vous devez envoyer une demande `POST` HTTP au point de terminaison `https://your-neptune-endpoint:port/loader`. Les paramètres de la demande `loader` peuvent être envoyés dans le corps `POST` ou en tant que paramètres encodés en URL. **Important** Le type MIME doit être `application/json`. Le compartiment Amazon S3 doit se trouver dans la même AWS région que le cluster. **Note** Vous pouvez charger des données chiffrées à partir d'Amazon S3 si elles ont été chiffrées avec le mode `SSE-S3` d'Amazon S3. Dans ce cas, Neptune peut emprunter vos informations d'identification et émettre des appels `s3:getObject` en votre nom. Vous pouvez également charger les données chiffrées à l'aide du mode `SSE-KMS` à partir d'Amazon S3, à condition que votre rôle IAM implique les autorisations nécessaires pour accéder à AWS KMS. Sans AWS KMS autorisations appropriées, l'opération de chargement en bloc échoue et renvoie une `LOAD_FAILED` réponse. Neptune ne permet actuellement pas le chargement des données chiffrées Amazon S3 avec le mode `SSE-C`. Il n'est pas nécessaire d'attendre la fin d'une tâche de chargement avant d'en commencer une autre. Neptune peut mettre en file d'attente jusqu'à 64 demandes de tâche à la fois, si leurs paramètres `queueRequest` sont définis sur `"TRUE"`. L'ordre de file d'attente des tâches sera first-in-first-out (FIFO). En revanche, si vous ne voulez pas qu'une tâche de chargement soit mise en file d'attente, vous pouvez définir son paramètre `queueRequest` sur `"FALSE"` (valeur par défaut), de sorte que la tâche de chargement échoue si une autre est déjà en cours. Vous pouvez utiliser le paramètre `dependencies` pour mettre en file d'attente une tâche qui doit être exécutée uniquement une fois que les tâches précédentes spécifiées dans la file d'attente se sont achevées correctement. Si vous faites cela et que l'une des tâches spécifiées échoue, votre tâche ne sera pas exécutée et son statut sera défini sur `LOAD_FAILED_BECAUSE_DEPENDENCY_NOT_SATISFIED`. ## Syntaxe des demandes du chargeur Neptune ``` { "source" : "string", "format" : "string", "iamRoleArn" : "string", "mode": "NEW|RESUME|AUTO", "region" : "us-east-1", "failOnError" : "string", "parallelism" : "string", "parserConfiguration" : { "baseUri" : "http://base-uri-string", "namedGraphUri" : "http://named-graph-string" }, "updateSingleCardinalityProperties" : "string", "queueRequest" : "TRUE", "dependencies" : ["load_A_id", "load_B_id"] } ``` **edgeOnlyLoad Syntaxe** Pour an`edgeOnlyLoad`, la syntaxe serait la suivante : ``` { "source" : "string", "format" : "string", "iamRoleArn" : "string", "mode": "NEW|RESUME|AUTO", "region" : "us-east-1", "failOnError" : "string", "parallelism" : "string", "edgeOnlyLoad" : "string", "parserConfiguration" : { "baseUri" : "http://base-uri-string", "namedGraphUri" : "http://named-graph-string" }, "updateSingleCardinalityProperties" : "string", "queueRequest" : "TRUE", "dependencies" : ["load_A_id", "load_B_id"] } ``` ## Paramètres de demande du chargeur Neptune + **`source`** : URI Amazon S3. Le paramètre `SOURCE` accepte un URI Amazon S3 qui identifie un seul fichier, plusieurs fichiers, un dossier ou plusieurs dossiers. Neptune charge tous les fichiers de données dans n'importe quel dossier spécifié. L'URI peut être à l'un des formats suivants. + `s3://bucket_name/object-key-name` + `https://s3.amazonaws.com/bucket_name/object-key-name` + `https://s3.us-east-1.amazonaws.com/bucket_name/object-key-name` L'`object-key-name`élément de l'URI est équivalent au paramètre de [préfixe](https://docs.aws.amazon.com/AmazonS3/latest/API/API_ListObjects.html#API_ListObjects_RequestParameters) dans un appel d'[ListObjects](https://docs.aws.amazon.com/AmazonS3/latest/API/API_ListObjects.html)API Amazon S3. Il identifie tous les objets du compartiment Amazon S3 spécifié dont le nom commence par ce préfixe. Il peut s'agir d'un seul fichier ou dossier, ou de plusieurs and/or dossiers de fichiers. Le dossier spécifié peut contenir plusieurs fichiers de sommet et plusieurs fichiers d'arête. Par exemple, si vous aviez la structure de dossiers et les fichiers suivants dans un compartiment Amazon S3 nommé `bucket-name` : ``` s3://bucket-name/a/bc s3://bucket-name/ab/c s3://bucket-name/ade s3://bucket-name/bcd ``` Si le paramètre source est spécifié comme`s3://bucket-name/a`, les trois premiers fichiers seront chargés. ``` s3://bucket-name/a/bc s3://bucket-name/ab/c s3://bucket-name/ade ``` + **`format`** : format des données. Pour plus d'informations sur les formats de données pour la commande `Loader` Neptune, consultez [Utilisation du chargeur en vrac Amazon Neptune pour ingérer des données](bulk-load.md). **Valeurs autorisées** + **`csv`** pour le [format de données CSV Gremlin](bulk-load-tutorial-format-gremlin.md). + **`opencypher`** pour le [format de données CSV openCypher](bulk-load-tutorial-format-opencypher.md). + **`ntriples`** pour le [format de données N-Triples RDF](https://www.w3.org/TR/n-triples/). + **`nquads`** pour le [format de données N-Quads RDF](https://www.w3.org/TR/n-quads/). + **`rdfxml`** pour le [format de données RDF RDF/XML](https://www.w3.org/TR/rdf-syntax-grammar/). + **`turtle`** pour le [format de données RDF Turtle](https://www.w3.org/TR/turtle/). + **`iamRoleArn`** : Amazon Resource Name (ARN) d'un rôle IAM qui doit être endossé par l'instance de base de données Neptune pour accéder au compartiment S3. Pour plus d'informations sur la création d'un rôle ayant accès à Amazon S3 et sur son association à un cluster Neptune, consultez [Prérequis : rôle IAM et accès à Amazon S3](bulk-load-tutorial-IAM.md). À partir de la [version 1.2.1.0.R3 du moteur](engine-releases-1.2.1.0.R3.md), vous pouvez également enchaîner plusieurs rôles IAM si l'instance de base de données Neptune et le compartiment Amazon S3 se trouvent dans des comptes différents. AWS Dans ce cas, `iamRoleArn` contient une liste de rôles séparés par des virgules ARNs, comme décrit dans. [Chaînage des rôles IAM dans Amazon Neptune](bulk-load-tutorial-chain-roles.md) Par exemple : ``` curl -X POST https://localhost:8182/loader \ -H 'Content-Type: application/json' \ -d '{ "source" : "s3://(the target bucket name)/(the target date file name)", "iamRoleArn" : "arn:aws:iam::(Account A ID):role/(RoleA),arn:aws:iam::(Account B ID):role/(RoleB),arn:aws:iam::(Account C ID):role/(RoleC)", "format" : "csv", "region" : "us-east-1" }' ``` + **`region`**— Le `region` paramètre doit correspondre à la AWS région du cluster et au compartiment S3. Amazon Neptune est disponible dans les régions suivantes : + USA Est (Virginie du Nord) : `us-east-1` + USA Est (Ohio) : `us-east-2` + USA Ouest (Californie du Nord) : `us-west-1` + USA Ouest (Oregon) : `us-west-2` + Canada (Centre) : `ca-central-1` + Canada-Ouest (Calgary) : `ca-west-1` + Amérique du Sud (São Paulo) : `sa-east-1` + Europe (Stockholm) : `eu-north-1` + Europe (Espagne) : `eu-south-2` + Europe (Irlande) : `eu-west-1` + Europe (Londres) : `eu-west-2` + Europe (Paris) : `eu-west-3` + Europe (Francfort) : `eu-central-1` + Moyen-Orient (Bahreïn) : `me-south-1` + Moyen-Orient (EAU) : `me-central-1` + Israël (Tel Aviv) : `il-central-1` + Afrique (Le Cap) : `af-south-1` + Asie-Pacifique (Hong Kong) : `ap-east-1` + Asie-Pacifique (Tokyo) : `ap-northeast-1` + Asie-Pacifique (Séoul) : `ap-northeast-2` + Asie-Pacifique (Osaka) : `ap-northeast-3` + Asie-Pacifique (Singapour) : `ap-southeast-1` + Asie-Pacifique (Sydney) : `ap-southeast-2` + Asie-Pacifique (Jakarta) : `ap-southeast-3` + Asie-Pacifique (Melbourne) : `ap-southeast-4` + Asie-Pacifique (Malaisie) : `ap-southeast-5` + Asie-Pacifique (Mumbai) : `ap-south-1` + Asie-Pacifique (Hyderabad) : `ap-south-2` + Chine (Beijing) : `cn-north-1` + Chine (Ningxia) : `cn-northwest-1` + AWS GovCloud (US-Ouest) : `us-gov-west-1` + AWS GovCloud (USA Est) : `us-gov-east-1` + **`mode`** : mode de la tâche de chargement. *Valeurs autorisées* : `RESUME`, `NEW`, `AUTO` *Valeur par défaut* : `AUTO` **** + `RESUME` : en mode REPRISE, le chargeur recherche un chargement précédent à partir de cette source et, s'il en trouve un, reprend cette tâche de chargement. Si aucune tâche de chargement précédente n'est trouvée, le chargeur s'arrête. Le chargeur évite de recharger les fichiers qui ont été chargés avec succès lors d'une tâche précédente. Il essaie uniquement de traiter les fichiers ayant échoué. Si vous aviez supprimé des données précédemment chargées à partir de votre cluster Neptune, ces données ne sont pas rechargées dans ce mode. Si une tâche de chargement précédente a chargé tous les fichiers de la même source avec succès, rien n'est rechargé, et le chargeur renvoie une réussite. + `NEW` : le mode NOUVEAU crée une autre demande de chargement sans tenir compte des chargements précédents. Vous pouvez utiliser ce mode pour recharger toutes les données d'une source après la suppression de données précédemment chargées à partir de votre cluster Neptune ou pour charger de nouvelles données disponibles sur la même source. + `AUTO` : en mode AUTO, le chargeur recherche une tâche de chargement précédente à partir de la même source, et s'il en trouve une, reprend cette tâche, exactement comme en mode `RESUME`. Si le chargeur ne trouve pas de tâche de chargement précédente à partir de la même source, il charge toutes les données de la source, exactement comme en mode `NEW`. + **`edgeOnlyLoad`**— Un drapeau qui contrôle l'ordre de traitement des fichiers lors du chargement en masse. *Valeurs autorisées* : `"TRUE"`, `"FALSE"`. *Valeur par défaut* : `"FALSE"`. Lorsque ce paramètre est défini sur « FALSE », le chargeur charge automatiquement les fichiers de sommets en premier, puis les fichiers de bords. Pour ce faire, il analyse d'abord tous les fichiers pour déterminer leur contenu (sommets ou arêtes). Lorsque ce paramètre est défini sur « TRUE », le chargeur ignore la phase de numérisation initiale et charge immédiatement tous les fichiers dans l'ordre dans lequel ils apparaissent. Pour plus d'informations, voir [Optimisation du chargement en vrac](https://docs.aws.amazon.com//neptune/latest/userguide/bulk-load-optimize.html). + **`failOnError`** : indicateur permettant d'activer un arrêt complet au niveau d'une erreur. *Valeurs autorisées* : `"TRUE"`, `"FALSE"`. *Valeur par défaut* : `"TRUE"`. Lorsque ce paramètre est défini sur `"FALSE"`, le chargeur essaie de charger toutes les données à l'emplacement spécifié, en ignorant les entrées contenant des erreurs. Lorsque ce paramètre est défini sur `"TRUE"`, le chargeur s'arrête dès qu'il rencontre une erreur. Les données chargées jusqu'à ce point persistent. + **`parallelism`** : paramètre facultatif qui peut être défini de façon à réduire le nombre de threads utilisés par le processus de chargement en bloc. *Valeurs autorisées* : + `LOW`— Le nombre de threads utilisés est le nombre de v disponibles CPUs divisé par 8. + `MEDIUM`— Le nombre de threads utilisés est le nombre de v disponibles CPUs divisé par 2. + `HIGH`— Le nombre de threads utilisés est identique au nombre de v disponiblesCPUs. + `OVERSUBSCRIBE`— Le nombre de threads utilisés est le nombre de v disponibles CPUs multiplié par 2. Si cette valeur est utilisée, le chargeur en bloc accepte toutes les ressources disponibles. Cela ne signifie toutefois pas que le paramètre `OVERSUBSCRIBE` entraîne une utilisation du CPU à 100 %. L'opération de chargement étant limitée, I/O l'utilisation maximale du processeur à laquelle on peut s'attendre se situe entre 60 % et 70 %. *Valeur par défaut* : `HIGH` Le paramètre `parallelism` peut parfois entraîner un blocage entre les threads lors du chargement des données openCypher. Lorsque cela se produit, Neptune renvoie le message d'erreur `LOAD_DATA_DEADLOCK`. Vous pouvez généralement résoudre le problème en définissant un paramètre `parallelism` inférieur et en soumettant la commande de chargement à une nouvelle tentative. + **`parserConfiguration`** : objet facultatif avec des valeurs de configuration d'analyseur supplémentaires. Chacun des paramètres enfants est également facultatif : [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/neptune/latest/userguide/load-api-reference-load.html) Pour de plus amples informations, veuillez consulter [Graphe par défaut SPARQL et graphes nommés](feature-sparql-compliance.md#sparql-default-graph). + **`updateSingleCardinalityProperties`** : paramètre facultatif qui contrôle la façon dont le chargeur en bloc traite une nouvelle valeur pour les propriétés de sommet ou d'arête à cardinalité unique. Il n'est pas pris en charge pour le chargement de données openCypher (voir [Chargement de données openCypher](#load-api-reference-load-parameters-opencypher)). *Valeurs autorisées* : `"TRUE"`, `"FALSE"`. *Valeur par défaut* : `"FALSE"`. Par défaut, ou lorsque `updateSingleCardinalityProperties` est explicitement défini sur `"FALSE"`, le chargeur traite une nouvelle valeur comme une erreur, car elle ne respecte pas la cardinalité unique. En revanche, lorsque `updateSingleCardinalityProperties` est défini sur `"TRUE"`, le chargeur en bloc remplace la valeur existante par la nouvelle. Si plusieurs valeurs de propriété de sommet à cardinalité unique ou d'arête sont fournies dans le ou les fichiers source en cours de chargement, la valeur finale à l'issue du chargement en bloc peut être une de ces nouvelles valeurs. Le chargeur garantit uniquement que la valeur existante a été remplacée par une des nouvelles. + **`queueRequest`** : paramètre d'indicateur facultatif qui indique si la demande de chargement peut être mise en file d'attente ou non. Vous n'avez pas besoin d'attendre qu'une tâche de chargement soit terminée avant d'émettre la suivante, car Neptune peut mettre en file d'attente jusqu'à 64 tâches à la fois, si leurs paramètres `queueRequest` sont tous définis sur `"TRUE"`. L'ordre de file d'attente des tâches sera first-in-first-out (FIFO). Si le paramètre `queueRequest` est omis ou défini sur `"FALSE"`, la demande de chargement échouera si une autre tâche de chargement est déjà en cours d'exécution. *Valeurs autorisées* : `"TRUE"`, `"FALSE"`. *Valeur par défaut* : `"FALSE"`. + **`dependencies`** : paramètre facultatif qui peut subordonner une demande de chargement en file d'attente à la réussite d'une ou de plusieurs tâches précédentes dans la file d'attente. Neptune peut mettre en file d'attente jusqu'à 64 requêtes de chargement à la fois, si leurs paramètres `queueRequest` sont définis sur `"TRUE"`. Le paramètre `dependencies` vous permet de rendre l'exécution d'une telle requête en file d'attente dépendante de la réussite d'une ou de plusieurs requêtes précédentes spécifiées dans la file d'attente. Par exemple, si les charges `Job-A` et `Job-B` sont indépendantes l'une de l'autre, mais que la charge `Job-C` a besoin que `Job-A` et `Job-B` soient terminées avant de commencer, procédez comme suit : 1. Soumettez `load-job-A` et `load-job-B` l'une après l'autre dans n'importe quel ordre, et enregistrez leurs ID de chargement. 1. Soumettez `load-job-C` avec les ID de chargement des deux tâches dans son domaine `dependencies` : ``` "dependencies" : ["job_A_load_id", "job_B_load_id"] ``` En raison du paramètre `dependencies`, le chargeur en bloc ne démarrera pas `Job-C` avant que `Job-A` et `Job-B` soient terminées avec succès. Si l'une des d'eux échoue, Job-C ne sera pas exécuté et son statut sera défini sur `LOAD_FAILED_BECAUSE_DEPENDENCY_NOT_SATISFIED`. Vous pouvez configurer plusieurs niveaux de dépendance de cette façon, de sorte que l'échec d'une tâche entraîne l'annulation de toutes les demandes qui en dépendent directement ou indirectement. + **`userProvidedEdgeIds`**— Ce paramètre est obligatoire uniquement lors du chargement de données OpenCypher contenant une relation. IDs Il doit être inclus et défini `True` lorsque les relations OpenCypher IDs sont explicitement fournies dans les données de chargement (recommandé). Quand `userProvidedEdgeIds` est absent ou défini sur `True`, une colonne `:ID` doit être présente dans chaque fichier de relations inclus dans le chargement. Quand `userProvidedEdgeIds` est présent et défini sur `False`, les fichiers de relations inclus dans le chargement **ne doivent pas** contenir de colonne `:ID`. Au lieu de cela, le chargeur Neptune génère automatiquement un ID pour chaque relation. Il est utile de fournir une relation de IDs manière explicite afin que le chargeur puisse reprendre le chargement après correction d'une erreur dans les données CSV, sans avoir à recharger les relations déjà chargées. Si aucune relation IDs n'a été explicitement attribuée, le chargeur ne peut pas reprendre un chargement défaillant si un fichier de relations a dû être corrigé, et doit à la place recharger toutes les relations. + `accessKey` : **[obsolète]** ID de clé d'accès d'un rôle IAM avec un accès au compartiment S3 et aux fichiers de données. Le paramètre `iamRoleArn` est recommandé à la place. Pour plus d'informations sur la création d'un rôle ayant accès à Amazon S3 et sur son association à un cluster Neptune, consultez [Prérequis : rôle IAM et accès à Amazon S3](bulk-load-tutorial-IAM.md). Pour plus d'informations, consultez [Clés d'accès (ID de clé d'accès et clé d'accès secrète)](https://docs.aws.amazon.com/general/latest/gr/aws-sec-cred-types.html#access-keys-and-secret-access-keys). + `secretKey` : **[obsolète]** le paramètre `iamRoleArn` est recommandé à la place. Pour plus d'informations sur la création d'un rôle ayant accès à Amazon S3 et sur son association à un cluster Neptune, consultez [Prérequis : rôle IAM et accès à Amazon S3](bulk-load-tutorial-IAM.md). Pour plus d'informations, consultez [Clés d'accès (ID de clé d'accès et clé d'accès secrète)](https://docs.aws.amazon.com/general/latest/gr/aws-sec-cred-types.html#access-keys-and-secret-access-keys). ### Considérations spéciales relatives au chargement de données openCypher + Lorsque vous chargez des données openCypher au format CSV, le paramètre de format doit être défini sur `opencypher`. + Le paramètre `updateSingleCardinalityProperties` n'est pas pris en charge pour les chargements openCypher, car toutes les propriétés openCypher ont une cardinalité unique. Le format de chargement openCypher ne prend pas en charge les tableaux, et si une valeur d'ID apparaît plusieurs fois, elle est traitée comme un doublon ou comme une erreur d'insertion (voir ci-dessous). + Le chargeur Neptune gère les doublons qu'il trouve dans les données openCypher de la manière suivante : + Si le chargeur identifie plusieurs lignes avec le même ID de nœud, elles sont fusionnées selon la règle suivante : + Toutes les étiquettes des lignes sont ajoutées au nœud. + Pour chaque propriété, une seule des valeurs de propriété est chargée. Le choix de celle à charger n'est pas déterministe. + Si le chargeur identifie plusieurs lignes avec le même ID de relation, une seule d'entre elles est chargée. Le choix de celle à charger n'est pas déterministe. + Le chargeur ne met jamais à jour les valeurs des propriétés d'un nœud ou d'une relation dans la base de données s'il trouve des données de chargement avec l'ID de ce nœud ou de cette relation. Cependant, il charge les étiquettes et les propriétés des nœuds qui ne se trouvent pas dans le nœud ou la relation existants. + Bien que vous n'ayez pas à assigner IDs aux relations, c'est généralement une bonne idée (voir le `userProvidedEdgeIds` paramètre ci-dessus). En l'absence de relation explicite IDs, le chargeur doit recharger toutes les relations en cas d'erreur dans un fichier de relations, plutôt que de reprendre le chargement là où il a échoué. De plus, si les données de chargement ne contiennent pas de relation explicite IDs, le chargeur n'a aucun moyen de détecter les relations dupliquées. Voici un exemple de commande de chargement openCypher : ``` curl -X POST https://your-neptune-endpoint:port/loader \ -H 'Content-Type: application/json' \ -d ' { "source" : "s3://bucket-name/object-key-name", "format" : "opencypher", "userProvidedEdgeIds": "TRUE", "iamRoleArn" : "arn:aws:iam::account-id:role/role-name", "region" : "region", "failOnError" : "FALSE", "parallelism" : "MEDIUM", }' ``` La réponse du chargeur est la même que d'habitude. Par exemple : ``` { "status" : "200 OK", "payload" : { "loadId" : "guid_as_string" } } ``` ## Syntaxe de la réponse du chargeur Neptune ``` { "status" : "200 OK", "payload" : { "loadId" : "guid_as_string" } } ``` **200 OK** Une tâche de chargement démarrée avec succès renvoie un code `200`. # Erreurs du chargeur Neptune Lorsqu'une erreur se produit, un objet JSON est renvoyé dans le `BODY` (corps) de la réponse. L'objet `message` contient une description de l'erreur. **Catégories d'erreurs** + `Error 400` : les erreurs de syntaxe renvoient une erreur de demande incorrecte `400` HTTP. Le message décrit l'erreur. + `Error 500` : une demande valide qui ne peut pas être traitée renvoie une erreur de serveur interne HTTP `500`. Le message décrit l'erreur. Voici les messages d'erreur possibles du chargeur avec une description de l'erreur. **Messages d'erreur du chargeur** + `Couldn't find the AWS credential for iam_role_arn`  (HTTP 400) Les informations d'identification n'ont pas été trouvées. Vérifiez les informations d'identification fournies par rapport à la console ou à la AWS CLI sortie IAM. Vérifiez que vous avez ajouté au cluster le rôle IAM spécifié dans `iamRoleArn`. + `S3 bucket not found for source`  (HTTP 400) Le compartiment S3 n'existe pas. Vérifiez le nom du compartiment. + `The source source-uri does not exist/not reachable`  (HTTP 400) Aucun fichier correspondant n'a été trouvé dans le compartiment S3. + `Unable to connect to S3 endpoint. Provided source = source-uri and region = aws-region`  (HTTP 500) Impossible de se connecter à Amazon S3. La région doit correspondre à la région du cluster. Assurez-vous de disposer d'un point de terminaison de VPC. Pour plus d'informations sur la création d'un point de terminaison VPC, consultez [Création d'un point de terminaison de VPC Amazon S3](bulk-load-data.md#bulk-load-prereqs-s3). + `Bucket is not in provided Region (aws-region)`  (HTTP 400) Le bucket doit se trouver dans la même AWS région que votre instance de base de données Neptune. + `Unable to perform S3 list operation`  (HTTP 400) L'utilisateur ou le rôle IAM fourni ne dispose pas d'autorisations `List` sur le compartiment ou le dossier. Vérifiez la stratégie ou la liste de contrôle d'accès (ACL) sur le compartiment. + `Start new load operation not permitted on a read replica instance`  (HTTP 405) Le chargement est une opération d'écriture. Réessayez de charger sur le point de terminaison du read/write cluster. + `Failed to start load because of unknown error from S3`  (HTTP 500) Amazon S3 a renvoyé une erreur inconnue. Contactez [AWS Support](https://aws.amazon.com/premiumsupport/). + `Invalid S3 access key`  (HTTP 400) La clé d'accès n'est pas valide. Vérifiez les informations d'identification fournies. + `Invalid S3 secret key`  (HTTP 400) La clé secrète n'est pas valide. Vérifiez les informations d'identification fournies. + `Max concurrent load limit breached`  (HTTP 400) Si une demande de chargement est soumise sans `"queueRequest" : "TRUE"`, et qu'une tâche de chargement est en cours d'exécution, la demande échouera avec cette erreur. + `Failed to start new load for the source "source name". Max load task queue size limit breached. Limit is 64`  (HTTP 400) Neptune prend en charge la mise en file d'attente de jusqu'à 64 tâches de chargeur à la fois. Si une demande de chargement supplémentaire est soumise à la file d'attente alors qu'elle contient déjà 64 tâches, la demande échoue avec ce message. # Exemples de chargeur Neptune Cet exemple montre comment utiliser le chargeur Neptune pour charger des données dans une base de données de graphes Neptune à l'aide du format CSV Gremlin. La demande est envoyée sous forme de requête HTTP POST au point de terminaison du chargeur Neptune, et le corps de la demande contient les paramètres nécessaires pour spécifier la source de données, le format, le rôle IAM et les autres options de configuration. La réponse inclut l'ID de chargement, qui peut être utilisé pour suivre la progression du processus de chargement des données. **Example Demande** Voici une demande envoyée via HTTP POST à l'aide de la commande `curl`. Un fichier au format CSV Neptune est chargé. Pour de plus amples informations, veuillez consulter [Format de chargement de données Gremlin](bulk-load-tutorial-format-gremlin.md). ``` curl -X POST \ -H 'Content-Type: application/json' \ https://your-neptune-endpoint:port/loader -d ' { "source" : "s3://bucket-name/object-key-name", "format" : "csv", "iamRoleArn" : "ARN for the IAM role you are using", "region" : "region", "failOnError" : "FALSE", "parallelism" : "MEDIUM", "updateSingleCardinalityProperties" : "FALSE", "queueRequest" : "FALSE" }' ``` **Example Réponse** ``` { "status" : "200 OK", "payload" : { "loadId" : "ef478d76-d9da-4d94-8ff1-08d9d4863aa5" } } ``` # API Neptune Loader Get-Status Obtient le statut d'une tâche `loader`. Pour obtenir le statut de chargement, vous devez envoyer une demande `GET` HTTP au point de terminaison `https://your-neptune-endpoint:port/loader`. Pour obtenir le statut d'une demande de chargement particulière, vous devez inclure l'`loadId` comme paramètre d'URL ou ajouter l'`loadId` au chemin d'URL. Neptune ne conserve une trace que des 1 024 tâches de chargement en bloc les plus récentes et ne stocke que les 10 000 dernières informations détaillées d'erreur par tâche. Consultez [Message d'erreur et de flux liés au chargeur Neptune](loader-message.md) pour obtenir la liste des messages d'erreur et de flux renvoyés par le chargeur en cas d'erreur. **Contents** + [Demandes de Neptune Loader Get-Status](load-api-reference-status-requests.md) + [Syntaxe de Get-Status demande du chargeur](load-api-reference-status-requests.md#load-api-reference-status-request-syntax) + [Paramètres de demande du Neptune Loader Get-Status](load-api-reference-status-requests.md#load-api-reference-status-parameters) + [Réponses du Neptune Loader Get-Status](load-api-reference-status-response.md) + [Disposition JSON du Neptune Loader Get-Status Response](load-api-reference-status-response.md#load-api-reference-status-response-layout) + [Neptune Loader Get-Status `overallStatus` et `failedFeeds` objets de réponse](load-api-reference-status-response.md#load-api-reference-status-response-objects) + [Objet de réponse Neptune Loader Get-Status `errors`](load-api-reference-status-response.md#load-api-reference-status-errors) + [Objet de réponse Neptune Loader Get-Status `errorLogs`](load-api-reference-status-response.md#load-api-reference-error-logs) + [Exemples de chargeurs Neptune Get-Status](load-api-reference-status-examples.md) + [Exemple de demande de statut de chargement](load-api-reference-status-examples.md#load-api-reference-status-examples-status-request) + [Exemple de demande d'ID de chargement](load-api-reference-status-examples.md#load-api-reference-status-examples-loadId-request) + [Exemple de demande de statut de détaillé](load-api-reference-status-examples.md#load-api-reference-status-examples-details-request) + [Exemples de Neptune Loader Get-Status `errorLogs`](load-api-reference-error-logs-examples.md) + [Exemple de réponse de statut détaillée en cas d'erreur](load-api-reference-error-logs-examples.md#load-api-reference-status-examples-details-request-errors) + [Exemple d'erreur `Data prefetch task interrupted`](load-api-reference-error-logs-examples.md#load-api-reference-status-examples-task-interrupted) # Demandes de Neptune Loader Get-Status ## Syntaxe de Get-Status demande du chargeur ``` GET https://your-neptune-endpoint:port/loader?loadId=loadId ``` ``` GET https://your-neptune-endpoint:port/loader/loadId ``` ``` GET https://your-neptune-endpoint:port/loader ``` ## Paramètres de demande du Neptune Loader Get-Status + **`loadId`** : ID de la tâche de chargement. Si vous ne spécifiez pas a`loadId`, une liste de charges IDs est renvoyée. + **`details`** : inclut des détails autres que le statut global. *Valeurs autorisées* : `TRUE`, `FALSE`. *Valeur par défaut* : `FALSE`. + **`errors`** : inclut la liste d'erreurs. *Valeurs autorisées* : `TRUE`, `FALSE`. *Valeur par défaut* : `FALSE`. La liste d'erreurs est paginée. Les paramètres `page` et `errorsPerPage` vous permettent de parcourir toutes les erreurs. + **`page`** : numéro de page de l'erreur. Valide uniquement si le paramètre `errors` est défini sur `TRUE`. *Valeurs autorisées* : Entiers positifs *Valeur par défaut* : 1. + **`errorsPerPage`** : nombre d'erreurs par page. Valide uniquement si le paramètre `errors` est défini sur `TRUE`. *Valeurs autorisées* : Entiers positifs *Valeur par défaut* : 10. + **`limit`** : nombre d'ID de chargement à répertorier. Valable uniquement lorsque vous demandez une liste de charges IDs en envoyant une `GET` demande sans `loadId` spécification. *Valeurs autorisées* : nombre entier positif compris entre 1 et 100. *Valeur par défaut* : 100. + **`includeQueuedLoads`**— Paramètre facultatif qui peut être utilisé pour exclure le chargement IDs des demandes de chargement en file d'attente lorsqu'une liste de chargements IDs est demandée. Par défaut, le chargement IDs de toutes les tâches de chargement ayant un statut `LOAD_IN_QUEUE` est inclus dans une telle liste. Ils apparaissent avant le chargement IDs des autres tâches, triés selon l'heure à laquelle ils ont été ajoutés à la file d'attente, du plus récent au plus ancien. *Valeurs autorisées* : `TRUE`, `FALSE`. *Valeur par défaut* : `TRUE`. # Réponses du Neptune Loader Get-Status L'exemple de réponse suivant de l' Get-Status API Neptune décrit la structure globale de la réponse, explique les différents champs et leurs types de données, ainsi que le traitement des erreurs et les détails du journal des erreurs. ## Disposition JSON du Neptune Loader Get-Status Response La structure générale d'une réponse de statut du chargeur est la suivante : ``` { "status" : "200 OK", "payload" : { "feedCount" : [ { "LOAD_FAILED" : number } ], "overallStatus" : { "fullUri" : "s3://bucket/key", "runNumber" : number, "retryNumber" : number, "status" : "string", "totalTimeSpent" : number, "startTime" : number, "totalRecords" : number, "totalDuplicates" : number, "parsingErrors" : number, "datatypeMismatchErrors" : number, "insertErrors" : number, }, "failedFeeds" : [ { "fullUri" : "s3://bucket/key", "runNumber" : number, "retryNumber" : number, "status" : "string", "totalTimeSpent" : number, "startTime" : number, "totalRecords" : number, "totalDuplicates" : number, "parsingErrors" : number, "datatypeMismatchErrors" : number, "insertErrors" : number, } ], "errors" : { "startIndex" : number, "endIndex" : number, "loadId" : "string, "errorLogs" : [ ] } } } ``` ## Neptune Loader Get-Status `overallStatus` et `failedFeeds` objets de réponse Les réponses possibles renvoyées pour chaque flux ayant échoué, avec une description de l'erreur, sont les mêmes que pour l'objet `overallStatus` dans une réponse `Get-Status`. Ces champs apparaissent dans l'objet `overallStatus` pour tous les chargements, et le champ `failedFeeds` pour chaque flux ayant échoué. + **`fullUri`** : URI du ou des fichiers à charger. *Type* : *chaîne* *Format* : `s3://bucket/key`. + **`runNumber`** : nombre d'exécutions de ce chargement ou flux. Ce nombre est incrémenté lorsque le chargement est redémarré. *Type :* *long non signé*. + **`retryNumber`** : nombre de nouvelles tentatives de ce chargement ou flux. Ce nombre est incrémenté lorsque le chargeur relance automatiquement un flux ou un chargement. *Type :* *long non signé*. + **`status`** : statut renvoyé du chargement ou du flux. `LOAD_COMPLETED` indique la réussite du chargement, sans problèmes. Pour obtenir la liste des autres messages relatifs au statut du chargement, consultez [Message d'erreur et de flux liés au chargeur Neptune](loader-message.md). *Type* : *chaîne* + **`totalTimeSpent`** : temps, en secondes, consacré à analyser et insérer les données pour le chargement ou le flux. N'inclut pas le temps consacré à l'extraction de la liste de fichiers source. *Type :* *long non signé*. + **`totalRecords`** : nombre total d'enregistrements chargés ou de tentatives de chargement. *Type :* *long non signé*. Notez que lors du chargement à partir d'un fichier CSV, le nombre d'enregistrements ne fait pas référence au nombre de lignes chargées, mais plutôt au nombre d'enregistrements individuels contenus dans ces lignes. Par exemple, prenons un petit fichier CSV comme celui-ci : ``` ~id,~label,name,team 'P-1','Player','Stokes','England' ``` Neptune considérerait que ce fichier contient trois enregistrements, à savoir : ``` P-1 label Player P-1 name Stokes P-1 team England ``` + **`totalDuplicates`** : nombre d'enregistrements en double détectés. *Type :* *long non signé*. Comme dans le cas du décompte `totalRecords`, cette valeur contient le nombre d'enregistrements en double individuels dans un fichier CSV, et non le nombre de lignes dupliquées. Prenons, par exemple, ce petit fichier CSV : ``` ~id,~label,name,team P-2,Player,Kohli,India P-2,Player,Kohli,India ``` Le statut renvoyé après le chargement ressemblerait à ceci, indiquant six enregistrements au total, dont trois sont des doublons : ``` { "status": "200 OK", "payload": { "feedCount": [ { "LOAD_COMPLETED": 1 } ], "overallStatus": { "fullUri": "(the URI of the CSV file)", "runNumber": 1, "retryNumber": 0, "status": "LOAD_COMPLETED", "totalTimeSpent": 3, "startTime": 1662131463, "totalRecords": 6, "totalDuplicates": 3, "parsingErrors": 0, "datatypeMismatchErrors": 0, "insertErrors": 0 } } } ``` Pour les chargements openCypher, un doublon est compté dans les situations suivantes : + Le chargeur détecte qu'une ligne d'un fichier de nœud possède un ID sans espace d'ID identique à une autre valeur d'ID sans espace d'ID, que ce soit sur une autre ligne ou appartenant à un nœud existant. + Le chargeur détecte qu'une ligne d'un fichier de nœud possède un ID avec un espace d'ID identique à une autre valeur d'ID avec un espace d'ID, que ce soit sur une autre ligne ou appartenant à un nœud existant. Consultez [Considérations spéciales relatives au chargement de données openCypher](load-api-reference-load.md#load-api-reference-load-parameters-opencypher). + **`parsingErrors`** : nombre d'erreurs d'analyse détectées. *Type :* *long non signé*. + **`datatypeMismatchErrors`** : nombre d'enregistrements avec un type de données qui ne correspond pas aux données fournies. *Type :* *long non signé*. + **`insertErrors`** : nombre d'enregistrements qui n'ont pas pu être insérés en raison d'erreurs. *Type :* *long non signé*. ## Objet de réponse Neptune Loader Get-Status `errors` Les erreurs sont réparties dans les catégories suivantes : + **`Error 400`** : une erreur non valide `loadId` renvoie une erreur de requête HTTP `400` incorrecte. Le message décrit l'erreur. + **`Error 500`** : une demande valide qui ne peut pas être traitée renvoie une erreur de serveur interne HTTP `500`. Le message décrit l'erreur. Consultez [Message d'erreur et de flux liés au chargeur Neptune](loader-message.md) pour obtenir la liste des messages d'erreur et de flux renvoyés par le chargeur en cas d'erreur. Lorsqu'une erreur se produit, un objet JSON `errors` est renvoyé dans le corps (`BODY`) de la réponse. + **`startIndex`** : index de la première erreur incluse. *Type :* *long non signé*. + **`endIndex`** : index de la dernière erreur incluse. *Type :* *long non signé*. + **`loadId`** : ID du chargement. Vous pouvez utiliser cet ID pour afficher les erreurs du chargement en définissant le paramètre `errors` sur `TRUE`. *Type* : *chaîne* + **`errorLogs`** : liste des erreurs. *Type :* *liste*. ## Objet de réponse Neptune Loader Get-Status `errorLogs` L'objet `errorLogs` sous `errors` dans la réponse Get-Status du chargeur contient un objet décrivant chaque erreur à l'aide des champs suivants : + **`errorCode`** : identifie la nature de l'erreur. Il peut avoir l'une des valeurs suivantes : + `PARSING_ERROR` + `S3_ACCESS_DENIED_ERROR` + `FROM_OR_TO_VERTEX_ARE_MISSING` + `ID_ASSIGNED_TO_MULTIPLE_EDGES` + `SINGLE_CARDINALITY_VIOLATION` + `FILE_MODIFICATION_OR_DELETION_ERROR` + `OUT_OF_MEMORY_ERROR` + `INTERNAL_ERROR` (renvoyé lorsque le chargeur en bloc ne parvient pas à déterminer le type d'erreur). + **`errorMessage`** : message décrivant l'erreur. Il peut s'agir d'un message générique associé au code d'erreur ou d'un message spécifique contenant des détails, par exemple sur un from/to sommet manquant ou sur une erreur d'analyse. + **`fileName`** : nom du flux. + **`recordNum`** : dans le cas d'une erreur d'analyse, il s'agit du numéro dans le fichier de l'enregistrement qui n'a pas pu être analysé. Il correspond à zéro si le numéro d'enregistrement n'est pas applicable à l'erreur ou s'il n'a pas pu être déterminé. Par exemple, le chargeur en bloc générerait une erreur d'analyse s'il détectait une ligne défectueuse telle que la suivante dans un fichier RDF `nquads` : ``` |http://base#predicate> . ``` Comme vous pouvez le constater, le deuxième `http` de la ligne ci-dessus devrait être précédé de `<` au lieu de `|`. L'objet d'erreur généré sous `errorLogs` dans une réponse de statut ressemble à ceci : ``` { "errorCode" : "PARSING_ERROR", "errorMessage" : "Expected '<', found: |", "fileName" : "s3://bucket/key", "recordNum" : 12345 }, ``` # Exemples de chargeurs Neptune Get-Status Les exemples suivants illustrent l'utilisation de l'API Get-Status du chargeur Neptune, qui vous permet de récupérer des informations sur l'état de vos chargements de données dans la base de données de graphes Amazon Neptune. Ces exemples couvrent trois scénarios principaux : récupérer l'état d'une charge spécifique, répertorier la charge IDs disponible et demander des informations détaillées sur l'état d'une charge spécifique. ## Exemple de demande de statut de chargement Voici une demande envoyée via HTTP `GET` à l'aide de la commande `curl`. ``` curl -X GET 'https://your-neptune-endpoint:port/loader/loadId (a UUID)' ``` **Example Réponse** ``` { "status" : "200 OK", "payload" : { "feedCount" : [ { "LOAD_FAILED" : 1 } ], "overallStatus" : { "datatypeMismatchErrors" : 0, "fullUri" : "s3://bucket/key", "insertErrors" : 0, "parsingErrors" : 5, "retryNumber" : 0, "runNumber" : 1, "status" : "LOAD_FAILED", "totalDuplicates" : 0, "totalRecords" : 5, "totalTimeSpent" : 3.0 } } } ``` ## Exemple de demande d'ID de chargement Voici une demande envoyée via HTTP `GET` à l'aide de la commande `curl`. ``` curl -X GET 'https://your-neptune-endpoint:port/loader?limit=3' ``` **Example Réponse** ``` { "status" : "200 OK", "payload" : { "loadIds" : [ "a2c0ce44-a44b-4517-8cd4-1dc144a8e5b5", "09683a01-6f37-4774-bb1b-5620d87f1931", "58085eb8-ceb4-4029-a3dc-3840969826b9" ] } } ``` ## Exemple de demande de statut de détaillé Voici une demande envoyée via HTTP `GET` à l'aide de la commande `curl`. ``` curl -X GET 'https://your-neptune-endpoint:port/loader/loadId (a UUID)?details=true' ``` **Example Réponse** ``` { "status" : "200 OK", "payload" : { "failedFeeds" : [ { "datatypeMismatchErrors" : 0, "fullUri" : "s3://bucket/key", "insertErrors" : 0, "parsingErrors" : 5, "retryNumber" : 0, "runNumber" : 1, "status" : "LOAD_FAILED", "totalDuplicates" : 0, "totalRecords" : 5, "totalTimeSpent" : 3.0 } ], "feedCount" : [ { "LOAD_FAILED" : 1 } ], "overallStatus" : { "datatypeMismatchErrors" : 0, "fullUri" : "s3://bucket/key", "insertErrors" : 0, "parsingErrors" : 5, "retryNumber" : 0, "runNumber" : 1, "status" : "LOAD_FAILED", "totalDuplicates" : 0, "totalRecords" : 5, "totalTimeSpent" : 3.0 } } } ``` # Exemples de Neptune Loader Get-Status `errorLogs` Les exemples suivants présentent la réponse d'état détaillée du chargeur Neptune lorsque des erreurs se sont produites pendant le processus de chargement des données. Les exemples illustrent la structure de la réponse, notamment les informations sur les flux défaillants, l'état général et les journaux d'erreurs détaillés. ## Exemple de réponse de statut détaillée en cas d'erreur Il s'agit d'une demande envoyée via HTTP `GET` avec `curl` : ``` curl -X GET 'https://your-neptune-endpoint:port/loader/0a237328-afd5-4574-a0bc-c29ce5f54802?details=true&errors=true&page=1&errorsPerPage=3' ``` **Example Exemple d'une réponse détaillée en cas d'erreur** Voici un exemple de la réponse que vous pourriez obtenir à la suite de la requête ci-dessus, avec un objet `errorLogs` répertoriant les erreurs de chargement détectées : ``` { "status" : "200 OK", "payload" : { "failedFeeds" : [ { "datatypeMismatchErrors" : 0, "fullUri" : "s3://bucket/key", "insertErrors" : 0, "parsingErrors" : 5, "retryNumber" : 0, "runNumber" : 1, "status" : "LOAD_FAILED", "totalDuplicates" : 0, "totalRecords" : 5, "totalTimeSpent" : 3.0 } ], "feedCount" : [ { "LOAD_FAILED" : 1 } ], "overallStatus" : { "datatypeMismatchErrors" : 0, "fullUri" : "s3://bucket/key", "insertErrors" : 0, "parsingErrors" : 5, "retryNumber" : 0, "runNumber" : 1, "status" : "LOAD_FAILED", "totalDuplicates" : 0, "totalRecords" : 5, "totalTimeSpent" : 3.0 }, "errors" : { "endIndex" : 3, "errorLogs" : [ { "errorCode" : "PARSING_ERROR", "errorMessage" : "Expected '<', found: |", "fileName" : "s3://bucket/key", "recordNum" : 1 }, { "errorCode" : "PARSING_ERROR", "errorMessage" : "Expected '<', found: |", "fileName" : "s3://bucket/key", "recordNum" : 2 }, { "errorCode" : "PARSING_ERROR", "errorMessage" : "Expected '<', found: |", "fileName" : "s3://bucket/key", "recordNum" : 3 } ], "loadId" : "0a237328-afd5-4574-a0bc-c29ce5f54802", "startIndex" : 1 } } } ``` ## Exemple d'erreur `Data prefetch task interrupted` Parfois, lorsque vous obtenez un statut `LOAD_FAILED`, puis demandez des informations plus détaillées, l'erreur renvoyée peut être `PARSING_ERROR` avec un message `Data prefetch task interrupted`, comme suit : ``` "errorLogs" : [ { "errorCode" : "PARSING_ERROR", "errorMessage" : "Data prefetch task interrupted: Data prefetch task for 11467 failed", "fileName" : "s3://amzn-s3-demo-bucket/some-source-file", "recordNum" : 0 } ] ``` Cette erreur se produit en cas d'interruption temporaire du processus de chargement des données qui n'est généralement pas provoquée par votre demande ni vos données. Elle peut généralement être résolue simplement en réexécutant la demande de chargement par lot. Si vous utilisez les paramètres par défaut, à savoir `"mode":"AUTO"` et `"failOnError":"TRUE"`, le chargeur ignore les fichiers qu'il a déjà chargés avec succès et reprend le chargement des fichiers qu'il n'avait pas encore chargés lorsque l'interruption s'est produite. # Tâche d'annulation du chargeur Neptune Annule une tâche de chargement. Pour annuler une tâche, vous devez envoyer une demande `DELETE` HTTP au point de terminaison `https://your-neptune-endpoint:port/loader`. L'ID `loadId` peut être ajouté au chemin d'URL `/loader`, ou inclus en tant que variable dans l'URL. ## Syntaxe de la demande d'annulation de tâche ``` DELETE https://your-neptune-endpoint:port/loader?loadId=loadId ``` ``` DELETE https://your-neptune-endpoint:port/loader/loadId ``` ## Paramètres de demande d'annulation de tâche **loadId** ID de la tâche de chargement. ## Syntaxe de la réponse d'annulation de tâche ``` no response body ``` **200 OK** Une tâche de chargement supprimée avec succès renvoie un code `200`. ## Erreurs d'annulation de tâche Lorsqu'une erreur se produit, un objet JSON est renvoyé dans le `BODY` (corps) de la réponse. L'objet `message` contient une description de l'erreur. **Catégories d'erreurs** + **`Error 400`** : une erreur non valide `loadId` renvoie une erreur de requête HTTP `400` incorrecte. Le message décrit l'erreur. + **`Error 500`** : une demande valide qui ne peut pas être traitée renvoie une erreur de serveur interne HTTP `500`. Le message décrit l'erreur. ## Messages d'erreur d'annulation de tâche Voici les messages d'erreur possibles de l'API d'annulation avec une description de l'erreur. + `The load with id = load_id does not exist or not active` (HTTP 404) : le chargement est introuvable. Vérifiez la valeur du paramètre `id`. + `Load cancellation is not permitted on a read replica instance.` (HTTP 405) : le chargement est une opération d'écriture. Réessayez de charger sur le point de terminaison du read/write cluster. ## Exemples d'annulation de tâche **Example Demande** Voici une demande envoyée via HTTP `DELETE` à l'aide de la commande `curl`. ``` curl -X DELETE 'https://your-neptune-endpoint:port/loader/0a237328-afd5-4574-a0bc-c29ce5f54802' ``` # Utilisation AWS Database Migration Service pour charger des données dans Amazon Neptune à partir d'un autre magasin de données AWS Database Migration Service (AWS DMS) peut charger des données dans Neptune à partir de [bases de données sources prises en charge](https://docs.aws.amazon.com/dms/latest/userguide/CHAP_Source.html) rapidement et en toute sécurité. La base de données source reste pleinement opérationnelle durant la migration, ce qui réduit au minimum les temps d'arrêt des applications qui l'utilisent. Vous trouverez des informations détaillées AWS DMS à ce sujet dans le [guide de l'AWS Database Migration Service utilisateur](https://docs.aws.amazon.com/dms/latest/userguide/) et dans la [référence de l'AWS Database Migration Service API](https://docs.aws.amazon.com/dms/latest/APIReference/). En particulier, vous pourrez découvrir comment configurer un cluster Neptune en tant que cible de la migration dans [Utilisation d'Amazon Neptune comme cible pour AWS Database Migration Service](https://docs.aws.amazon.com/dms/latest/userguide/CHAP_Target.Neptune.html). Voici quelques prérequis à l'importation de données dans Neptune à l'aide de AWS DMS : + Vous devrez créer un objet de mappage de AWS DMS table pour définir la manière dont les données doivent être extraites de la base de données source (voir [Spécification de la sélection de tables et des transformations par mappage de table à l'aide de JSON](https://docs.aws.amazon.com/dms/latest/userguide/CHAP_Tasks.CustomizingTasks.TableMapping.html#CHAP_Tasks.CustomizingTasks.TableMapping.SelectionTransformation) dans le AWS DMS guide de l'utilisateur pour plus de détails). Cet objet de configuration de mappage de table spécifie les tables qui doivent être lues et l'ordre dans lequel cette lecture doit s'effectuer, ainsi que les noms des colonnes. Il peut également filtrer les lignes copiées et fournir des transformations de valeur simples telles que la conversion en minuscules ou l'arrondi. + Vous devrez créer une configuration `GraphMappingConfig` Neptune pour spécifier la façon dont les données extraites de la base de données source doivent être chargées dans Neptune. Pour les données RDF (interrogées à l'aide de SPARQL), l'élément `GraphMappingConfig` est écrit dans le langage de mappage standard W3 [R2RML](https://www.w3.org/TR/r2rml/). Pour les données de graphe de propriétés (interrogées à l'aide de Gremlin), `GraphMappingConfig` est un objet JSON, décrit dans [GraphMappingConfig Mise en page pour les données Property-Graph/Gkremlin](dms-neptune-graph-mapping.md#dms-neptune-graph-mapping-gremlin). + Vous devez l'utiliser AWS DMS pour créer une instance de réplication dans le même VPC que votre cluster de base de données Neptune, afin de faciliter le transfert de données. + Vous aurez également besoin d'un compartiment Amazon S3 à utiliser comme stockage intermédiaire pour le transfert des données de migration. # Création d'un Neptune GraphMappingConfig L'élément `GraphMappingConfig` que vous créez spécifie la façon dont les données extraites d'un magasin de données source doivent être chargées dans un cluster de bases de données Neptune. Son format diffère selon qu'il est destiné au chargement de données RDF ou au chargement de données de graphe de propriétés. Pour les données RDF, vous pouvez utiliser le langage W3 [R2RML](https://www.w3.org/TR/r2rml/) pour mapper des données relationnelles sur RDF. Si vous chargez des données de graphe de propriétés destinées à être interrogées à l'aide de Gremlin, vous créez un objet JSON pour `GraphMappingConfig`. ## GraphMappingConfig Mise en page des RDF/SPARQL données Si vous chargez des données RDF destinées à être interrogées à l'aide de SPARQL, vous écrivez l'élément `GraphMappingConfig` en [R2RML](https://www.w3.org/TR/r2rml/). `R2RML` est un langage W3 standard destiné au mappage des données relationnelles sur RDF. Voici un exemple : ``` @prefix rr: . @prefix ex: . <#TriplesMap1> rr:logicalTable [ rr:tableName "nodes" ]; rr:subjectMap [ rr:template "http://data.example.com/employee/{id}"; rr:class ex:Employee; ]; rr:predicateObjectMap [ rr:predicate ex:name; rr:objectMap [ rr:column "label" ]; ] . ``` Voici un autre exemple : ``` @prefix rr: . @prefix ex: . @prefix foaf: . @prefix xsd: . <#TriplesMap2> rr:logicalTable [ rr:tableName "Student" ]; rr:subjectMap [ rr:template "http://example.com/{ID}{Name}"; rr:class foaf:Person ]; rr:predicateObjectMap [ rr:predicate ex:id ; rr:objectMap [ rr:column "ID"; rr:datatype xsd:integer ] ]; rr:predicateObjectMap [ rr:predicate foaf:name ; rr:objectMap [ rr:column "Name" ] ] . ``` La recommandation W3 dans [R2RML: RDB to RDF Mapping Language](https://www.w3.org/TR/r2rml/) fournit des détails sur le langage. ## GraphMappingConfig Mise en page pour les données Property-Graph/Gkremlin L'élément `GraphMappingConfig` comparable pour les données de graphe de propriétés est un objet JSON qui fournit une règle de mappage pour chaque entité de graphe à générer à partir des données source. Le modèle suivant montre à quoi ressemble chaque règle de cet objet : ``` { "rules": [ { "rule_id": "(an identifier for this rule)", "rule_name": "(a name for this rule)", "table_name": "(the name of the table or view being loaded)", "vertex_definitions": [ { "vertex_id_template": "{col1}", "vertex_label": "(the vertex to create)", "vertex_definition_id": "(an identifier for this vertex)", "vertex_properties": [ { "property_name": "(name of the property)", "property_value_template": "{col2} or text", "property_value_type": "(data type of the property)" } ] } ] }, { "rule_id": "(an identifier for this rule)", "rule_name": "(a name for this rule)", "table_name": "(the name of the table or view being loaded)", "edge_definitions": [ { "from_vertex": { "vertex_id_template": "{col1}", "vertex_definition_id": "(an identifier for the vertex referenced above)" }, "to_vertex": { "vertex_id_template": "{col3}", "vertex_definition_id": "(an identifier for the vertex referenced above)" }, "edge_id_template": { "label": "(the edge label to add)", "template": "{col1}_{col3}" }, "edge_properties":[ { "property_name": "(the property to add)", "property_value_template": "{col4} or text", "property_value_type": "(data type like String, int, double)" } ] } ] } ] } ``` Notez que la présence d'une étiquette de sommet implique que le sommet est créé ici, alors que son absence implique que le sommet est créé par une source différente et que cette définition n'ajoute que des propriétés de sommet. Voici un exemple de règle pour un enregistrement d'employé : ``` { "rules": [ { "rule_id": "1", "rule_name": "vertex_mapping_rule_from_nodes", "table_name": "nodes", "vertex_definitions": [ { "vertex_id_template": "{emp_id}", "vertex_label": "employee", "vertex_definition_id": "1", "vertex_properties": [ { "property_name": "name", "property_value_template": "{emp_name}", "property_value_type": "String" } ] } ] }, { "rule_id": "2", "rule_name": "edge_mapping_rule_from_emp", "table_name": "nodes", "edge_definitions": [ { "from_vertex": { "vertex_id_template": "{emp_id}", "vertex_definition_id": "1" }, "to_vertex": { "vertex_id_template": "{mgr_id}", "vertex_definition_id": "1" }, "edge_id_template": { "label": "reportsTo", "template": "{emp_id}_{mgr_id}" }, "edge_properties":[ { "property_name": "team", "property_value_template": "{team}", "property_value_type": "String" } ] } ] } ] } ``` # Création d'une tâche de AWS DMS réplication avec Neptune comme cible Une fois que vous avez créé vos configurations de mappage de tables et de mappage de graphes, procédez comme suit pour charger les données du magasin source dans Neptune. Consultez la AWS DMS documentation pour plus de détails sur le sujet APIs en question. ## Création d'une instance AWS DMS de réplication Créez une instance de AWS DMS réplication dans le VPC sur lequel votre cluster de base de données Neptune est exécuté (voir [Utilisation d'une instance de réplication AWS DMS](https://docs.aws.amazon.com/dms/latest/userguide/CHAP_ReplicationInstance.html) et [CreateReplicationInstance](https://docs.aws.amazon.com/dms/latest/APIReference/API_CreateReplicationInstance.html)dans le guide de l'utilisateur). AWS DMS Pour ce faire, vous pouvez utiliser une AWS CLI commande comme celle-ci : ``` aws dms create-replication-instance \ --replication-instance-identifier (the replication instance identifier) \ --replication-instance-class (the size and capacity of the instance, like 'dms.t2.medium') \ --allocated-storage (the number of gigabytes to allocate for the instance initially) \ --engine-version (the DMS engine version that the instance should use) \ --vpc-security-group-ids (the security group to be used with the instance) ``` ## Création d'un AWS DMS point de terminaison pour la base de données source L'étape suivante consiste à créer un AWS DMS point de terminaison pour votre magasin de données source. Vous pouvez utiliser l' AWS DMS [CreateEndpoint](https://docs.aws.amazon.com/dms/latest/APIReference/API_CreateEndpoint.html)API de la AWS CLI manière suivante : ``` aws dms create-endpoint \ --endpoint-identifier (source endpoint identifier) \ --endpoint-type source \ --engine-name (name of source database engine) \ --username (user name for database login) \ --password (password for login) \ --server-name (name of the server) \ --port (port number) \ --database-name (database name) ``` ## Configuration d'un compartiment Amazon S3 que Neptune utilisera pour le transfert de données Si vous ne disposez pas d'un compartiment Amazon S3 pouvant être utilisé pour la copie intermédiaire des données, créez-en un comme expliqué dans [Création d'un compartiment](https://docs.aws.amazon.com/AmazonS3/latest/userguide/CreatingABucket.html) dans le guide de mise en route Amazon S3 ou [Comment créer un compartiment S3 ?](https://docs.aws.amazon.com/AmazonS3/latest/userguide/create-bucket.html) dans le Guide de l'utilisateur de la console. Vous devrez créer une politique IAM octroyant les autorisations `GetObject`, `PutObject`, `DeleteObject` et `ListObject` au compartiment si vous n'en avez pas déjà une : ------ #### [ JSON ] **** ``` { "Version":"2012-10-17", "Statement": [ { "Sid": "ListObjectsInBucket", "Effect": "Allow", "Action": [ "s3:ListBucket" ], "Resource": [ "arn:aws:s3:::amzn-s3-demo-bucket" ] }, { "Sid": "AllObjectActions", "Effect": "Allow", "Action": [ "s3:GetObject", "s3:PutObject", "s3:DeleteObject" ], "Resource": [ "arn:aws:s3:::amzn-s3-demo-bucket/*" ] } ] } ``` ------ Si l'authentification IAM est activée pour votre cluster de bases de données Neptune, vous devrez également inclure la politique suivante : ------ #### [ JSON ] **** ``` { "Version":"2012-10-17", "Statement": [ { "Sid": "VisualEditor0", "Effect": "Allow", "Action": "neptune-db:*", "Resource": "arn:aws:neptune-db:us-east-1:111122223333:cluster-resource-id/*" } ] } ``` ------ Créez un rôle IAM en tant que document d'approbation auquel attacher la politique : ------ #### [ JSON ] **** ``` { "Version":"2012-10-17", "Statement": [ { "Sid": "", "Effect": "Allow", "Principal": { "Service": "dms.amazonaws.com" }, "Action": "sts:AssumeRole" }, { "Sid": "neptune", "Effect": "Allow", "Principal": { "Service": "rds.amazonaws.com" }, "Action": "sts:AssumeRole" } ] } ``` ------ Après avoir attaché la politique au rôle, attachez-le à votre cluster de bases de données Neptune. Cela permettra d' AWS DMS utiliser le bucket pour préparer les données en cours de chargement. ## Création d'un point de terminaison Amazon S3 dans le VPC Neptune Créez maintenant un point de terminaison de passerelle de VPC pour votre compartiment Amazon S3 intermédiaire dans le VPC où se trouve votre cluster Neptune. Pour ce faire, vous pouvez AWS CLI utiliser le AWS Management Console ou le, comme décrit dans [Création d'un point de terminaison de passerelle](https://docs.aws.amazon.com/vpc/latest/userguide/vpce-gateway.html#create-gateway-endpoint). ## Création d'un point de terminaison AWS DMS cible pour Neptune Créez un AWS DMS point de terminaison pour votre cluster de base de données Neptune cible. Vous pouvez utiliser l' AWS DMS [CreateEndpoint](https://docs.aws.amazon.com/dms/latest/APIReference/API_CreateEndpoint.html)API avec le `NeptuneSettings` paramètre suivant : ``` aws dms create-endpoint \ --endpoint-identifier (target endpoint identifier) \ --endpoint-type target \ --engine-name neptune \ --server-name (name of the server) \ --port (port number) \ --neptune-settings '{ \ "ServiceAccessRoleArn": "(ARN of the service access role)", \ "S3BucketName": "(name of S3 bucket to use for staging files when migrating)", \ "S3BucketFolder": "(name of the folder to use in that S3 bucket)", \ "ErrorRetryDuration": (number of milliseconds to wait between bulk-load retries), \ "MaxRetryCount": (the maximum number of times to retry a failing bulk-load job), \ "MaxFileSize": (maximum file size, in bytes, of the staging files written to S3), \ "IamAuthEnabled": (set to true if IAM authentication is enabled on the Neptune cluster) }' ``` L'objet JSON transmis à l' AWS DMS `CreateEndpoint`API dans son `NeptuneSettings` paramètre comporte les champs suivants : **** + **`ServiceAccessRoleArn`** : *(obligatoire)* ARN d'un rôle IAM qui permet un accès précis au compartiment S3 utilisé comme outil intermédiaire de la migration des données vers Neptune. Ce rôle doit également avoir des autorisations d'accès à votre cluster de bases de données Neptune si l'autorisation IAM y est activée. + **`S3BucketName`** : *(obligatoire)* pour la migration à chargement complet, l'instance de réplication convertit toutes les données RDS en fichiers CSV ou quad et les charge vers ce compartiment intermédiaire dans S3, puis les charge en bloc dans Neptune. + **`S3BucketFolder`** : *(obligatoire)* dossier à utiliser dans le compartiment intermédiaire S3. + **`ErrorRetryDuration`** : *(facultatif)* nombre de millisecondes à attendre après l'échec d'une demande Neptune avant d'effectuer une nouvelle demande. La valeur par défaut est 250. + **`MaxRetryCount`**— *(facultatif)* Le nombre maximum de demandes de nouvelle tentative à effectuer AWS DMS après un échec de nouvelle tentative. La valeur par défaut est 5. + **`MaxFileSize`** : *(facultatif)* taille maximale en octets de chaque fichier intermédiaire enregistré dans S3 lors de la migration. La valeur par défaut est de 1 048 576 Ko (1 Go). + **`IsIAMAuthEnabled`** : *(facultatif)* s'il est défini sur `true`, l'authentification IAM est activée sur le cluster de bases de données Neptune. Dans le cas contraire, sa valeur indique `false`. La valeur par défaut est `false`. ## Testez les connexions aux nouveaux points de terminaison Vous pouvez tester la connexion à chacun de ces nouveaux points de terminaison à l'aide de l' AWS DMS [TestConnection](https://docs.aws.amazon.com/dms/latest/APIReference/API_TestConnection.html)API comme suit : ``` aws dms test-connection \ --replication-instance-arn (the ARN of the replication instance) \ --endpoint-arn (the ARN of the endpoint you are testing) ``` ## Création d'une tâche AWS DMS de réplication Une fois que vous avez effectué les étapes précédentes avec succès, créez une tâche de réplication pour migrer les données de votre banque de données source vers Neptune, à l'aide de AWS DMS [CreateReplicationTask](https://docs.aws.amazon.com/dms/latest/APIReference/API_CreateReplicationTask.html.html)l'API suivante : ``` aws dms create-replication-task \ --replication-task-identifier (name for the replication task) \ --source-endpoint-arn (ARN of the source endpoint) \ --target-endpoint-arn (ARN of the target endpoint) \ --replication-instance-arn (ARN of the replication instance) \ --migration-type full-load \ --table-mappings (table-mapping JSON object or URI like 'file:///tmp/table-mappings,json') \ --task-data (a GraphMappingConfig object or URI like 'file:///tmp/graph-mapping-config.json') ``` Le paramètre `TaskData` fournit le [GraphMappingConfig](dms-neptune-graph-mapping.md) qui spécifie la façon dont les données en cours de copie doivent être stockées dans Neptune. ## Lancer la tâche AWS DMS de réplication Vous pouvez maintenant démarrer la tâche de réplication : ``` aws dms start-replication-task --replication-task-arn (ARN of the replication task started in the previous step) --start-replication-task-type start-replication ``` # Chargement de données dans Amazon Neptune à l'aide de requêtes Neptune prend en charge l'écriture de données directement par le biais d'opérations en langage de requête. Vous pouvez utiliser des opérations d'écriture standard telles que `CREATE` et `MERGE` dans OpenCypher, `INSERT` dans SPARQL ou `mergeV()` `mergeE()` dans Gremlin pour ajouter ou modifier des données dans votre graphique. Ces opérations sont adaptées aux mises à jour incrémentielles et aux écritures transactionnelles. Pour charger des données depuis Amazon S3, utilisez le [Utilisation du chargeur en vrac Amazon Neptune pour ingérer des données](bulk-load.md) pour les grands ensembles de données nécessitant des performances optimisées. Pour les petits ensembles de données contenus dans un ou plusieurs fichiers Amazon S3, vous pouvez utiliser des fonctions de chargement basées sur des requêtes pour lire et traiter les données directement dans vos requêtes. Les fonctions de chargement basées sur des requêtes suivantes sont disponibles : ## OpenCypher : neptune.read () La `neptune.read()` fonction lit les fichiers CSV ou Parquet depuis Amazon S3 dans une `CALL` sous-requête, ce qui vous permet de traiter et de charger des données au moment de la requête. ``` CALL neptune.read({ source: "s3://bucket/data.csv", format: "csv" }) YIELD row CREATE (n:Person {id: row.id, name: row.name}) ``` Pour une documentation complète, voir[neptune.read ()](access-graph-opencypher-21-extensions-s3-read.md). ## SPARQL : CHARGER et DÉCHARGER Les `LOAD` opérations SPARQL importent des données RDF depuis un URI dans un graphe nommé. `UNLOAD`exporte les données d'un graphique vers Amazon S3. ``` LOAD INTO GRAPH ``` Pour une documentation complète, voir[Utilisation de SPARQL UPDATE LOAD pour importer des données dans Neptune](sparql-api-reference-update-load.md). ## Gmail : io () étape Vous pouvez également utiliser l'`g.io(URL).read()`étape de Gremlin pour lire des fichiers de données au format [GraphML](https://tinkerpop.apache.org/docs/current/dev/io/#graphml) (format XML), [GraphSon](https://tinkerpop.apache.org/docs/current/dev/io/#graphson) (format JSON) et dans d'autres formats. ``` g.io("s3://bucket/data.graphml").read().iterate() ``` Consultez [TinkerPopla documentation](https://tinkerpop.apache.org/docs/current/reference/#io-step) pour plus de détails.