Las traducciones son generadas a través de traducción automática. En caso de conflicto entre la traducción y la version original de inglés, prevalecerá la version en inglés. # Carga de datos en Amazon Neptune Hay varias formas diferentes de cargar datos de gráficos en Amazon Neptune: + Si solo necesita cargar una cantidad relativamente pequeña de datos, puede utilizar consultas como las `INSERT` instrucciones de SPARQL o Gremlin `mergeV` and `mergeE` steps. OpenCypher también incluye cláusulas y. `CREATE` `MERGE` + Puede aprovechar [Programa de carga masiva de Neptune](bulk-load.md) para adquirir grandes cantidades de datos que residan en archivos externos. El comando de carga masiva es más rápido y tiene menos sobrecarga que los comandos de lenguaje de consultas. Está optimizado para conjuntos de datos grandes y admite tanto datos RDF (Resource Description Framework) como datos de Gremlin. + [Puede usar AWS Database Migration Service (AWS DMS) para importar datos de otros almacenes de datos (consulte [AWS Database Migration Service Utilización para cargar datos en Amazon Neptune desde un almacén de datos diferente](dms-neptune.md) y la Guía del usuario).AWS Database Migration Service](https://docs.aws.amazon.com/dms/latest/userguide/) + Para conjuntos de datos más pequeños en uno o varios archivos de Amazon S3, puede utilizar las funciones de carga basadas en consultas para leer y procesar los datos directamente dentro de sus consultas. Consulte [Carga de datos en Amazon Neptune mediante consultas](load-data-via-query.md) para obtener más detalles. **Topics** + [Uso del programa de carga masiva de Amazon Neptune para adquirir datos](bulk-load.md) + [AWS Database Migration Service Utilización para cargar datos en Amazon Neptune desde un almacén de datos diferente](dms-neptune.md) + [Carga de datos en Amazon Neptune mediante consultas](load-data-via-query.md) # Uso del programa de carga masiva de Amazon Neptune para adquirir datos Amazon Neptune ofrece un comando `Loader` para cargar datos de archivos externos directamente en un clúster de base de datos de Neptune. Puede utilizar este comando en lugar de ejecutar un gran número de instrucciones `INSERT`, pasos `addV` y `addE`, u otras llamadas a la API. El comando **Loader** de Neptune es más rápido, implica una menor sobrecarga, está optimizado para conjuntos de datos grandes y es compatible tanto con los datos de Gremlin como los datos RDF (marco de descripción de recursos) que utiliza SPARQL. En el diagrama siguiente se muestra información general del proceso de carga: ![\[Diagrama que muestra los pasos básicos para cargar datos en Neptune.\]](http://docs.aws.amazon.com/es_es/neptune/latest/userguide/images/load-diagram.png) A continuación se muestran los pasos del proceso de carga: 1. Copie los archivos de datos en un bucket de Amazon Simple Storage Service (Amazon S3). 1. Crear una función de IAM con acceso de lectura y lista al bucket. 1. Cree punto de conexión de VPC de Amazon S3 1. Inicie el programa de carga de Neptune enviando una solicitud mediante HTTP a la instancia de base de datos de Neptune. 1. La instancia de base de datos de Neptune asume el rol de IAM para cargar los datos del bucket. **nota** Puede cargar datos cifrados de Amazon S3 si se cifraron mediante `SSE-S3` de Amazon S3 o el modo `SSE-KMS`, siempre que el rol que utilice para la carga masiva tenga acceso al objeto de Amazon S3 y, en el caso de SSE-KMS, a `kms:decrypt`. En ese caso, Neptune puede suplantar sus credenciales y emitir llamadas `s3:getObject` en su nombre. Sin embargo, Neptune actualmente no admite la carga de datos cifrados con el modo `SSE-C`. En las secciones siguientes, encontrará instrucciones para preparar y cargar datos en Neptune. **Topics** + [Requisitos previos: rol de IAM y acceso a Amazon S3](bulk-load-tutorial-IAM.md) + [Formatos de los datos de carga](bulk-load-tutorial-format.md) + [Ejemplo: carga de datos en una instancia de base de datos de Neptune](bulk-load-data.md) + [Optimización de una carga masiva de Amazon Neptune](bulk-load-optimize.md) + [Referencia del programa de carga de Neptune](load-api-reference.md) # Requisitos previos: rol de IAM y acceso a Amazon S3 La carga de datos desde un bucket de Amazon Simple Storage Service (Amazon S3) requiere AWS Identity and Access Management un rol (IAM) que tenga acceso al bucket. Amazon Neptune asume este rol para cargar los datos. **nota** Puede cargar datos cifrados desde Amazon S3 si se cifran mediante el modo `SSE-S3` de Amazon S3. En ese caso, Neptune es capaz de suplantar sus credenciales y emitir llamadas de `s3:getObject` en su nombre. También puede cargar datos cifrados desde Amazon S3 que se hayan cifrado mediante el modo `SSE-KMS`, siempre que el rol de IAM incluya los permisos necesarios para obtener acceso a AWS KMS. Sin AWS KMS los permisos adecuados, la operación de carga masiva no se realiza correctamente y devuelve una `LOAD_FAILED` respuesta. Actualmente Neptune no admite la carga de datos cifrados de Amazon S3 con el modo `SSE-C`. En las siguientes secciones, se muestra cómo utilizar una política de IAM administrada para crear un rol de IAM para obtener acceso a los recursos de Amazon S3 y, luego, asociarla a su clúster de Neptune. **Topics** + [Creación de un rol de IAM que permita a Amazon Neptune acceder a los recursos de Amazon S3.](bulk-load-tutorial-IAM-CreateRole.md) + [Adición del rol de IAM a un clúster de Amazon Neptune](bulk-load-tutorial-IAM-add-role-cluster.md) + [Creación de un punto de conexión de VPC de Amazon S3](bulk-load-tutorial-vpc.md) + [Encadenamiento de roles de IAM en Amazon Neptune](bulk-load-tutorial-chain-roles.md) **nota** En estas instrucciones, se requiere que tenga acceso a la consola de IAM y permisos para administrar las políticas y los roles de IAM. Para obtener más información, consulte [Permisos para trabajar en la consola AWS de administración](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_permissions-required.html#Credentials-Permissions-overview-console) en la *Guía del usuario de IAM*. La consola de Amazon Neptune requiere que el usuario tenga los siguientes permisos de IAM para asociar el rol al clúster de Neptune: ``` iam:GetAccountSummary on resource: * iam:ListAccountAliases on resource: * iam:PassRole on resource: * with iam:PassedToService restricted to rds.amazonaws.com ``` # Creación de un rol de IAM que permita a Amazon Neptune acceder a los recursos de Amazon S3. Utilice la política de IAM administrada `AmazonS3ReadOnlyAccess` para crear un nuevo rol de IAM que permita a Amazon Neptune acceder a los recursos de Amazon S3. **Para crear un nuevo rol de IAM que permita que Neptune acceda a Amazon S3** 1. Abra la consola de IAM en [https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/). 1. Seleccione **Roles** en el panel de navegación. 1. Elija **Create role** (Crear rol). 1. En **Servicio de AWS **, elija **S3**. 1. Elija **Siguiente: permisos**. 1. Utilice la casilla de filtro para filtrar por el término **S3** y marque la casilla situada junto a **ReadOnlyAccessAmazonS3**. **nota** Esta política concede los permisos `s3:Get*` y `s3:List*` a todos los buckets. Los pasos posteriores restringen el acceso al rol mediante la política de confianza. El programa de carga solo requiere los permisos `s3:Get*` y `s3:List*` para el bucket desde el que realiza la carga, por lo que también puede restringir estos permisos según el recurso de Amazon S3. Si su bucket de S3 está cifrado, debe añadir permisos `kms:Decrypt` 1. Elija **Siguiente: Revisar**. 1. En **Nombre de rol**, escriba un nombre para el rol de IAM, por ejemplo, `NeptuneLoadFromS3`. También puede añadir un valor opcional en **Descripción del rol**, como: "Permite a Neptune obtener acceso a los recursos de Amazon S3 en su nombre". 1. Seleccione **Crear rol**. 1. Seleccione **Roles** en el panel de navegación. 1. En el campo **Search (Buscar)**, introduzca el nombre de la función creada y elija la función cuando aparezca en la lista. 1. En la pestaña **Trust Relationships (Relaciones de confianza)**, elija **Edit trust relationship (Editar relación de confianza)**. 1. Copie la siguiente política de confianza en el campo de texto: ------ #### [ JSON ] **** ``` { "Version":"2012-10-17", "Statement": [ { "Sid": "", "Effect": "Allow", "Principal": { "Service": [ "rds.amazonaws.com" ] }, "Action": "sts:AssumeRole" } ] } ``` ------ 1. Elija **Actualizar política de confianza**. 1. Realice los pasos que se indican en [Adición del rol de IAM a un clúster de Amazon Neptune](bulk-load-tutorial-IAM-add-role-cluster.md). # Adición del rol de IAM a un clúster de Amazon Neptune Utilice la consola para añadir el rol de IAM a un clúster de Amazon Neptune. De este modo, cualquier instancia de base de datos de Neptune del clúster puede asumir el rol y cargarlo desde Amazon S3. **nota** La consola de Amazon Neptune requiere que el usuario tenga los siguientes permisos de IAM para asociar el rol al clúster de Neptune: ``` iam:GetAccountSummary on resource: * iam:ListAccountAliases on resource: * iam:PassRole on resource: * with iam:PassedToService restricted to rds.amazonaws.com ``` **Para añadir un rol de IAM a un clúster de Amazon Neptune** 1. [Inicie sesión en la consola AWS de administración y abra la consola de Amazon Neptune en https://console.aws.amazon.com/neptune/ casa.](https://console.aws.amazon.com/neptune/home) 1. En el panel de navegación, elija **Databases** (Bases de datos). 1. Elija el identificador del clúster que desee modificar. 1. Elija la pestaña **Conectividad y seguridad**. 1. En la sección Roles de IAM, elija el rol que ha creado en la sección anterior. 1. Seleccione **Add role (Añadir rol)**. 1. Espere hasta que el clúster tenga acceso al rol de IAM antes de utilizarlo. # Creación de un punto de conexión de VPC de Amazon S3 El programa de carga de Neptune requiere un punto de conexión de VPC de tipo Puerta de enlace para Amazon S3. **Para configurar el acceso a Amazon S3** 1. Inicie sesión en la consola de Amazon VPC Consola de administración de AWS y ábrala en. [https://console.aws.amazon.com/vpc/](https://console.aws.amazon.com/vpc/) 1. En el panel de navegación, elija **Puntos de conexión**. 1. Elija **Crear punto de conexión**. 1. Elija el **Nombre del servicio** `com.amazonaws.region.s3` para el punto de conexión de tipo Puerta de enlace. **nota** Si la región indicada es incorrecta, asegúrese de que la región de la consola es correcta. 1. Elija la VPC que contiene su instancia de base de datos de Neptune (aparece para su instancia de base de datos en la consola de Neptune). 1. Seleccione la casilla de verificación situada junto a las tablas de ruteo asociadas a las subredes relacionadas con el clúster. Si solo tiene una tabla de ruteo, debe seleccionar esa casilla. 1. Seleccione **Crear punto de conexión**. Para obtener más información acerca de la creación del punto de conexión, consulte [Puntos de conexión de la VPC](https://docs.aws.amazon.com/vpc/latest/userguide/vpc-endpoints.html#create-vpc-endpoint) en la *Guía del usuario de Amazon VPC*. Para obtener información acerca de las limitaciones de los puntos de conexión de VPC, consulte [VPC Endpoints for Amazon S3](https://docs.aws.amazon.com/vpc/latest/userguide/vpc-endpoints-s3.html). **Siguientes pasos** Ahora que ha concedido acceso al bucket de Amazon S3, puede prepararse para la carga de datos. Para obtener información acerca de los formatos admitidos, consulte [Formatos de los datos de carga](bulk-load-tutorial-format.md). # Encadenamiento de roles de IAM en Amazon Neptune **importante** La nueva característica multicuenta de carga masiva introducida en la [versión 1.2.1.0.R3 del motor](engine-releases-1.2.1.0.R3.md), que aprovecha la posibilidad de encadenar roles de IAM, en algunos casos, puede provocar una degradación del rendimiento de la carga masiva. En consecuencia, las actualizaciones de las versiones del motor que admiten esta característica se han suspendido temporalmente hasta que se resuelva el problema. Cuando asocia un rol a su clúster, este puede asumir dicho rol para obtener acceso a los datos almacenados en Amazon S3. A partir de la [versión 1.2.1.0.R3 del motor](engine-releases-1.2.1.0.R3.md), si ese rol no tiene acceso a todos los recursos que necesita, puede encadenar uno o más roles adicionales que el clúster puede asumir para acceder a otros recursos. Cada rol de la cadena asume el siguiente rol de la cadena, hasta que su clúster haya asumido el rol al final de la cadena. Para encadenar roles, debe establecer una relación de confianza entre ellos. Por ejemplo, para encadenar `RoleB` a `RoleA`, `RoleA` debe tener una política de permisos que le permita asumir `RoleB` y `RoleB` debe tener una política de confianza que le permita volver a transferir sus permisos a `RoleA`. Para obtener más información, consulte [Uso de roles de IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_use.html). El primer rol de una cadena debe estar asociado al clúster que está cargando los datos. El primer rol, y cada rol subsiguiente que asuma el siguiente rol en la cadena, debe tener: + Una política que incluye una instrucción específica con el efecto `Allow` sobre la acción `sts:AssumeRole`. + El nombre de recurso de Amazon (ARN) del siguiente rol de un elemento `Resource`. **nota** El bucket de Amazon S3 de destino debe estar en la misma AWS región que el clúster. ## Acceso entre cuentas mediante roles encadenados Puede conceder el acceso entre cuentas encadenando un rol o roles que pertenezcan a otra cuenta. Cuando su clúster asuma temporalmente un rol que pertenece a otra cuenta, puede acceder a los recursos de esa cuenta. Por ejemplo, imagine que la **cuenta A** desea obtener acceso a los datos de un bucket de Amazon S3 que pertenece a la **cuenta B**: + La **cuenta A** crea un rol de AWS servicio para Neptune denominado `RoleA` y lo adjunta a un clúster. + La **cuenta B** crea un rol denominado `RoleB` que está autorizado para obtener acceso a los datos de un bucket de la **cuenta B**. + La **cuenta A** asocia una política de permisos a `RoleA` que le permite asumir `RoleB`. + La **cuenta B** asocia una política de confianza a `RoleB`, que le permite transferir sus permisos a `RoleA`. + Para obtener acceso a los datos del bucket de la **cuenta B**, la **cuenta A** ejecuta un comando del programa de carga utilizando un parámetro `iamRoleArn` que encadena `RoleA` y `RoleB`. Durante la operación del programa de carga, `RoleA` asume de forma temporal el `RoleB` para obtener acceso al bucket de Amazon S3 en la **cuenta B**. ![\[Diagrama que muestra el acceso entre cuentas mediante roles encadenados\]](http://docs.aws.amazon.com/es_es/neptune/latest/userguide/images/cross-account-bulk-load.png) Por ejemplo, `RoleA` tendría una política de confianza que establece una relación de confianza con Neptune: ------ #### [ JSON ] **** ``` { "Version":"2012-10-17", "Statement": [ { "Effect": "Allow", "Principal": { "Service": "rds.amazonaws.com" }, "Action": "sts:AssumeRole" } ] } ``` ------ `RoleA` también tendría una política de permisos que le permitiría asumir el `RoleB`, que es propiedad de la **cuenta B**: ------ #### [ JSON ] **** ``` { "Version":"2012-10-17", "Statement": [ { "Sid": "Stmt1487639602000", "Effect": "Allow", "Action": [ "sts:AssumeRole" ], "Resource": "arn:aws:iam::111122223333:role/RoleB" } ] } ``` ------ Por el contrario, `RoleB` tendría una política de confianza para establecer una relación de confianza con`RoleA`: ------ #### [ JSON ] **** ``` { "Version":"2012-10-17", "Statement": [ { "Effect": "Allow", "Action": "sts:AssumeRole", "Principal": { "AWS": "arn:aws:iam::111122223333:role/RoleA" } } ] } ``` ------ `RoleB` también necesitaría permiso para acceder a los datos del bucket de Amazon S3 ubicado en la **cuenta B**. ## Creación de un punto AWS Security Token Service final de VPC (STS) El cargador Neptune requiere un punto final de VPC para encadenar funciones de IAM para AWS STS acceder de forma privada a través de direcciones IP privadas. AWS STS APIs Puede conectarse directamente desde una Amazon VPC a AWS STS través de un punto final de VPC de forma segura y escalable. Cuando utiliza un punto de conexión de VPC de interfaz, ofrece una mejor postura de seguridad, ya que no necesita abrir firewalls de tráfico saliente. También ofrece las demás ventajas del uso de puntos de conexión de Amazon VPC. Cuando se utiliza un punto final de VPC, el tráfico AWS STS no se transmite por Internet y nunca sale de la red de Amazon. Su VPC está conectada de forma segura AWS STS sin riesgos de disponibilidad ni restricciones de ancho de banda en el tráfico de su red. Para obtener más información, consulte [Uso de puntos de conexión de VPC de interfaz en AWS STS](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_sts_vpce.html). **Para configurar el acceso para AWS Security Token Service (STS)** 1. Inicie sesión en la consola de Amazon VPC Consola de administración de AWS y ábrala en. [https://console.aws.amazon.com/vpc/](https://console.aws.amazon.com/vpc/) 1. En el panel de navegación, elija **Puntos de conexión**. 1. Elija **Crear punto de conexión**. 1. Elija el **Nombre del servicio**: `com.amazonaws.region.sts` para el punto de conexión de tipo Interfaz. 1. Elija la **VPC** que contiene la instancia de base de datos de Neptune y la instancia EC2. 1. Seleccione la casilla de verificación junto a la subred en la que se encuentra su instancia EC2. No puede seleccionar varias subredes de la misma zona de disponibilidad. 1. En Tipo de dirección IP, elija entre las siguientes opciones: + **IPv4**— Asigne IPv4 direcciones a las interfaces de red de sus puntos finales. Esta opción solo se admite si todas las subredes seleccionadas tienen rangos de IPv4 direcciones. + **IPv6**— Asigne IPv6 direcciones a las interfaces de red de sus puntos finales. Esta opción solo se admite si todas las subredes seleccionadas son subredes IPv6 exclusivas. + **Dualstack**: asigne ambas IPv6 direcciones a las interfaces de red IPv4 de sus puntos finales. Esta opción solo se admite si todas las subredes seleccionadas tienen ambos IPv4 rangos de direcciones. IPv6 1. En **Security groups** (Grupos de seguridad), seleccione los grupos de seguridad para asociarlas a las interfaces de red del punto de conexión para el punto de conexión de VPC. Debería seleccionar todos los grupos de seguridad que están asociados a la instancia de base de datos de Neptune y a la instancia EC2. 1. En **Política**, seleccione **Acceso completo** para permitir todas las operaciones de todas las entidades principales en todos los recursos del punto de conexión de VPC. De lo contrario, seleccione **Personalizar** para adjuntar una política de punto de conexión de VPC que controle los permisos que tienen las entidades principales para realizar acciones en los recursos a través del punto de conexión de VPC. Esta opción solo está disponible si el servicio admite las políticas de punto de conexión de VPC. Para obtener más información, consulte [Políticas de puntos de conexión](https://docs.aws.amazon.com/vpc/latest/privatelink/vpc-endpoints-access.html). 1. (*Opcional*) Para añadir una etiqueta, elija **Agregar etiqueta nueva** e introduzca la clave y el valor de la etiqueta. 1. Seleccione **Crear punto de conexión**. Para obtener más información acerca de la creación del punto de conexión, consulte [Puntos de conexión de la VPC](https://docs.aws.amazon.com/vpc/latest/privatelink/create-interface-endpoint.html) en la Guía del usuario de Amazon VPC. Tenga en cuenta que el punto de conexión de VPC de Amazon STS es un requisito previo obligatorio para el encadenamiento de roles de IAM. Ahora que ha concedido el acceso al AWS STS punto final, puede prepararse para cargar los datos. Para obtener más información acerca de los formatos admitidos, consulte [Load Data Formats](bulk-load-tutorial-format.md). ## Encadenamiento de roles en un comando del programa de carga Puede especificar el encadenamiento de roles al ejecutar un comando de carga incluyendo una lista de roles separados por comas ARNs en el parámetro. `iamRoleArn` Aunque la mayoría de las veces solo necesitará tener dos roles en una cadena, es posible encadenar tres o más. Por ejemplo, este comando del programa de carga encadena tres roles: ``` 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" }' ``` # Formatos de los datos de carga La API `Load` de Amazon Neptune admite la carga de datos en una gran variedad de formatos. **Formatos de carga de gráficos de propiedades** A continuación, se pueden consultar los datos cargados en uno de los siguientes formatos de gráficos de propiedades mediante Gremlin y openCypher: + [Formato de datos de carga de Gremlin](bulk-load-tutorial-format-gremlin.md) (`csv`): formato de valores separados por comas (CSV). + [Formato de carga de datos openCypher](bulk-load-tutorial-format-opencypher.md): (`opencypher`) formato de valores separados por comas (CSV). **Formatos de carga RDF** Para cargar datos del marco de descripción de recursos (RDF) que consulte mediante SPARQL, puede utilizar uno de los siguientes formatos estándar especificados por el World Wide Web Consortium (W3C): + N-Triples (`ntriples`) de la especificación en [https://www.w3.org/TR/n-triples/](https://www.w3.org/TR/n-triples/). + N-Quads (`nquads`) de la especificación en [https://www.w3.org/TR/n-quads/](https://www.w3.org/TR/n-quads/). + RDF/XML (`rdfxml`) de la especificación en [https://www.w3.org/TR/rdf-syntax-grammar/](https://www.w3.org/TR/rdf-syntax-grammar/). + Turtle (`turtle`) de la especificación en [https://www.w3.org/TR/turtle/](https://www.w3.org/TR/turtle/). **Los datos de carga deben utilizar la codificación UTF-8** **importante** Todos los archivos de datos de carga deben estar codificados en formato UTF-8. Si un archivo no tiene formato UTF-8, Neptune intenta cargarlo de todos modos como UTF-8. Para los datos N-Quads y N-triples que incluyen caracteres Unicode, se admiten las secuencias de escape `\uxxxxx`. Sin embargo, Neptune no admite la normalización. Si hay un valor que requiere normalización, no byte-to-byte coincidirá durante la consulta. Para obtener más información acerca de la normalización, consulte la página [Normalization](https://unicode.org/faq/normalization.html) en [Unicode.org](https://unicode.org). Si los datos no están en un formato compatible, debe convertirlos antes de cargarlos. Una herramienta para convertir GraphML al formato CSV de Neptune está disponible en el proyecto [Graph ML2](https://github.com/awslabs/amazon-neptune-tools/blob/master/graphml2csv/README.md) CSV en. [GitHub](https://github.com/) ## Compatibilidad con compresión para archivos de datos de carga Neptune admite la compresión de archivos individuales en formato `gzip` o `bzip2`. El archivo comprimido debe tener una extensión `.gz` o `.bz2` y debe ser un archivo de texto único codificado en formato UTF-8. Puede cargar varios archivos, pero cada uno debe ser un archivo `.gz`, `.bz2` o un archivo de texto sin comprimir independiente. No es posible archivar archivos con extensiones como `.tar`, `.tar.gz` y `.tgz`. En las siguientes secciones se describen los formatos de manera más detallada. **Topics** + [Compatibilidad con compresión para archivos de datos de carga](#bulk-load-tutorial-format-compression) + [Formato de datos de carga de Gremlin](bulk-load-tutorial-format-gremlin.md) + [Formato de carga para los datos de openCypher](bulk-load-tutorial-format-opencypher.md) + [Formatos de los datos de carga de RDF](bulk-load-tutorial-format-rdf.md) # Formato de datos de carga de Gremlin Para cargar datos de Apache TinkerPop Gremlin con el formato CSV, debe especificar los vértices y los bordes en archivos separados. El cargador puede cargar desde varios archivos de vértice y varios archivos de borde en una única tarea de carga. Para cada comando de carga, el conjunto de archivos que se va a cargar debe estar en la misma carpeta del bucket de Amazon S3 y se debe especificar el nombre de la carpeta para el parámetro `source`. Los nombres de archivo y las extensiones de estos no son importantes. El formato CSV de Amazon Neptune se ajusta a la especificación RFC 4180 para este tipo de formato. Para obtener más información, consulte la sección sobre [formato común y tipos MIME para archivos CSV](https://tools.ietf.org/html/rfc4180) en el sitio web de Internet Engineering Task Force (IETF). **nota** Todos los archivos deben estar codificados en formato UTF-8. Cada archivo tiene una fila de encabezado con elementos separados por comas. La fila de encabezado se compone tanto de encabezados de columnas del sistema como encabezados de columnas de propiedades. ## Encabezados de columnas del sistema Los encabezados de columnas del sistema necesarios y permitidos son distintos para los archivos de vértices y para los archivos de bordes. Cada columna del sistema solo puede aparecer una vez en un encabezado. Todas las etiquetas distinguen entre mayúsculas y minúsculas. **Encabezados de vértices** + `~id`: **obligatorio** ID del vértice. + `~label` Etiqueta para el vértice. Se permiten varios valores de etiqueta, separados por punto y coma (`;`). Si no `~label` está presente, TinkerPop proporciona una etiqueta con el valor`vertex`, ya que cada vértice debe tener al menos una etiqueta. **Encabezados de borde** + `~id`: **obligatorio** ID del borde. + `~from`: **obligatorio** ID del vértice *desde*. + `~to`: **obligatorio** ID del vértice *hasta*. + `~label` Etiqueta para el borde. Los bordes solo pueden tener una etiqueta. Si no `~label` está presente, TinkerPop proporciona una etiqueta con el valor`edge`, ya que cada borde debe tener una etiqueta. ## Encabezados de columnas de propiedades Para especificar una columna (`:`) para una propiedad, use la sintaxis siguiente. Los nombres de tipos no distinguen entre mayúsculas y minúsculas. Sin embargo, tenga en cuenta que si aparecen dos puntos dentro del nombre de una propiedad, deben ir precedidos de una barra invertida: `\:`. ``` propertyname:type ``` **nota** No se permiten espacios, comas, retornos de carro ni caracteres de nueva línea en los encabezados de las columnas, por lo que los nombres de las propiedades no pueden incluir estos caracteres. Para especificar una columna para un tipo de matriz, añada `[]` al tipo: ``` propertyname:type[] ``` **nota** Las propiedades de borde solo pueden tener un único valor y provocarán un error si se especifica un tipo de matriz o si se especifica un segundo valor. En el siguiente ejemplo, se muestra el encabezado de columna para una propiedad llamada `age` de tipo `Int`. ``` age:Int ``` Cada fila del archivo debe tener un entero en esa posición o bien dejarse en blanco. Se permiten matrices de cadenas, pero las cadenas de una matriz no pueden incluir el carácter de punto y coma (`;`) a menos que se escapen mediante una barra invertida (como esta: `\;`). **Especificación de la cardinalidad de una columna** El encabezado de columna se pueden utilizar para especificar la *cardinalidad* de la propiedad identificada por la columna. Esto permite que el programa de carga masivo respete la cardinalidad de manera similar a como lo hace con las consultas Gremlin. Especifique la cardinalidad de una columna como se indica a continuación: ``` propertyname:type(cardinality) ``` El valor *cardinality* puede ser `single` o `set`. El valor predeterminado se supone que es `set`, lo que significa que la columna puede aceptar varios valores. En el caso de los archivos de borde, la cardinalidad es siempre única y la especificación de otra cardinalidad provoca que el programa de carga genere una excepción. Si la cardinalidad es `single`, el programa de carga genera un error si ya hay presente un valor anterior cuando se cargan uno o varios valores. Este comportamiento se puede anular, de forma que un valor existente se sustituye cuando un nuevo valor se carga mediante el uso del indicador `updateSingleCardinalityProperties`. Consulte [Comando Loader](load-api-reference-load.md). Es posible utilizar una configuración de cardinalidad con un tipo de matriz, aunque esto, por lo general, no es es necesario. A continuación se muestran las posibles combinaciones: + `name:type`: la cardinalidad es `set` y el contenido es de un solo valor. + `name:type[]`: la cardinalidad es `set` y el contenido es de varios valores. + `name:type(single)`: la cardinalidad es `single` y el contenido es de un solo valor. + `name:type(set)`— la cardinalidad es `set`, que es la misma que la predeterminada, y el contenido es de un solo valor. + `name:type(set)[]`: la cardinalidad es `set` y el contenido es de varios valores. + `name:type(single)[]`: esto es contradictorio y produce un error. En la siguiente sección se enumeran todos los tipos de datos Gremlin disponibles. ## Tipos de datos de Gremlin Esta es una lista de los tipos de propiedades permitidos, con una descripción de cada tipo. **Bool (o Booleano)** Indica un campo booleano. Valores permitidos: `false`, `true` **nota** Cualquier valor distinto de `true` se tratará como falso. **Tipos de número entero** Los valores fuera de los intervalos definidos generarán un error. | | | Tipo | Range | | --- |--- | | Byte | De -128 a 127 | | Short | De -32768 a 32767 | | Int | -2^31 a 2^31-1 | | Long | -2^63 a 2^63-1 | **Tipos de número decimal** Admite la notación decimal y la notación científica. También permite símbolos, como (\$1/-), Infinity o NaN. INF no se admite. | | | Tipo | Rango | | --- |--- | | Flotante | Punto flotante IEEE 754 de 32 bits | | Double | Punto flotante IEEE 754 de 64 bits | Los valores float y double que son demasiado largos, se cargan y se redondean al valor más cercano con una precisión de 24 bits (float) y de 53 bits (double). Un valor intermedio se redondea a 0 hasta el último dígito restante en el nivel de bit. **Cadena** El uso de las comillas es opcional. A los caracteres de coma, nueva línea y retorno de carro se les aplica escape automáticamente si están incluidos en una cadena entre comillas dobles (`"`). *Ejemplo*: `"Hello, World"` Para incluir comillas en una cadena con comillas, use dos entradas de comillas en una fila para aplicar escape: *Ejemplo:* `"Hello ""World"""` Se permiten matrices de cadenas, pero las cadenas de una matriz no pueden incluir el carácter de punto y coma (`;`) a menos que se escapen mediante una barra invertida (como esta: `\;`). Si desea rodear las cadenas de una matriz con comillas, debe rodear toda la matriz con un conjunto de comillas. *Ejemplo*: `"String one; String 2; String 3"` **Date** Fecha de Java en formato ISO-8601. Soporta los siguientes formatos:`yyyy-MM-dd`,`yyyy-MM-ddTHH:mm`,`yyyy-MM-ddTHH:mm:ss`,`yyyy-MM-ddTHH:mm:ssZ`. Los valores se convierten a tiempo de época y se almacenan. **Fecha y hora** Fecha de Java en formato ISO-8601. Soporta los siguientes formatos:`yyyy-MM-dd`,`yyyy-MM-ddTHH:mm`,`yyyy-MM-ddTHH:mm:ss`,`yyyy-MM-ddTHH:mm:ssZ`. Los valores se convierten a tiempo de época y se almacenan. ## Formato de fila de Gremlin **Delimitadores** Los campos de una fila se separan por una coma. Los registros se separan por una nueva línea o por una nueva línea seguida de un retorno de carro. **Campos en blanco** Se permiten los campos en blanco para las columnas que no son obligatorias (por ejemplo, las propiedades que define el usuario). Un campo en blanco también requiere el separador de coma. Los campos en blanco en las columnas obligatorias darán lugar a un error de análisis. Los valores de cadena vacíos se interpretan como un valor de cadena vacío para el campo, no como un campo en blanco. El ejemplo de la siguiente sección tiene un campo en blanco en cada vértice de ejemplo. **Vértice IDs** Los valores `~id` deben ser únicos para todos los vértices en cada archivo de vértices. Varias filas de vértice que tengan valores `~id` idénticos se aplican a un mismo vértice del gráfico. La cadena vacía (`""`) es un identificador válido y el vértice se crea con una cadena vacía como identificador. **Borde IDs** Los valores `~id` también deben ser únicos para todos los bordes en cada archivo de bordes. Varias filas de borde que tengan valores `~id` idénticos se aplican a un mismo borde del gráfico. La cadena vacía (`""`) es un identificador válido y el borde se crea con una cadena vacía como identificador. **Etiquetas** Las etiquetas distinguen entre mayúsculas y minúsculas y no pueden estar vacías. Un valor de `""` dará lugar a un error. **Valores de cadena** El uso de las comillas es opcional. A los caracteres de coma, nueva línea y retorno de carro se les aplica escape automáticamente si están incluidos en una cadena entre comillas dobles (`"`). Los valores de cadena vacíos `("")` se interpretan como un valor de cadena vacío para el campo, no como un campo en blanco. ## Especificación del formato CSV El formato CSV de Neptune se ajusta a la especificación RFC 4180 correspondiente a este tipo de formato, que incluye los siguientes requisitos: + Se admiten finales de línea tanto de estilo Unix como Windows (\$1n o \$1r\$1n). + Cualquier campo se puede incluir entre comillas (usando comillas dobles). + Los campos que contienen un salto de línea, comillas dobles o comas deben incluirse entre comillas. (De lo contrario, la carga se anula inmediatamente). + Un carácter de comillas dobles (`"`) en un campo debe representarse con dos caracteres de comillas (dobles). Por ejemplo, una cadena `Hello "World"` debe aparecer como `"Hello ""World"""` en los datos. + Los espacios que hay entre los delimitadores se omiten. Si una fila se incluye como `value1, value2`, se almacenan como `"value1"` y `"value2"`. + Cualquier otro carácter de escape se almacena literalmente. Por ejemplo, `"data1\tdata2"` se almacena como `"data1\tdata2"`. No es necesario seguir aplicando el escape, siempre que estos caracteres estén encerrados entre comillas. + Se permiten campos en blanco. Un campo en blanco se considera un valor vacío. + Si un campo tiene varios valores, estos se separan por punto y coma (`;`). Para obtener más información, consulte la sección sobre [formato común y tipos MIME para archivos CSV](https://tools.ietf.org/html/rfc4180) en el sitio web de Internet Engineering Task Force (IETF). ## Ejemplo de Gremlin El siguiente diagrama muestra un ejemplo de dos vértices y una arista tomados del gráfico TinkerPop moderno. ![\[Diagrama que muestra dos vértices y un borde, cuyos elementos son marko, de 29 años, y software LOP con lenguaje java.\]](http://docs.aws.amazon.com/es_es/neptune/latest/userguide/images/tiny-modern-graph.png) A continuación se muestra el gráfico con formato de carga CSV de Neptune. Archivo de vértice: ``` ~id,name:String,age:Int,lang:String,interests:String[],~label v1,"marko",29,,"sailing;graphs",person v2,"lop",,"java",,software ``` Vista tabular del archivo de vértice: | | | | | | | | --- |--- |--- |--- |--- |--- | | \$1id | name:String | age:Int | lang:String | Intereses: cadena [] | \$1label | | v1 | "marko" | 29 | | ["navegación», «gráficos"] | person | | v2 | "lop" | | "java" | | software | Archivo de borde: ``` ~id,~from,~to,~label,weight:Double e1,v1,v2,created,0.4 ``` Vista tabular del archivo de borde: | | | | | | | --- |--- |--- |--- |--- | | \$1id | \$1from | \$1a | \$1label | weight:Double | | e1 | v1 | v2 | created | 0.4 | **Siguientes pasos** Ahora que conoce mejor los formatos de carga, consulte [Ejemplo: carga de datos en una instancia de base de datos de Neptune](bulk-load-data.md). # Formato de carga para los datos de openCypher Para cargar datos de openCypher con el formato CSV de OpenCypher, debe especificar los nodos y las relaciones en archivos independientes. El programa de carga puede cargar desde varios de estos archivos de nodos y archivos de relaciones en un solo trabajo de carga. Para cada comando de carga, el conjunto de archivos que se va a cargar debe tener el mismo prefijo de ruta en un bucket de Amazon Simple Storage Service. Debe especificar ese prefijo en el parámetro de origen. Los nombres de archivo y sus extensiones no son importantes. En Amazon Neptune, el formato CSV de openCypher cumple la especificación CSV de la RFC 4180. Para obtener más información, consulte [Formato común y tipo MIME para archivos CSV](https://tools.ietf.org/html/rfc4180) (https://tools.ietf.org/html/rfc4180) en el sitio web del Grupo de Trabajo de Ingeniería de Internet (IETF). **nota** Estos archivos deben estar codificados en formato UTF-8. Cada archivo tiene una fila de encabezados separada por comas que contiene los encabezados de las columnas del sistema y los encabezados de las columnas de propiedades. ## Encabezados de columnas del sistema en archivos de carga de datos de openCypher Una columna del sistema determinada solo puede aparecer una vez en cada archivo. Todas las etiquetas de encabezado de columna del sistema distinguen entre mayúsculas y minúsculas. Los encabezados de columna del sistema que son obligatorios y están permitidos son diferentes para los archivos de carga de nodos de openCypher y los archivos de carga de relaciones: ### Encabezados de columnas del sistema en los archivos de nodos + **`:ID`**: (obligatorio) Un identificador para el nodo. Se puede añadir un espacio de identificación opcional al encabezado de la columna `:ID` del nodo de la siguiente manera: `:ID(ID Space)`. Un ejemplo es `:ID(movies)`. Al cargar las relaciones que conectan los nodos de este archivo, utilice los mismos espacios de identificación en las columnas de los archivos de relaciones. `:START_ID` and/or `:END_ID` La columna `:ID` de los nodos se puede almacenar opcionalmente como una propiedad en el formato `property name:ID`. Un ejemplo es `name:ID`. El nodo IDs debe ser único en todos los archivos de nodos de la carga actual y anterior. Si se utiliza un espacio de ID, el nodo IDs debe ser único en todos los archivos de nodos que utilizan el mismo espacio de ID en las cargas actuales y anteriores. + **`:LABEL`**: etiqueta del nodo. Cuando se utilizan varios valores de etiqueta para un solo nodo, cada etiqueta debe estar separada por punto y coma (`;`). ### Encabezados de columnas del sistema en archivos de relaciones + **`:ID`**: identificador de la relación. Es obligatorio cuando `userProvidedEdgeIds` es true (el valor predeterminado), pero no es válido cuando `userProvidedEdgeIds` es`false`. La relación IDs debe ser única en todos los archivos de relaciones de las cargas actuales y anteriores. + **`:START_ID`**: (*obligatorio*) el identificador de nodo del nodo desde el que se inicia esta relación. Opcionalmente, se puede asociar un espacio de identificador a la columna del identificador inicial en el formato `:START_ID(ID Space)`. El espacio de identificador asignado al identificador del nodo inicial debe coincidir con el espacio de identificador asignado al nodo en su archivo de nodos. + **`:END_ID`**: (*obligatorio*) el identificador de nodo del nodo en el que termina esta relación. Opcionalmente, se puede asociar un espacio de identificador a la columna del identificador final en el formato `:END_ID(ID Space)`. El espacio de identificador asignado al identificador del nodo final debe coincidir con el espacio de identificador asignado al nodo en su archivo de nodos. + **`:TYPE`**: tipo de la relación. Las relaciones solo pueden tener un tipo. **nota** Consulte [Carga de datos de openCypher](load-api-reference-load.md#load-api-reference-load-parameters-opencypher) para obtener información sobre cómo gestiona el proceso de carga masiva los nodos o relaciones IDs duplicados. ### Encabezados de columnas de propiedades en archivos de carga de datos de openCypher Puede especificar que una columna contenga los valores de una propiedad concreta mediante un encabezado de columna de propiedades con el siguiente formato: ``` propertyname:type ``` No se permiten espacios, comas, retornos de carro ni caracteres de nueva línea en los encabezados de las columnas, por lo que los nombres de las propiedades no pueden incluir estos caracteres. A continuación, se muestra un ejemplo de encabezado de columna para una propiedad denominada `age` del tipo `Int`: ``` age:Int ``` La columna con `age:Int` como encabezado de columna tendría entonces que contener un número entero o un valor vacío en cada fila. ## Tipos de datos en archivos de carga de datos de openCypher de Neptune + **`Bool`** o **`Boolean`**: campo booleano. Los valores permitidos son `true` y `false`. Cualquier valor que no sea `true` se trata como `false`. + **`Byte`**: número entero comprendido en el rango de `-128` a `127`. + **`Short`**: número entero comprendido en el rango de `-32,768` a `32,767`. + **`Int`**: número entero comprendido en el rango de `-2^31` a `2^31 - 1`. + **`Long`**: número entero comprendido en el rango de `-2^63` a `2^63 - 1`. + **`Float`**: número de coma flotante IEEE 754 de 32 bits. Se admiten tanto la notación decimal como la notación científica. `Infinity`, `-Infinity` y `NaN` se reconocen, pero no `INF`. Los valores que tienen demasiados dígitos y no caben se redondean al valor más cercano (un valor intermedio se redondea a 0 para el último dígito restante en el nivel de bits). + **`Double`**: número de coma flotante IEEE 754 de 64 bits. Se admiten tanto la notación decimal como la notación científica. `Infinity`, `-Infinity` y `NaN` se reconocen, pero no `INF`. Los valores que tienen demasiados dígitos y no caben se redondean al valor más cercano (un valor intermedio se redondea a 0 para el último dígito restante en el nivel de bits). + **`String`**: el uso de las comillas es opcional. Los caracteres de coma, nueva línea y retorno de carro se escapan automáticamente si se incluyen en una cadena rodeada de comillas dobles (`"`) como `"Hello, World"`. Puede incluir comillas en una cadena entre comillas usando dos seguidas; por ejemplo `"Hello ""World"""`. + **`DateTime`**: fecha Java en uno de los siguientes formatos ISO-8601: + `yyyy-MM-dd` + `yyyy-MM-ddTHH:mm` + `yyyy-MM-ddTHH:mm:ss` + `yyyy-MM-ddTHH:mm:ssZ` ### Tipos de datos de conversión automática en archivos de carga de datos de openCypher de Neptune Los tipos de datos de conversión automática sirven para cargar tipos de datos que Neptune no admite actualmente de forma nativa. Los datos de estas columnas se almacenan en forma de cadenas, textualmente, sin necesidad de compararlos con los formatos previstos. Se permiten los siguientes tipos de datos de conversión automática: + **`Char`**: campo `Char`. Almacenado como una cadena. + **`Date`**, **`LocalDate`** y **`LocalDateTime`**: consulte [Neo4j Temporal Instants](https://neo4j.com/docs/cypher-manual/current/values-and-types/temporal/#cypher-temporal-instants) para ver una descripción de los tipos `date`, `localdate` y `localdatetime`. Los valores se cargan textualmente como cadenas, sin validación. + **`Duration`**: consulte [Neo4j Duration format](https://neo4j.com/docs/cypher-manual/current/values-and-types/temporal/#cypher-temporal-durations). Los valores se cargan textualmente como cadenas, sin validación. + **Punto**: campo de puntos para almacenar datos espaciales. Consulte [Spatial instants](https://neo4j.com/docs/cypher-manual/current/values-and-types/spatial/#spatial-values-spatial-instants). Los valores se cargan textualmente como cadenas, sin validación. ## Ejemplo del formato de carga de openCypher El siguiente diagrama, tomado del gráfico TinkerPop moderno, muestra un ejemplo de dos nodos y una relación: ![\[Diagrama de dos nodos y una relación entre ellos.\]](http://docs.aws.amazon.com/es_es/neptune/latest/userguide/images/tinkerpop-2-nodes-and-relationship.png) A continuación, se muestra el gráfico en el formato de carga de openCypher normal de Neptune. **Archivo de nodos:** ``` :ID,name:String,age:Int,lang:String,:LABEL v1,"marko",29,,person v2,"lop",,"java",software ``` **Archivo de relaciones:** ``` :ID,:START_ID,:END_ID,:TYPE,weight:Double e1,v1,v2,created,0.4 ``` Como alternativa, puede utilizar los espacios de identificador y el identificador como una propiedad, de la siguiente manera: **Primer archivo de nodo:** ``` name:ID(person),age:Int,lang:String,:LABEL "marko",29,,person ``` **Segundo archivo de nodo:** ``` name:ID(software),age:Int,lang:String,:LABEL "lop",,"java",software ``` **Archivo de relaciones:** ``` :ID,:START_ID(person),:END_ID(software),:TYPE,weight:Double e1,"marko","lop",created,0.4 ``` # Formatos de los datos de carga de RDF Para cargar datos del marco de descripción de recursos (RDF), puede utilizar uno de los formatos estándar siguientes de la forma especificada por el World Wide Web Consortium (W3C): + N-Triples (`ntriples`) de la especificación en [https://www.w3.org/TR/n-triples/](https://www.w3.org/TR/n-triples/) + N-Quads (`nquads`) de la especificación en [https://www.w3.org/TR/n-quads/](https://www.w3.org/TR/n-quads/) + RDF/XML (`rdfxml`) de la especificación en [https://www.w3.org/TR/rdf-syntax-grammar/](https://www.w3.org/TR/rdf-syntax-grammar/) + Turtle (`turtle`) de la especificación en [https://www.w3.org/TR/turtle/](https://www.w3.org/TR/turtle/) **importante** Todos los archivos deben estar codificados en formato UTF-8. Para los datos N-Quads y N-triples que incluyen caracteres Unicode, se admiten las secuencias de escape `\uxxxxx`. Sin embargo, Neptune no admite la normalización. Si hay un valor que requiere normalización, no coincidirá byte-to-byte durante la consulta. Para obtener más información acerca de la normalización, consulte la página [Normalization](https://unicode.org/faq/normalization.html) en [Unicode.org](https://unicode.org). **Siguientes pasos** Ahora que conoce mejor los formatos de carga, consulte [Ejemplo: carga de datos en una instancia de base de datos de Neptune](bulk-load-data.md). # Ejemplo: carga de datos en una instancia de base de datos de Neptune Este ejemplo muestra cómo cargar datos en Amazon Neptune. A menos que se indique lo contrario, debe seguir estos pasos desde una instancia de Amazon Elastic Compute Cloud (Amazon EC2) en la misma instancia de la nube privada virtual (VPC) de Amazon que su instancia de base de datos de Neptune. ## Ejemplo de requisitos previos de carga de datos Antes de comenzar, debe disponer de lo siguiente: + Una instancia de base de datos de Neptune. Para obtener información acerca del inicio de una instancia de base de datos de Neptune, consulte [Creación de un clúster de Amazon Neptune](get-started-create-cluster.md). + Un bucket de Amazon Simple Storage Service (Amazon S3) en el que colocar los datos. Es posible utilizar un bucket existente. Si no tiene un bucket de S3, consulte [Crear un bucket](https://docs.aws.amazon.com/AmazonS3/latest/userguide/CreatingABucket.html) en la *[Guía de introducción de Amazon S3](https://docs.aws.amazon.com/AmazonS3/latest/userguide/)*. + Datos del gráfico que se van a cargar, en uno de los formatos admitidos por el programa de carga de Neptune: Si utiliza Gremlin para consultar el gráfico, Neptune puede cargar datos en formato comma-separated-values (`CSV`), como se describe en. [Formato de datos de carga de Gremlin](bulk-load-tutorial-format-gremlin.md) Si utiliza openCypher para consultar el gráfico, Neptune también puede cargar datos en un formato `CSV` específico de openCypher, como se describe en [Formato de carga para los datos de openCypher](bulk-load-tutorial-format-opencypher.md). Si utiliza SPARQL, Neptune puede cargar los datos en una serie de formatos RDF, tal y como se describe en [Formatos de los datos de carga de RDF](bulk-load-tutorial-format-rdf.md). + Un rol de IAM para que la instancia de base de datos de Neptune asuma que tiene una política de IAM que permite el acceso a los archivos de datos en el bucket de S3. La política debe conceder permisos de lectura y lista. Para obtener información acerca de cómo crear un rol con acceso a Amazon S3 y, después, asociarlo a un clúster de Neptune, consulte [Requisitos previos: rol de IAM y acceso a Amazon S3](bulk-load-tutorial-IAM.md). **nota** La API `Load` de Neptune necesita acceso de lectura solo para los archivos de datos. No es necesario que la política de IAM conceda acceso de escritura o acceso al bucket completo. + Un punto de conexión de VPC de Amazon S3. Para obtener más información, consulte la sección [Creación de un punto de conexión de VPC de Amazon S3](#bulk-load-prereqs-s3). ### Creación de un punto de conexión de VPC de Amazon S3 El programa de carga de Neptune requiere un punto de conexión de VPC para Amazon S3. **Para configurar el acceso a Amazon S3** 1. Inicie sesión en la consola de Amazon VPC Consola de administración de AWS y ábrala en. [https://console.aws.amazon.com/vpc/](https://console.aws.amazon.com/vpc/) 1. En el panel de navegación izquierdo, seleccione **Puntos de conexión**. 1. Seleccione **Crear punto de conexión**. 1. Elija el **Service Name (Nombre del servicio)** `com.amazonaws.region.s3`. **nota** Si la región indicada es incorrecta, asegúrese de que la región de la consola es correcta. 1. Elija la VPC que contiene la instancia de base de datos de Neptune. 1. Seleccione la casilla de verificación situada junto a las tablas de ruteo asociadas a las subredes relacionadas con el clúster. Si solo tiene una tabla de ruteo, debe seleccionar esa casilla. 1. Seleccione **Crear punto de conexión**. Para obtener más información acerca de la creación del punto de conexión, consulte [Puntos de conexión de la VPC](https://docs.aws.amazon.com/vpc/latest/userguide/vpc-endpoints.html#create-vpc-endpoint) en la *Guía del usuario de Amazon VPC*. Para obtener información acerca de las limitaciones de los puntos de conexión de VPC, consulte [VPC Endpoints for Amazon S3](https://docs.aws.amazon.com/vpc/latest/userguide/vpc-endpoints-s3.html). **Para cargar datos en una instancia de base de datos de Neptune** 1. Copie los archivos de datos en un bucket de Amazon S3. El bucket de S3 debe estar en la misma AWS región que el clúster que carga los datos. Puede usar el siguiente AWS CLI comando para copiar los archivos al bucket. **nota** No es necesario ejecutar este comando desde la instancia de Amazon EC2. ``` aws s3 cp data-file-name s3://bucket-name/object-key-name ``` **nota** En Amazon S3, un **nombre de una clave de objeto** es la ruta completa de un archivo, incluido el nombre de este. *Ejemplo:* en el comando `aws s3 cp datafile.txt s3://examplebucket/mydirectory/datafile.txt`, el nombre de la clave de objeto es **`mydirectory/datafile.txt`**. Como alternativa, puede utilizar el Consola de administración de AWS para cargar archivos en el bucket de S3. Abra la consola Amazon S3 en [https://console.aws.amazon.com/s3/](https://console.aws.amazon.com/s3/)y elija un bucket. En la esquina superior izquierda, elija **Upload (Cargar)** para cargar los archivos. 1. Desde una ventana de la línea de comandos, introduzca lo siguiente para ejecutar el programa de carga de Neptune con los valores correctos para su punto de conexión, la ruta de Amazon S3, el formato y el ARN del rol de IAM. El parámetro `format` puede tener cualquiera de los siguientes valores: `csv` para Gremlin, `opencypher` para openCypher o `ntriples`, `nquads`, `turtle` y `rdfxml` para RDF. Para obtener información acerca del resto de parámetros, consulte [Comando del programa de carga de Neptune](load-api-reference-load.md). Para obtener información acerca de cómo encontrar el nombre de host de la instancia de base de datos de Neptune, consulte la sección [Conexión a los puntos de conexión de Amazon Neptune](feature-overview-endpoints.md). El parámetro de región debe coincidir con la región del clúster y del bucket de S3. Amazon Neptune está disponible en las siguientes regiones: AWS + Este de EE. UU. (Norte de Virginia): `us-east-1` + Este de EE. UU. (Ohio): `us-east-2` + Oeste de EE. UU. (Norte de California): `us-west-1` + Oeste de EE. UU. (Oregón): `us-west-2` + Canadá (centro): `ca-central-1` + Canadá oeste (Calgary): `ca-west-1` + América del Sur (São Paulo): `sa-east-1` + Europa (Estocolmo): `eu-north-1` + Europa (España): `eu-south-2` + Europa (Irlanda): `eu-west-1` + Europa (Londres): `eu-west-2` + Europa (París): `eu-west-3` + Europa (Fráncfort): `eu-central-1` + Medio Oriente (Baréin): `me-south-1` + Medio Oriente (EAU): `me-central-1` + Israel (Tel Aviv):   `il-central-1` + África (Ciudad del Cabo): `af-south-1` + Asia Pacífico (Hong Kong): `ap-east-1` + Asia-Pacífico (Tokio): `ap-northeast-1` + Asia-Pacífico (Seúl): `ap-northeast-2` + Asia-Pacífico (Osaka): `ap-northeast-3` + Asia-Pacífico (Singapur): `ap-southeast-1` + Asia-Pacífico (Sídney): `ap-southeast-2` + Asia-Pacífico (Yakarta): `ap-southeast-3` + Asia Pacífico (Melbourne): `ap-southeast-4` + Asia Pacífico (Malasia): `ap-southeast-5` + Asia-Pacífico (Bombay): `ap-south-1` + Asia Pacífico (Hyderabad): `ap-south-2` + China (Pekín): `cn-north-1` + China (Ningxia): `cn-northwest-1` + AWS GovCloud (EEUU-Oeste): `us-gov-west-1` + AWS GovCloud (EEUU-Este): `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"] }' ``` Para obtener información acerca de cómo crear y asociar un rol de IAM a un clúster de Neptune, consulte [Requisitos previos: rol de IAM y acceso a Amazon S3](bulk-load-tutorial-IAM.md). **nota** Consulte [Parámetros de solicitudes del programa de carga de Neptune](load-api-reference-load.md#load-api-reference-load-parameters) para obtener información detallada sobre los parámetros de solicitud de carga. En resumen: El parámetro `source` acepta un URI de Amazon S3 que apunta a un archivo único o a una carpeta. Si especifica una carpeta, Neptune carga todos los archivos de datos en esta. La carpeta puede contener varios archivos de vértice y varios archivos de borde. El URI puede tener cualquiera de los siguientes formatos: `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` Este parámetro `format` puede ser uno de los siguientes: Formato CSV de Gremlin (`csv`) para gráfico de propiedades de Gremlin Formato CSV de openCypher (`opencypher`) para gráficos de propiedades de openCypher Formato N -Triples (`ntriples`) para RDF/SPARQL Formato N-Quads (`nquads`) para RDF/SPARQL Formato RDF/XML (`rdfxml`) para RDF/SPARQL Formato Turtle (`turtle`) para RDF/SPARQL El parámetro opcional `parallelism` le permite restringir el número de subprocesos utilizados en el proceso de carga masiva. Se puede establecer en `LOW`, `MEDIUM`, `HIGH` o `OVERSUBSCRIBE`. Cuando `updateSingleCardinalityProperties` se establece en `"FALSE"`, el cargador devuelve un error si se proporciona más de un valor en un archivo de origen que se está cargando para una propiedad de borde o de vértice de cardinalidad única. Si `queueRequest` se establece en `"TRUE"`, la solicitud de carga se colocará en una cola si ya se está ejecutando un trabajo de carga. El parámetro `dependencies` hace que la ejecución de la solicitud de carga dependa de la finalización correcta de uno o más trabajos de carga que ya se han colocado en la cola. 1. El programa de carga de Neptune devuelve un `id` de tarea que le permite comprobar el estado o cancelar el proceso de carga; por ejemplo: ``` { "status" : "200 OK", "payload" : { "loadId" : "ef478d76-d9da-4d94-8ff1-08d9d4863aa5" } } ``` 1. Escriba lo siguiente para obtener el estado de la carga con el `loadId` del **paso 3**: ``` curl -G 'https://your-neptune-endpoint:port/loader/ef478d76-d9da-4d94-8ff1-08d9d4863aa5' ``` Si el estado de la carga muestra un error, puede solicitar un estado más detallado y una lista de los errores. Para obtener más información y ejemplos, consulta [API Neptune Loader Get-Status](load-api-reference-status.md). 1. (Opcional) Cancele la tarea `Load`. Escriba lo siguiente `Delete` la tarea del programa de carga con el `id` de tarea del **paso 3**: ``` curl -X DELETE 'https://your-neptune-endpoint:port/loader/ef478d76-d9da-4d94-8ff1-08d9d4863aa5' ``` El comando `DELETE` devuelve el código HTTP `200 OK` si la cancelación se realiza correctamente. Los datos de los archivos de la tarea de carga que han terminado de cargarse no se revierten, Los datos permanecen en la instancia de base de datos de Neptune. # Optimización de una carga masiva de Amazon Neptune Utilice las siguientes estrategias para reducir al mínimo el tiempo de carga de una carga masiva de Neptune: + **Limpie sus datos:** + Asegúrese de convertir los datos a un [formato de datos compatible](bulk-load-tutorial-format.md) antes de cargarlos. + Elimine cualquier duplicado o error conocido. + Reduzca el número de predicados únicos (por ejemplo, propiedades de bordes y vértices) en la medida de lo posible. + **Optimice sus archivos:** + Si carga archivos grandes, como archivos CSV, desde un bucket de Amazon S3, el programa de carga administra automáticamente la simultaneidad analizándolos en fragmentos que puede cargar en paralelo. El uso de una gran cantidad de archivos pequeños puede ralentizar este proceso. + Si carga varios archivos desde un prefijo de Amazon S3, el cargador carga automáticamente primero los archivos de vértices y, después, los archivos de bordes. Sin embargo, si sabe que solo va a cargar archivos de borde, puede establecer `edgeOnlyLoad` en `TRUE` para omitir la primera trasmisión en la que se analizan todos los archivos para determinar su contenido (vértices o bordes), de modo que los archivos de vértices encontrados se carguen antes que los archivos de borde. Esto puede acelerar considerablemente el tiempo de carga, especialmente cuando hay muchos archivos de borde. En caso de que también haya algunos archivos de vértices en el mismo prefijo (parámetro `source`) de Amazon S3, se cargarán, pero sin ninguna garantía de orden en relación con otros archivos. Además, si algunos vértices `from` o `to` no se incluyen en la base de datos, la inserción de bordes puede informar de errores con el mensaje `FROM_OR_TO_VERTEX_ARE_MISSING`. Como práctica recomendada, coloque los nodos y los bordes en prefijos de Amazon S3 independientes. + **Compruebe la configuración del programa de carga:** + Si no necesita realizar ninguna otra operación durante la carga, utilice el parámetro [`OVERSUBSCRIBE``parallelism`](load-api-reference-load.md#load-api-reference-load-syntax). Esta configuración de parámetros hace que el programa de carga masiva utilice todos los recursos de CPU disponibles cuando se ejecuta. Por lo general, se necesita entre un 60 y un 70% de la capacidad de la CPU para mantener la operación funcionando tan rápido como lo permitan las restricciones. I/O **nota** Cuando `parallelism` se establece en `OVERSUBSCRIBE` o `HIGH` (configuración predeterminada), al cargar datos de openCypher, existe el riesgo de que los subprocesos se encuentren en una condición de carrera y se bloqueen, lo que provoque un error `LOAD_DATA_DEADLOCK`. En este caso, ajuste `parallelism` a un valor inferior y vuelva a intentar realizar la carga. + Si su trabajo de carga incluye varias solicitudes de carga, utilice el parámetro `queueRequest`. Si configura `queueRequest` en `TRUE`, Neptune pone en cola sus solicitudes para que no tenga que esperar a que termine una para emitir otra. + Si las solicitudes de carga están en cola, puede configurar niveles de dependencia mediante el parámetro `dependencies`, de modo que si falla un trabajo, los trabajos dependientes también fallan. Esto puede evitar incoherencias en los datos cargados. + Si un trabajo de carga va a implicar la actualización de valores cargados anteriormente, asegúrese de establecer el parámetro `updateSingleCardinalityProperties` en `TRUE`. Si no lo hace, el programa de carga considerará un error el intento de actualizar un valor de cardinalidad única existente. En el caso de los datos de Gremlin, la cardinalidad también se especifica en los encabezados de las columnas de propiedades (consulte [Encabezados de columnas de propiedades](bulk-load-tutorial-format-gremlin.md#bulk-load-tutorial-format-gremlin-propheaders)). **nota** El parámetro `updateSingleCardinalityProperties` no está disponible para los datos del marco de descripción de recursos (RDF). + Puede usar el parámetro `failOnError` para determinar si las operaciones de carga masiva deben fallar o continuar cuando se detecta un error. Además, puede usar el parámetro `mode` para asegurarse de que un trabajo de carga reanude la carga desde el punto en el que falló un trabajo anterior, en lugar de volver a cargar los datos que ya se habían cargado. + **Escalamiento vertical**: defina la instancia del escritor del clúster de base de datos en el tamaño máximo antes de cargarla de forma masiva. Tenga en cuenta que, si lo hace, también debe escalar verticalmente las instancias de réplica y lectura del clúster de base de datos o eliminarlas hasta que haya terminado de cargar los datos. Cuando se complete la carga masiva, asegúrese de volver a reducir verticalmente la instancia del escritor. **importante** Si experimenta un ciclo de reinicios repetidos de réplicas de lectura debido a un retardo en la replicación durante una carga masiva, es probable que sus réplicas no puedan mantener el ritmo del escritor en el clúster de base de datos. Escale los lectores a un tamaño superior al del escritor o quítelos temporalmente durante la carga masiva y vuelva a crearlos una vez finalizada la operación. Consulte [Parámetros de la solicitud](load-api-reference-load.md#load-api-reference-load-parameters) para obtener más información sobre cómo configurar los parámetros de las solicitudes de carga. # Referencia del programa de carga de Neptune En esta sección se describen las que están disponibles `Loader` APIs para Amazon Neptune en el punto de enlace HTTP de una instancia de base de datos de Neptune. **nota** Consulte [Mensajes de errores y fuente del programa de carga de Neptune](loader-message.md) para obtener una lista de los mensajes de error y de fuentes devueltos por el programa de carga en caso de errores. **Contents** + [Comando del programa de carga de Neptune](load-api-reference-load.md) + [Sintaxis de las solicitudes del programa de carga de Neptune](load-api-reference-load.md#load-api-reference-load-syntax) + [Parámetros de solicitudes del programa de carga de Neptune](load-api-reference-load.md#load-api-reference-load-parameters) + [Consideraciones especiales para cargar datos de openCypher](load-api-reference-load.md#load-api-reference-load-parameters-opencypher) + [Sintaxis de respuestas del programa de carga de Neptune](load-api-reference-load.md#load-api-reference-load-return) + [Errores del programa de carga de Neptune](load-api-reference-load-errors.md) + [Ejemplos del programa de carga de Neptune](load-api-reference-load-examples.md) + [API Neptune Loader Get-Status](load-api-reference-status.md) + [Solicitudes de Neptune Loader Get-Status](load-api-reference-status-requests.md) + [Sintaxis de Get-Status solicitud de cargador](load-api-reference-status-requests.md#load-api-reference-status-request-syntax) + [Parámetros de solicitud de Neptune Loader Get-Status](load-api-reference-status-requests.md#load-api-reference-status-parameters) + [Respuestas de Neptune Loader Get-Status](load-api-reference-status-response.md) + [Diseño JSON de Neptune Loader Get-Status Response](load-api-reference-status-response.md#load-api-reference-status-response-layout) + [Neptune Loader Get-Status `overallStatus` y `failedFeeds` objetos de respuesta](load-api-reference-status-response.md#load-api-reference-status-response-objects) + [Objeto de respuesta Neptune Loader Get-Status `errors`](load-api-reference-status-response.md#load-api-reference-status-errors) + [Objeto de respuesta Neptune Loader Get-Status `errorLogs`](load-api-reference-status-response.md#load-api-reference-error-logs) + [Ejemplos de Neptune Loader Get-Status](load-api-reference-status-examples.md) + [Ejemplo de solicitud del estado de carga](load-api-reference-status-examples.md#load-api-reference-status-examples-status-request) + [Ejemplo de solicitud de loadIds](load-api-reference-status-examples.md#load-api-reference-status-examples-loadId-request) + [Ejemplo de solicitud del estado detallado](load-api-reference-status-examples.md#load-api-reference-status-examples-details-request) + [Ejemplos de Neptune Loader Get-Status `errorLogs`](load-api-reference-error-logs-examples.md) + [Ejemplo de respuesta de estado detallada cuando se produjeron errores](load-api-reference-error-logs-examples.md#load-api-reference-status-examples-details-request-errors) + [Ejemplo de un error `Data prefetch task interrupted`](load-api-reference-error-logs-examples.md#load-api-reference-status-examples-task-interrupted) + [Cancelación de trabajo del programa de carga de Neptune](load-api-reference-cancel.md) + [Sintaxis de solicitud de cancelación de trabajo](load-api-reference-cancel.md#load-api-reference-cancel-syntax) + [Parámetros de solicitud de cancelación de tarea](load-api-reference-cancel.md#load-api-reference-cancel-parameters) + [Sintaxis de respuesta de cancelación de trabajo](load-api-reference-cancel.md#load-api-reference-cancel-parameters-response) + [Errores de cancelación de tarea](load-api-reference-cancel.md#load-api-reference-cancel-parameters-errors) + [Mensajes de error de cancelación de tarea](load-api-reference-cancel.md#load-api-reference-cancel-parameters-errors-messages) + [Ejemplos de cancelación de tarea](load-api-reference-cancel.md#load-api-reference-cancel-examples) # Comando del programa de carga de Neptune Carga datos desde un bucket de Amazon S3 en una instancia de base de datos de Neptune. Para cargar los datos, debe enviar una solicitud HTTP `POST` al punto de enlace `https://your-neptune-endpoint:port/loader`. Los parámetros de la solicitud `loader` se pueden enviar en el cuerpo de `POST` o como parámetros codificados en URL. **importante** El tipo MIME debe ser `application/json`. El bucket de Amazon S3 debe estar en la misma AWS región que el clúster. **nota** Puede cargar datos cifrados desde Amazon S3 si se cifran mediante el modo `SSE-S3` de Amazon S3. En ese caso, Neptune es capaz de suplantar sus credenciales y emitir llamadas de `s3:getObject` en su nombre. También puede cargar datos cifrados desde Amazon S3 que se hayan cifrado mediante el modo `SSE-KMS`, siempre que el rol de IAM incluya los permisos necesarios para obtener acceso a AWS KMS. Sin AWS KMS los permisos adecuados, se produce un error en la operación de carga masiva y devuelve una `LOAD_FAILED` respuesta. Actualmente Neptune no admite la carga de datos cifrados de Amazon S3 con el modo `SSE-C`. No tiene que esperar a que finalice un trabajo de carga para iniciar otro. Neptune puede poner en cola hasta 64 solicitudes de trabajo a la vez, siempre que todos sus parámetros `queueRequest` estén configurados como `"TRUE"`. El orden de espera de los trabajos será first-in-first-out (FIFO). Por otro lado, si no desea que un trabajo de carga esté en cola, puede establecer su parámetro `queueRequest` en `"FALSE"` (valor predeterminado), de modo que se producirá un error en el trabajo de carga si otro ya está en curso. Puede utilizar el parámetro `dependencies` para poner en cola un trabajo que solo debe ejecutarse después de que los trabajos anteriores especificados en la cola se hayan completado correctamente. Si lo hace y se produce un error en cualquiera de esos trabajos especificados, su trabajo no se ejecutará y el estado se establecerá en `LOAD_FAILED_BECAUSE_DEPENDENCY_NOT_SATISFIED`. ## Sintaxis de las solicitudes del programa de carga de 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 Sintaxis** Para `edgeOnlyLoad`, la sintaxis sería: ``` { "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"] } ``` ## Parámetros de solicitudes del programa de carga de Neptune + **`source`**: un URI de Amazon S3. El parámetro `SOURCE` acepta un URI de Amazon S3 que identifica un solo archivo, varios archivos, una carpeta o varias carpetas. Neptune carga todos los archivos de datos de cualquier carpeta especificada. El URI puede tener cualquiera de los siguientes formatos: + `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` El `object-key-name` elemento del URI equivale al parámetro de [prefijo](https://docs.aws.amazon.com/AmazonS3/latest/API/API_ListObjects.html#API_ListObjects_RequestParameters) en una llamada a la [ListObjects](https://docs.aws.amazon.com/AmazonS3/latest/API/API_ListObjects.html)API de Amazon S3. Identifica todos los objetos del bucket de Amazon S3 especificado cuyos nombres comienzan con ese prefijo. Puede ser un único archivo o carpeta o varias and/or carpetas de archivos. La carpeta o carpetas especificadas pueden contener varios archivos de vértice y varios archivos de borde. Por ejemplo, si tuviera la siguiente estructura de carpetas y archivos en un bucket de Amazon S3 llamado `bucket-name`: ``` s3://bucket-name/a/bc s3://bucket-name/ab/c s3://bucket-name/ade s3://bucket-name/bcd ``` Si el parámetro de origen se especifica como `s3://bucket-name/a`, se cargarán los tres primeros archivos. ``` s3://bucket-name/a/bc s3://bucket-name/ab/c s3://bucket-name/ade ``` + **`format`**: el formato de los datos. Para obtener más información acerca de los formatos de los datos para el comando `Loader` de Neptune, consulte [Uso del programa de carga masiva de Amazon Neptune para adquirir datos](bulk-load.md). **Valores permitidos** + **`csv`** para el [formato de datos CSV de Gremlin](bulk-load-tutorial-format-gremlin.md). + **`opencypher`** para el [formato de datos CSV de openCypher](bulk-load-tutorial-format-opencypher.md). + **`ntriples`** para el [formato de datos RDF N-Triples](https://www.w3.org/TR/n-triples/). + **`nquads`** para el [formato de datos RDF N-Quads](https://www.w3.org/TR/n-quads/). + **`rdfxml`** para el [formato de datos RDF RDF\$1XML](https://www.w3.org/TR/rdf-syntax-grammar/). + **`turtle`** para el [formato de datos RDF de Turtle](https://www.w3.org/TR/turtle/). + **`iamRoleArn`**: nombre de recurso de Amazon (ARN) para que la instancia de base de datos de Neptune asuma el rol de IAM para obtener acceso al bucket de S3. Para obtener información acerca de cómo crear un rol con acceso a Amazon S3 y, después, asociarlo a un clúster de Neptune, consulte [Requisitos previos: rol de IAM y acceso a Amazon S3](bulk-load-tutorial-IAM.md). A partir de la [versión 1.2.1.0.R3 del motor](engine-releases-1.2.1.0.R3.md), también puede encadenar varias funciones de IAM si la instancia de base de datos Neptune y el bucket de Amazon S3 están ubicados en cuentas diferentes. AWS En este caso, `iamRoleArn` contiene una lista de funciones separadas por comas, tal y como se describe en. ARNs [Encadenamiento de roles de IAM en Amazon Neptune](bulk-load-tutorial-chain-roles.md) Por ejemplo: ``` 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`**— El `region` parámetro debe coincidir con la AWS región del clúster y el bucket de S3. Amazon Neptune está disponible en las siguientes regiones de : + Este de EE. UU. (Norte de Virginia): `us-east-1` + Este de EE. UU. (Ohio): `us-east-2` + Oeste de EE. UU. (Norte de California): `us-west-1` + Oeste de EE. UU. (Oregón): `us-west-2` + Canadá (centro): `ca-central-1` + Canadá oeste (Calgary): `ca-west-1` + América del Sur (São Paulo): `sa-east-1` + Europa (Estocolmo): `eu-north-1` + Europa (España): `eu-south-2` + Europa (Irlanda): `eu-west-1` + Europa (Londres): `eu-west-2` + Europa (París): `eu-west-3` + Europa (Fráncfort): `eu-central-1` + Medio Oriente (Baréin): `me-south-1` + Medio Oriente (EAU): `me-central-1` + Israel (Tel Aviv):   `il-central-1` + África (Ciudad del Cabo): `af-south-1` + Asia Pacífico (Hong Kong): `ap-east-1` + Asia-Pacífico (Tokio): `ap-northeast-1` + Asia-Pacífico (Seúl): `ap-northeast-2` + Asia-Pacífico (Osaka): `ap-northeast-3` + Asia-Pacífico (Singapur): `ap-southeast-1` + Asia-Pacífico (Sídney): `ap-southeast-2` + Asia-Pacífico (Yakarta): `ap-southeast-3` + Asia Pacífico (Melbourne): `ap-southeast-4` + Asia Pacífico (Malasia): `ap-southeast-5` + Asia-Pacífico (Bombay): `ap-south-1` + Asia Pacífico (Hyderabad): `ap-south-2` + China (Pekín): `cn-north-1` + China (Ningxia): `cn-northwest-1` + AWS GovCloud (EEUU-Oeste): `us-gov-west-1` + AWS GovCloud (EEUU-Este): `us-gov-east-1` + **`mode`**: el modo de trabajo de carga. *Valores permitidos*: `RESUME`, `NEW`, `AUTO`. *Valor predeterminado:* `AUTO` **** + `RESUME`: en el modo RESUME, el programa de carga busca una carga anterior de este origen y, si encuentra una, reanuda ese trabajo de carga. Si no se encuentra ningún trabajo de carga anterior, el programa de carga se detiene. El programa de carga evita la recarga de archivos cargados correctamente en un trabajo anterior. Solo intenta procesar los archivos con errores. Si ha eliminado los datos cargados anteriormente del clúster de Neptune, esos datos no se vuelven a cargar en este modo. Si un trabajo de carga anterior ha cargado todos los archivos del mismo origen correctamente, no se vuelve a cargar nada y el programa de carga devuelve una operación correcta. + `NEW`: en el modo NEW, crea una solicitud de carga, independientemente de cualquier carga anterior. Puede utilizar este modo para volver a cargar todos los datos de un origen después de descartar los datos cargados anteriormente desde el clúster de Neptune o bien para cargar nuevos datos disponibles en el mismo origen. + `AUTO`: en el modo AUTO, el programa de carga busca un trabajo de carga anterior del mismo origen y, si encuentra uno, lo reanuda, igual que en el modo `RESUME`. Si el programa de carga no encuentra un trabajo de carga anterior del mismo origen, carga todos los datos del origen, al igual que en el modo `NEW`. + **`edgeOnlyLoad`**: un indicador que controla el orden de procesamiento de los archivos durante la carga masiva. *Valores permitidos*: `"TRUE"` y `"FALSE"`. *Valor predeterminado*: `"FALSE"`. Cuando este parámetro se establece en “FALSE”, el cargador carga automáticamente primero los archivos de vértices y, después, los archivos de bordes. Para ello, primero analiza todos los archivos para determinar su contenido (vértices o bordes). Cuando este parámetro se establece en “TRUE”, el programa de carga omite la fase de análisis inicial y carga inmediatamente todos los archivos en el orden en que aparecen. Para obtener más información, consulte [optimización de la carga masiva](https://docs.aws.amazon.com//neptune/latest/userguide/bulk-load-optimize.html). + **`failOnError`**: un indicador para activar la detención total al encontrar un error. *Valores permitidos*: `"TRUE"` y `"FALSE"`. *Valor predeterminado*: `"TRUE"`. Cuando este parámetro se establece en `"FALSE"`, el programa de carga intenta cargar todos los datos de la ubicación especificada, omitiendo cualquier entrada con errores. Cuando este parámetro se establece en `"TRUE"`, el programa de carga se detiene en cuanto encuentra un error. Los datos cargados hasta ese momento persisten. + **`parallelism`**: es un parámetro opcional que se puede establecer para reducir el número de subprocesos utilizados por el proceso de carga masiva. *Valores permitidos*: + `LOW`— El número de hilos utilizados es el número de v disponibles CPUs dividido entre 8. + `MEDIUM`— El número de hilos utilizados es el número de v disponibles CPUs dividido entre 2. + `HIGH`— El número de hilos utilizados es el mismo que el número de v disponiblesCPUs. + `OVERSUBSCRIBE`— El número de hilos utilizados es el número de v disponibles CPUs multiplicado por 2. Si se utiliza este valor, el programa de carga masiva absorbe todos los recursos disponibles. Sin embargo, esto no significa que el ajuste de `OVERSUBSCRIBE` dé como resultado un uso del 100 % de la CPU. Como la operación de carga es I/O limitada, la máxima utilización de la CPU que cabe esperar se sitúa entre el 60 y el 70%. *Valor predeterminado:* `HIGH` En ocasiones, este ajuste de `parallelism` puede provocar un bloqueo entre los subprocesos al cargar datos de openCypher. Cuando esto ocurre, Neptune devuelve el error `LOAD_DATA_DEADLOCK`. Por lo general, puede solucionar el problema configurando `parallelism` en un ajuste inferior y volviendo a intentar ejecutar el comando de carga. + **`parserConfiguration`**: objeto opcional con valores de configuración de analizador adicionales. Cada uno de los parámetros secundarios también es opcional: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/neptune/latest/userguide/load-api-reference-load.html) Para obtener más información, consulte [Gráfico predeterminado SPARQL y gráficos con nombre](feature-sparql-compliance.md#sparql-default-graph). + **`updateSingleCardinalityProperties`**: es un parámetro opcional que controla cómo el programa de carga masiva trata un nuevo valor para las propiedades de vértice o borde de cardinalidad única. Esto no se admite para cargar datos de openCypher (consulte [Carga de datos de openCypher](#load-api-reference-load-parameters-opencypher)). *Valores permitidos*: `"TRUE"` y `"FALSE"`. *Valor predeterminado*: `"FALSE"`. De forma predeterminada, o cuando `updateSingleCardinalityProperties` está configurado explícitamente en `"FALSE"`, el programa de carga trata un nuevo valor como un error, porque infringe la cardinalidad única. Por el contrario, cuando `updateSingleCardinalityProperties` está configurado en `"TRUE"`, el programa de carga en bloque reemplaza el valor existente por el nuevo. Si se proporcionan varios valores de propiedades de vértices de borde o de cardinalidad única en los archivos origen que se están cargando, el valor final al terminar la carga masiva podría ser cualquiera de esos nuevos valores. El programa de carga solo garantiza que el valor existente se ha reemplazado por uno de los nuevos. + **`queueRequest`**: es un parámetro de indicador opcional que indica si la solicitud de carga se puede poner en cola o no. No tiene que esperar a que se complete un trabajo de carga antes de emitir el siguiente, porque Neptune puede poner en cola hasta 64 trabajos a la vez, siempre que sus parámetros `queueRequest` estén configurados en `"TRUE"`. El orden de espera de los trabajos será first-in-first-out (FIFO). Si el parámetro `queueRequest` se omite o se establece en `"FALSE"`, se producirá un error en la solicitud de carga si ya se está ejecutando otro trabajo de carga. *Valores permitidos*: `"TRUE"` y `"FALSE"`. *Valor predeterminado*: `"FALSE"`. + **`dependencies`**: se trata de un parámetro opcional que puede supeditar una solicitud de carga en cola a la finalización satisfactoria de uno o más trabajos anteriores de la cola. Neptune puede poner en cola hasta 64 solicitudes de carga a la vez, si sus parámetros `queueRequest` están configurados en `"TRUE"`. El parámetro `dependencies` le permite hacer que la ejecución de dicha solicitud en cola dependa de la finalización correcta de una o más solicitudes anteriores especificadas en la cola. Por ejemplo, si las cargas `Job-A` y `Job-B` son independientes entre sí, pero la carga `Job-C` necesita `Job-A` y `Job-B` debe terminar antes de que comience, proceda de la siguiente manera: 1. Envíe `load-job-A` y `load-job-B` uno tras otro en cualquier orden, y guarde sus identificadores de carga. 1. Envíe `load-job-C` con los identificadores de carga de los dos trabajos en su campo `dependencies`: ``` "dependencies" : ["job_A_load_id", "job_B_load_id"] ``` Debido al parámetro `dependencies`, el programa de carga en bloque no iniciará `Job-C` hasta que `Job-A` y `Job-B` se hayan completado correctamente. Si se produce un error en alguno de ellos, Job-C no se ejecutará y su estado se establecerá en `LOAD_FAILED_BECAUSE_DEPENDENCY_NOT_SATISFIED`. Puede configurar varios niveles de dependencia de esta manera, de modo que el error de un trabajo provoque la cancelación de todas las solicitudes que dependen directa o indirectamente de él. + **`userProvidedEdgeIds`**— Este parámetro solo es necesario cuando se cargan datos de OpenCypher que contienen relaciones. IDs Debe incluirse y configurarse `True` cuando la relación de OpenCypher IDs se indique explícitamente en los datos de carga (recomendado). Si `userProvidedEdgeIds` está ausente o se establece en `True`, debe haber una columna `:ID` en todos los archivos de relaciones de la carga. Cuando `userProvidedEdgeIds` está presente y se establece en `False`, los archivos de relaciones de la carga **no deben** contener ninguna columna `:ID`. En su lugar, el programa de carga de Neptune genera automáticamente un identificador para cada relación. Resulta útil proporcionar la relación de IDs forma explícita para que el cargador pueda reanudar la carga una vez que se haya corregido un error en los datos del CSV, sin tener que volver a cargar ninguna relación que ya se haya cargado. Si la relación IDs no se ha asignado explícitamente, el cargador no puede reanudar una carga fallida si se ha tenido que corregir algún archivo de relaciones y, en su lugar, debe volver a cargar todas las relaciones. + `accessKey`: **[en desuso]** un identificador de clave de acceso de un rol de IAM con acceso a los archivos de datos y al bucket de S3. En su lugar, se recomienda el parámetro `iamRoleArn`. Para obtener información acerca de cómo crear un rol con acceso a Amazon S3 y, después, asociarlo a un clúster de Neptune, consulte [Requisitos previos: rol de IAM y acceso a Amazon S3](bulk-load-tutorial-IAM.md). Para obtener más información, consulte [Claves de acceso (ID de clave de acceso y clave de acceso secreta)](https://docs.aws.amazon.com/general/latest/gr/aws-sec-cred-types.html#access-keys-and-secret-access-keys). + `secretKey`: **[en desuso]** en su lugar, se recomienda el parámetro `iamRoleArn`. Para obtener información acerca de cómo crear un rol con acceso a Amazon S3 y, después, asociarlo a un clúster de Neptune, consulte [Requisitos previos: rol de IAM y acceso a Amazon S3](bulk-load-tutorial-IAM.md). Para obtener más información, consulte [Claves de acceso (ID de clave de acceso y clave de acceso secreta)](https://docs.aws.amazon.com/general/latest/gr/aws-sec-cred-types.html#access-keys-and-secret-access-keys). ### Consideraciones especiales para cargar datos de openCypher + Al cargar datos de openCypher en formato CSV, el parámetro de formato debe estar establecido en `opencypher`. + El parámetro `updateSingleCardinalityProperties` no es compatible con las cargas de openCypher, porque todas las propiedades de openCypher tienen una cardinalidad única. El formato de carga de openCypher no admite matrices y, si un valor de identificador aparece más de una vez, se trata como un duplicado o un error de inserción (véase más abajo). + El programa de carga de Neptune gestiona los duplicados que encuentra en los datos de openCypher de la siguiente manera: + Si el programa de carga encuentra varias filas con el mismo identificador de nodo, se fusionan según la siguiente regla: + Todas las etiquetas de las filas se añaden al nodo. + Para cada propiedad, solo se carga uno de los valores de la propiedad. La selección del que se va a cargar es no determinista. + Si el programa de carga encuentra varias filas con el mismo identificador de relación, solo se carga una de ellas. La selección del que se va a cargar es no determinista. + El programa de carga nunca actualiza los valores de las propiedades de un nodo o relación existente en la base de datos si encuentra datos de carga con el identificador del nodo o la relación existente. Sin embargo, carga etiquetas y propiedades de los nodos que no están presentes en el nodo o la relación existentes. + Aunque no es necesario asignar IDs a las relaciones, suele ser una buena idea (consulte el `userProvidedEdgeIds` parámetro anterior). Sin una relación explícita IDs, el cargador debe volver a cargar todas las relaciones en caso de que se produzca un error en un archivo de relaciones, en lugar de reanudar la carga desde donde se produjo el error. Además, si los datos de carga no contienen una relación explícita IDs, el cargador no tiene forma de detectar las relaciones duplicadas. A continuación se ofrece un ejemplo de un comando de carga de 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 respuesta del programa de carga es la misma que la normal. Por ejemplo: ``` { "status" : "200 OK", "payload" : { "loadId" : "guid_as_string" } } ``` ## Sintaxis de respuestas del programa de carga de Neptune ``` { "status" : "200 OK", "payload" : { "loadId" : "guid_as_string" } } ``` **200 OK** Una tarea de carga que se inició correctamente devuelve el código `200`. # Errores del programa de carga de Neptune Si se produce un error, se devuelve un objeto JSON en el elemento `BODY` de la respuesta. El objeto `message` contiene una descripción del error. **Categorías de errores** + `Error 400`: los errores de sintaxis devuelven un error de solicitud incorrecta HTTP `400`. El mensaje describe el error. + `Error 500`: una solicitud válida que no se puede procesar devuelve un error interno del servidor HTTP `500`. El mensaje describe el error. A continuación se muestran los posibles mensajes de error del programa de carga con la descripción correspondiente. **Mensajes de error del programa de carga** + `Couldn't find the AWS credential for iam_role_arn` (HTTP 400) No se encontraron las credenciales. Compruebe las credenciales suministradas con la consola o el AWS CLI resultado de IAM. Asegúrese de haber añadido el rol de IAM especificado en `iamRoleArn` al clúster. + `S3 bucket not found for source` (HTTP 400) El bucket de S3 no existe. Compruebe el nombre del bucket. + `The source source-uri does not exist/not reachable` (HTTP 400) No se encontraron archivos coincidentes en el bucket de S3. + `Unable to connect to S3 endpoint. Provided source = source-uri and region = aws-region` (HTTP 500) No es posible conectarse a Amazon S3. La región debe coincidir con la región del clúster. Asegúrese de que tiene un punto de enlace de la VPC. Para obtener información acerca de cómo crear un punto de enlace de la VPC, consulte [Creación de un punto de conexión de VPC de Amazon S3](bulk-load-data.md#bulk-load-prereqs-s3). + `Bucket is not in provided Region (aws-region)` (HTTP 400) El bucket debe estar en la misma AWS región que la instancia de base de datos de Neptune. + `Unable to perform S3 list operation` (HTTP 400) La función o el usuario de IAM que se ha proporcionado no tiene permisos `List` en el bucket o en la carpeta. Compruebe la política o la lista de control de acceso (ACL) en el bucket. + `Start new load operation not permitted on a read replica instance` (HTTP 405) La carga es una operación de escritura. Vuelva a intentar cargar en el punto final del read/write clúster. + `Failed to start load because of unknown error from S3` (HTTP 500) Amazon S3 ha devuelto un error desconocido. Ponte en contacto con [AWS Support](https://aws.amazon.com/premiumsupport/). + `Invalid S3 access key` (HTTP 400) La clave de acceso no es válida. Compruebe las credenciales proporcionadas. + `Invalid S3 secret key` (HTTP 400) La clave secreta no es válida. Compruebe las credenciales proporcionadas. + `Max concurrent load limit breached` (HTTP 400) Si una solicitud de carga se envía sin `"queueRequest" : "TRUE"` y un trabajo de carga se está ejecutando actualmente, se producirá este error en la solicitud. + `Failed to start new load for the source "source name". Max load task queue size limit breached. Limit is 64` (HTTP 400) Neptune permite poner en cola hasta 64 trabajos de carga a la vez. Si se envía una solicitud de carga adicional a la cola cuando ya contiene 64 trabajos, se producirá un error en la solicitud con este mensaje. # Ejemplos del programa de carga de Neptune En este ejemplo se muestra cómo utilizar el programa de carga de Neptune para cargar datos en una base de datos de gráficos de Neptune con el formato CSV de Gremlin. La solicitud se envía como una solicitud HTTP POST al punto de conexión del programa de carga de Neptune y el cuerpo de la solicitud contiene los parámetros necesarios para especificar el origen de datos, el formato, el rol de IAM y otras opciones de configuración. La respuesta incluye el ID de carga, que se puede utilizar para realizar un seguimiento del progreso del proceso de carga de datos. **Example Solicitud** A continuación, se muestra una solicitud enviada mediante HTTP POST con el comando `curl` Carga un archivo con el formato CSV de Neptune. Para obtener más información, consulte [Formato de datos de carga de 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 Respuesta** ``` { "status" : "200 OK", "payload" : { "loadId" : "ef478d76-d9da-4d94-8ff1-08d9d4863aa5" } } ``` # API Neptune Loader Get-Status Obtiene el estado de una tarea `loader`. Para obtener el estado de carga, debe enviar una solicitud HTTP `GET` al punto de enlace `https://your-neptune-endpoint:port/loader`. Para obtener el estado de una solicitud de carga concreta, debe incluir `loadId` como parámetro de la URL o añadir `loadId` a la ruta de la dirección URL. Neptune solo realiza un seguimiento de los 1024 trabajos de carga masiva más recientes y solo almacena los últimos 10 000 detalles de error por trabajo. Consulte [Mensajes de errores y fuente del programa de carga de Neptune](loader-message.md) para obtener una lista de los mensajes de error y de fuentes devueltos por el programa de carga en caso de errores. **Contents** + [Solicitudes de Neptune Loader Get-Status](load-api-reference-status-requests.md) + [Sintaxis de Get-Status solicitud de cargador](load-api-reference-status-requests.md#load-api-reference-status-request-syntax) + [Parámetros de solicitud de Neptune Loader Get-Status](load-api-reference-status-requests.md#load-api-reference-status-parameters) + [Respuestas de Neptune Loader Get-Status](load-api-reference-status-response.md) + [Diseño JSON de Neptune Loader Get-Status Response](load-api-reference-status-response.md#load-api-reference-status-response-layout) + [Neptune Loader Get-Status `overallStatus` y `failedFeeds` objetos de respuesta](load-api-reference-status-response.md#load-api-reference-status-response-objects) + [Objeto de respuesta Neptune Loader Get-Status `errors`](load-api-reference-status-response.md#load-api-reference-status-errors) + [Objeto de respuesta Neptune Loader Get-Status `errorLogs`](load-api-reference-status-response.md#load-api-reference-error-logs) + [Ejemplos de Neptune Loader Get-Status](load-api-reference-status-examples.md) + [Ejemplo de solicitud del estado de carga](load-api-reference-status-examples.md#load-api-reference-status-examples-status-request) + [Ejemplo de solicitud de loadIds](load-api-reference-status-examples.md#load-api-reference-status-examples-loadId-request) + [Ejemplo de solicitud del estado detallado](load-api-reference-status-examples.md#load-api-reference-status-examples-details-request) + [Ejemplos de Neptune Loader Get-Status `errorLogs`](load-api-reference-error-logs-examples.md) + [Ejemplo de respuesta de estado detallada cuando se produjeron errores](load-api-reference-error-logs-examples.md#load-api-reference-status-examples-details-request-errors) + [Ejemplo de un error `Data prefetch task interrupted`](load-api-reference-error-logs-examples.md#load-api-reference-status-examples-task-interrupted) # Solicitudes de Neptune Loader Get-Status ## Sintaxis de Get-Status solicitud de cargador ``` GET https://your-neptune-endpoint:port/loader?loadId=loadId ``` ``` GET https://your-neptune-endpoint:port/loader/loadId ``` ``` GET https://your-neptune-endpoint:port/loader ``` ## Parámetros de solicitud de Neptune Loader Get-Status + **`loadId`**: el identificador del trabajo de carga. Si no especifica a`loadId`, se devolverá una lista de cargas IDs . + **`details`**: incluye otros detalles aparte del estado general. *Valores permitidos*: `TRUE` y `FALSE`. *Valor predeterminado*: `FALSE`. + **`errors`**: incluye la lista de errores. *Valores permitidos*: `TRUE` y `FALSE`. *Valor predeterminado*: `FALSE`. Dicha lista está paginada. Los parámetros `page` y `errorsPerPage` le permiten desplazarse por todos los errores. + **`page`**: el número de la página de error. Solo es válido si el conjunto de parámetros `errors` está establecido en `TRUE`. *Valores permitidos*: números enteros positivos. *Valor predeterminado*: 1. + **`errorsPerPage`**: el número de errores por cada página. Solo es válido si el conjunto de parámetros `errors` está establecido en `TRUE`. *Valores permitidos*: números enteros positivos. *Valor predeterminado*: 10. + **`limit`**: el número de identificadores de carga que se va a incluir en la lista. Solo es válido cuando se solicita una lista de cargas IDs mediante el envío de una `GET` solicitud sin `loadId` especificar nada. *Valores permitidos*: números enteros positivos del 1 al 100. *Valor predeterminado*: 100. + **`includeQueuedLoads`**— Un parámetro opcional que se puede utilizar para excluir la carga IDs de solicitudes de carga en cola cuando se solicita una lista de carga IDs. De forma predeterminada, la carga IDs de todos los trabajos de carga con estado `LOAD_IN_QUEUE` se incluye en dicha lista. Aparecen antes IDs de que se carguen los demás trabajos, ordenados por el momento en que se agregaron a la cola, desde el más reciente al más antiguo. *Valores permitidos*: `TRUE` y `FALSE`. *Valor predeterminado*: `TRUE`. # Respuestas de Neptune Loader Get-Status El siguiente ejemplo de respuesta de la Get-Status API de Neptune describe la estructura general de la respuesta, explica los distintos campos y sus tipos de datos, así como la gestión de errores y los detalles del registro de errores. ## Diseño JSON de Neptune Loader Get-Status Response El diseño general de la respuesta de estado de un programa de carga es el siguiente: ``` { "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` y `failedFeeds` objetos de respuesta Las posibles respuestas devueltas para cada fuente fallida, incluidas las descripciones de los errores, son las mismas que para el objeto `overallStatus` de una respuesta `Get-Status`. Los siguientes campos aparecen en el objeto `overallStatus` de todas las cargas y en el objeto `failedFeeds` de cada fuente fallida: + **`fullUri`**: el URI del archivo o archivos que se van a cargar. *Tipo:* *string* *Formato*: `s3://bucket/key`. + **`runNumber`**: el número de ejecución de la carga o fuente. Aumenta cuando se reinicia la carga. *Tipo*: *entero largo sin signo*. + **`retryNumber`**: el número de reintento de la carga o fuente. Aumenta cuando el programa de carga reintenta automáticamente realizar una carga o procesar una fuente. *Tipo*: *entero largo sin signo*. + **`status`**: el estado que devuelve la carga o la fuente. `LOAD_COMPLETED` indica una carga correcta sin problemas. Para ver una lista de otros mensajes de estado de carga, consulte [Mensajes de errores y fuente del programa de carga de Neptune](loader-message.md). *Tipo:* *string*. + **`totalTimeSpent`**: el tiempo, en segundos, dedicado a analizar e insertar datos para la carga o la fuente. No incluye el tiempo dedicado a obtener la lista de archivos de origen. *Tipo*: *entero largo sin signo*. + **`totalRecords`**: número total de registros que se han cargado o que se ha intentado cargar. *Tipo*: *entero largo sin signo*. Tenga en cuenta que al cargar desde un archivo CSV, el recuento de registros no se refiere al número de líneas cargadas, sino al número de registros individuales en esas líneas. Tomemos como ejemplo un archivo CSV pequeño como este: ``` ~id,~label,name,team 'P-1','Player','Stokes','England' ``` Neptune consideraría que este archivo contiene 3 registros: ``` P-1 label Player P-1 name Stokes P-1 team England ``` + **`totalDuplicates`**: el número de registros duplicados que se ha encontrado. *Tipo*: *entero largo sin signo*. Como en el caso del recuento de `totalRecords`, este valor contiene el número de registros duplicados individuales de un archivo CSV, no el número de líneas duplicadas. Tomemos como ejemplo este archivo CSV pequeño: ``` ~id,~label,name,team P-2,Player,Kohli,India P-2,Player,Kohli,India ``` El estado devuelto después de cargarlo tendría este aspecto, con un total de 6 registros, de los cuales 3 son duplicados: ``` { "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 } } } ``` En el caso de las cargas de openCypher, se cuenta un duplicado cuando: + El programa de carga detecta que una fila de un archivo de nodo tiene un identificador sin un espacio de identificador que es igual a otro valor de identificador sin espacio de identificador, ya sea en otra fila o que pertenezca a un nodo existente. + El programa de carga detecta que una fila de un archivo de nodo tiene un identificador con un espacio de identificador que es igual a otro valor de identificador con espacio de identificador, ya sea en otra fila o que pertenezca a un nodo existente. Consulte [Consideraciones especiales para cargar datos de openCypher](load-api-reference-load.md#load-api-reference-load-parameters-opencypher). + **`parsingErrors`**: el número de errores de análisis encontrados. *Tipo*: *entero largo sin signo*. + **`datatypeMismatchErrors`**: el número de registros con un tipo de datos que no coincide con los datos proporcionados. *Tipo*: *entero largo sin signo*. + **`insertErrors`**: el número de registros que no se han podido insertar debido a errores. *Tipo*: *entero largo sin signo*. ## Objeto de respuesta Neptune Loader Get-Status `errors` Los errores se dividen en las categorías siguientes: + **`Error 400`**: un `loadId` no válido devuelve un error de solicitud incorrecta HTTP `400`. El mensaje describe el error. + **`Error 500`**: una solicitud válida que no se puede procesar devuelve un error interno del servidor HTTP `500`. El mensaje describe el error. Consulte [Mensajes de errores y fuente del programa de carga de Neptune](loader-message.md) para obtener una lista de los mensajes de error y de fuentes devueltos por el programa de carga en caso de errores. Si se produce un error, se devuelve un objeto JSON `errors` en el elemento `BODY` de la respuesta con los siguientes campos: + **`startIndex`**: el índice del primer error incluido. *Tipo*: *entero largo sin signo*. + **`endIndex`**: el índice del último error incluido. *Tipo*: *entero largo sin signo*. + **`loadId`**: el identificador de la carga. Puede utilizar este ID para imprimir los errores de la carga si establece el parámetro `errors` en `TRUE`. *Tipo:* *string*. + **`errorLogs`**: una lista de los errores. *Tipo*: *lista*. ## Objeto de respuesta Neptune Loader Get-Status `errorLogs` El objeto `errorLogs` que aparece en `errors` en la respuesta del estado de obtención del programa de carga contiene un objeto que describe cada error mediante los siguientes campos: + **`errorCode`**: identifica la naturaleza del error. Puede tener uno de los siguientes valores: + `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` (se devuelve cuando el programa de carga masiva no puede determinar el tipo de error). + **`errorMessage`**: mensaje que describe el error. Puede ser un mensaje genérico asociado al código de error o un mensaje específico que contenga detalles, por ejemplo, sobre un from/to vértice que falta o sobre un error de análisis. + **`fileName`**: el nombre de la fuente. + **`recordNum`**: en el caso de un error de análisis, se trata del número de registro del archivo del registro que no se ha podido analizar. Se establece en cero si el número de registro no es aplicable al error o si no se ha podido determinar. Por ejemplo, el programa de carga masiva generaría un error de análisis si encontrara una fila fallida como la siguiente en un archivo RDF `nquads`: ``` |http://base#predicate> . ``` Como puede ver, el segundo `http` de la fila anterior debería ir precedido de `<` en lugar de `|`. El objeto de error resultante en `errorLogs` en una respuesta de estado tendría el siguiente aspecto: ``` { "errorCode" : "PARSING_ERROR", "errorMessage" : "Expected '<', found: |", "fileName" : "s3://bucket/key", "recordNum" : 12345 }, ``` # Ejemplos de Neptune Loader Get-Status En los siguientes ejemplos, se muestra el uso de la API de obtención de estado del programa de carga de Neptune, que le permite recuperar información sobre el estado de las cargas de datos en la base de datos de gráficos de Amazon Neptune. Estos ejemplos cubren tres escenarios principales: recuperar el estado de una carga específica, enumerar la carga IDs disponible y solicitar información detallada sobre el estado de una carga específica. ## Ejemplo de solicitud del estado de carga A continuación, se muestra una solicitud enviada mediante HTTP `GET` con el comando `curl`. ``` curl -X GET 'https://your-neptune-endpoint:port/loader/loadId (a UUID)' ``` **Example Respuesta** ``` { "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 } } } ``` ## Ejemplo de solicitud de loadIds A continuación, se muestra una solicitud enviada mediante HTTP `GET` con el comando `curl`. ``` curl -X GET 'https://your-neptune-endpoint:port/loader?limit=3' ``` **Example Respuesta** ``` { "status" : "200 OK", "payload" : { "loadIds" : [ "a2c0ce44-a44b-4517-8cd4-1dc144a8e5b5", "09683a01-6f37-4774-bb1b-5620d87f1931", "58085eb8-ceb4-4029-a3dc-3840969826b9" ] } } ``` ## Ejemplo de solicitud del estado detallado A continuación, se muestra una solicitud enviada mediante HTTP `GET` con el comando `curl`. ``` curl -X GET 'https://your-neptune-endpoint:port/loader/loadId (a UUID)?details=true' ``` **Example Respuesta** ``` { "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 } } } ``` # Ejemplos de Neptune Loader Get-Status `errorLogs` En los siguientes ejemplos, se muestra la respuesta de estado detallada del programa de carga de Neptune cuando se producen errores durante el proceso de carga de datos. Los ejemplos ilustran la estructura de la respuesta, incluida la información sobre las fuentes erróneas, el estado general y los registros de errores detallados. ## Ejemplo de respuesta de estado detallada cuando se produjeron errores Se trata de una solicitud enviada a través de HTTP `GET` mediante `curl`: ``` curl -X GET 'https://your-neptune-endpoint:port/loader/0a237328-afd5-4574-a0bc-c29ce5f54802?details=true&errors=true&page=1&errorsPerPage=3' ``` **Example de una respuesta detallada cuando se produjeron errores** Este es un ejemplo de la respuesta que podría obtener de la consulta anterior, con un objeto `errorLogs` que muestre los errores de carga detectados: ``` { "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 } } } ``` ## Ejemplo de un error `Data prefetch task interrupted` Ocasionalmente, al obtener un estado `LOAD_FAILED` y solicitar a continuación información más detallada, el error devuelto puede ser un `PARSING_ERROR` con un mensaje `Data prefetch task interrupted`, como este: ``` "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 } ] ``` Este error se produce si ha habido una interrupción temporal en el proceso de carga de datos no provocada normalmente por su solicitud o sus datos. En general, puede resolverse simplemente ejecutando de nuevo la solicitud de carga masiva. En caso de que esté usando la configuración predeterminada, es decir, `"mode":"AUTO"` y `"failOnError":"TRUE"`, el programa de carga omite los archivos que ya ha cargado correctamente y reanuda la carga de los archivos que aún no había cargado en el momento de la interrupción. # Cancelación de trabajo del programa de carga de Neptune Cancela un trabajo de carga. Para cancelar un trabajo, debe enviar una solicitud HTTP `DELETE` al punto de enlace `https://your-neptune-endpoint:port/loader`. El valor `loadId` se puede añadir a la ruta de la dirección URL `/loader` o bien incluirse como variable en la URL. ## Sintaxis de solicitud de cancelación de trabajo ``` DELETE https://your-neptune-endpoint:port/loader?loadId=loadId ``` ``` DELETE https://your-neptune-endpoint:port/loader/loadId ``` ## Parámetros de solicitud de cancelación de tarea **loadId** El ID de la tarea de carga. ## Sintaxis de respuesta de cancelación de trabajo ``` no response body ``` **200 OK** Una tarea de carga eliminada correctamente devuelve el código `200`. ## Errores de cancelación de tarea Si se produce un error, se devuelve un objeto JSON en el elemento `BODY` de la respuesta. El objeto `message` contiene una descripción del error. **Categorías de errores** + **`Error 400`**: un `loadId` no válido devuelve un error de solicitud incorrecta HTTP `400`. El mensaje describe el error. + **`Error 500`**: una solicitud válida que no se puede procesar devuelve un error interno del servidor HTTP `500`. El mensaje describe el error. ## Mensajes de error de cancelación de tarea A continuación se muestran los posibles mensajes de error de la API de cancelación con la descripción correspondiente. + `The load with id = load_id does not exist or not active` (HTTP 404): no se ha encontrado la carga. Compruebe el valor del parámetro `id`. + `Load cancellation is not permitted on a read replica instance.` (HTTP 405): la carga es una operación de escritura. Vuelva a intentar cargar en el punto final del read/write clúster. ## Ejemplos de cancelación de tarea **Example Solicitud** A continuación, se muestra una solicitud enviada mediante HTTP `DELETE` con el comando `curl`. ``` curl -X DELETE 'https://your-neptune-endpoint:port/loader/0a237328-afd5-4574-a0bc-c29ce5f54802' ``` # AWS Database Migration Service Utilización para cargar datos en Amazon Neptune desde un almacén de datos diferente AWS Database Migration Service (AWS DMS) puede cargar datos en Neptune desde [bases de datos fuente compatibles](https://docs.aws.amazon.com/dms/latest/userguide/CHAP_Source.html) de forma rápida y segura. La base de datos de origen permanece totalmente operativa durante la migración, lo que minimiza el tiempo de inactividad de las aplicaciones que dependen de ella. Encontrará información detallada al respecto AWS DMS en la [Guía del AWS Database Migration Service usuario](https://docs.aws.amazon.com/dms/latest/userguide/) y en la [Referencia de la AWS Database Migration Service API](https://docs.aws.amazon.com/dms/latest/APIReference/). En concreto, puede encontrar información sobre cómo configurar un clúster de Neptune como objetivo para la migración en [Using Amazon Neptune as a Target for AWS Database Migration Service](https://docs.aws.amazon.com/dms/latest/userguide/CHAP_Target.Neptune.html). Estos son algunos requisitos previos para importar datos en Neptune mediante AWS DMS: + Deberá crear un objeto de mapeo de AWS DMS tablas para definir cómo deben extraerse los datos de la base de datos de origen (consulte [Especificar la selección y las transformaciones de las tablas mediante el mapeo de tablas mediante JSON](https://docs.aws.amazon.com/dms/latest/userguide/CHAP_Tasks.CustomizingTasks.TableMapping.html#CHAP_Tasks.CustomizingTasks.TableMapping.SelectionTransformation) en la AWS DMS guía del usuario para obtener más información). Este objeto de configuración de asignación de tablas especifica qué tablas se deben leer y en qué orden y cómo se denominan sus columnas. También puede filtrar las filas que se copian y proporcionar transformaciones de valor simples como convertir a minúsculas o redondear. + Tendrá que crear una `GraphMappingConfig` de Neptune para especificar cómo deben cargarse los datos extraídos de la base de datos de origen en Neptune. Para los datos RDF (consultados mediante SPARQL), el `GraphMappingConfig` se escribe en el lenguaje de asignación [R2RML](https://www.w3.org/TR/r2rml/) estándar de W3. Para los datos del gráfico de propiedades (consultados con Gremlin), el `GraphMappingConfig` es un objeto JSON, descrito en [GraphMappingConfig Diseño para datos de Property-Graph/Gremlin](dms-neptune-graph-mapping.md#dms-neptune-graph-mapping-gremlin). + Debe utilizarla AWS DMS para crear una instancia de replicación en la misma VPC que su clúster de base de datos de Neptune, para mediar en la transferencia de datos. + También necesitará un bucket de Amazon S3 para que se utilice como almacenamiento intermedio para el almacenamiento provisional de los datos de migración. # Creando un Neptuno GraphMappingConfig El `GraphMappingConfig` que crea especifica cómo se deben cargar los datos extraídos de un almacén de datos de origen en un clúster de base de datos de Neptune. Su formato varía en función de si está destinado a cargar datos RDF o para cargar datos de gráficos de propiedades. Para los datos de RDF, puede utilizar el lenguaje [R2RML](https://www.w3.org/TR/r2rml/) de W3 para asignar datos relacionales a RDF. Si está cargando datos de gráficos de propiedades para consultarlos mediante Gremlin, se crea un objeto JSON para `GraphMappingConfig`. ## GraphMappingConfig Diseño de datos RDF/SPARQL Si está cargando datos RDF para consultarlos mediante SPARQL, escriba `GraphMappingConfig` en [R2RML](https://www.w3.org/TR/r2rml/). `R2RML` es un lenguaje W3 estándar para asignación de datos relacionales a RDF. Aquí tiene un ejemplo: ``` @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" ]; ] . ``` Este es otro ejemplo: ``` @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 recomendación de W3 en [R2RML: RDB to RDF Mapping Language](https://www.w3.org/TR/r2rml/) proporciona detalles sobre el lenguaje. ## GraphMappingConfig Diseño para datos de Property-Graph/Gremlin Un `GraphMappingConfig` comparable para datos de Property-Graph es un objeto JSON que proporciona una regla de asignación para cada entidad de gráfico que se generará a partir de los datos de origen. La siguiente plantilla muestra el aspecto de cada regla en este objeto: ``` { "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)" } ] } ] } ] } ``` Tenga en cuenta que la presencia de una etiqueta de vértice implica que el vértice se está creando aquí, mientras que su ausencia implica que el vértice es creado por un origen distinto y esta definición solo agrega propiedades de vértice. Aquí hay una regla de ejemplo para un registro de empleado: ``` { "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" } ] } ] } ] } ``` # Crear una tarea de AWS DMS replicación con Neptune como objetivo Una vez que haya creado las configuraciones de mapeo de tablas y mapeo de gráficos, utilice el siguiente proceso para cargar datos desde el almacén de origen en Neptune. Consulte la AWS DMS documentación para obtener más detalles sobre el tema APIs en cuestión. ## Cree una instancia AWS DMS de replicación Cree una instancia de AWS DMS replicación en la VPC en la que se ejecuta el clúster de base de datos de Neptune (consulte [Trabajar con una instancia de replicación de AWS DMS](https://docs.aws.amazon.com/dms/latest/userguide/CHAP_ReplicationInstance.html) y [CreateReplicationInstance](https://docs.aws.amazon.com/dms/latest/APIReference/API_CreateReplicationInstance.html)en la Guía del usuario). AWS DMS Para ello, puede utilizar un AWS CLI comando como el siguiente: ``` 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) ``` ## Cree un AWS DMS punto final para la base de datos de origen El siguiente paso es crear un AWS DMS punto final para el almacén de datos de origen. Puedes usar la AWS DMS [CreateEndpoint](https://docs.aws.amazon.com/dms/latest/APIReference/API_CreateEndpoint.html)API de la siguiente AWS CLI manera: ``` 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) ``` ## Configuración de un bucket de Amazon S3 para que Neptune almacene provisionalmente los datos Si no tiene un bucket de Amazon S3 que pueda utilizar para almacenar provisionalmente los datos, cree uno como se explica en [Creación de un bucket](https://docs.aws.amazon.com/AmazonS3/latest/userguide/CreatingABucket.html) en la Guía de introducción de Amazon S3 o [¿Cómo se puede crear un bucket de S3?](https://docs.aws.amazon.com/AmazonS3/latest/userguide/create-bucket.html) en la Guía de usuario de la consola. Tendrá que crear un política de IAM que conceda permisos `GetObject`, `PutObject`, `DeleteObject` y `ListObject` al bucket si no dispone de uno aún: ------ #### [ 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 su clúster de base de datos de Neptune tiene habilitada la autenticación de IAM, también deberá incluir la siguiente política: ------ #### [ 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/*" } ] } ``` ------ Cree un rol de IAM como documento de confianza al que asociar la política: ------ #### [ 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" } ] } ``` ------ Después de asociar la política al rol, asocie el rol al clúster de base de datos de Neptune. Esto permitirá AWS DMS usar el depósito para organizar los datos que se están cargando. ## Creación de un punto de conexión de Amazon S3 en la VPC de Neptune Ahora cree un punto de conexión de la puerta de enlace de VPC para su bucket de Amazon S3 intermediario, en la VPC donde se encuentra su clúster de Neptune. AWS CLI Para ello, puede utilizar el Consola de administración de AWS o el, tal y como se describe en [Creación de un punto final de puerta](https://docs.aws.amazon.com/vpc/latest/userguide/vpce-gateway.html#create-gateway-endpoint) de enlace. ## Cree un punto final de AWS DMS destino para Neptune Cree un AWS DMS punto final para el clúster de base de datos Neptune de destino. Puede usar la AWS DMS [CreateEndpoint](https://docs.aws.amazon.com/dms/latest/APIReference/API_CreateEndpoint.html)API con el `NeptuneSettings` parámetro de la siguiente manera: ``` 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) }' ``` El objeto JSON que se pasa a la AWS DMS `CreateEndpoint` API en su `NeptuneSettings` parámetro tiene los siguientes campos: **** + **`ServiceAccessRoleArn`**: *(obligatorio)* el ARN de un rol de IAM que permite acceso detallado al bucket de S3 utilizado para el almacenamiento provisional de la migración de los datos a Neptune. Este rol también debe tener permisos para acceder al clúster de base de datos de Neptune si la autorización de IAM está habilitada en él. + **`S3BucketName`**: *(obligatorio)* para la migración de carga completa, la instancia de replicación convierte todos los datos RDS en archivos CSV quad, los carga en este bucket de almacenamiento provisional en S3 y, a continuación, realiza una carga masiva de los mismos en Neptune. + **`S3BucketFolder`**: *(obligatorio)* la carpeta que se va a utilizar en el bucket de almacenamiento provisional de S3. + **`ErrorRetryDuration`**: *(opcional)* el número de milisegundos que hay que esperar después de que la solicitud de Neptune devuelva un error antes de realizar una solicitud de reintento. El valor predeterminado es 250. + **`MaxRetryCount`**— *(opcional)* El número máximo de solicitudes de reintento que se AWS DMS deben realizar tras un error que se pueda volver a intentar. El valor predeterminado es 5. + **`MaxFileSize`**: *(opcional)* el tamaño máximo en bytes de cada archivo de almacenamiento provisional guardado en S3 durante la migración. El valor predeterminado es 1.048.576 KB (1 GB). + **`IsIAMAuthEnabled`**: *(opcional)* establézcalo en `true` si la autenticación de IAM está habilitada en el clúster de base de datos de Neptune o en `false` si no es así. El valor predeterminado es `false`. ## Prueba de las conexiones con los nuevos puntos de conexión Puedes probar la conexión a cada uno de estos nuevos puntos de conexión mediante la API de la AWS DMS [TestConnection](https://docs.aws.amazon.com/dms/latest/APIReference/API_TestConnection.html)siguiente manera: ``` aws dms test-connection \ --replication-instance-arn (the ARN of the replication instance) \ --endpoint-arn (the ARN of the endpoint you are testing) ``` ## Cree una tarea de AWS DMS replicación Una vez que haya completado correctamente los pasos anteriores, cree una tarea de replicación para migrar los datos del banco de datos de origen a Neptune, utilizando AWS DMS [CreateReplicationTask](https://docs.aws.amazon.com/dms/latest/APIReference/API_CreateReplicationTask.html.html)la API de la siguiente manera: ``` 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') ``` El parámetro `TaskData` proporciona el [GraphMappingConfig](dms-neptune-graph-mapping.md) que especifica cómo deben almacenarse en Neptune los datos que se copian. ## Inicie la tarea de AWS DMS replicación Ahora puede iniciar la tarea de replicación: ``` aws dms start-replication-task --replication-task-arn (ARN of the replication task started in the previous step) --start-replication-task-type start-replication ``` # Carga de datos en Amazon Neptune mediante consultas Neptune permite escribir datos directamente a través de operaciones de lenguaje de consulta. Puede utilizar operaciones de escritura estándar, como `CREATE` y `MERGE` en OpenCypher, en SPARQL o `INSERT` en Gremlin, para añadir o `mergeV()` modificar datos `mergeE()` en el gráfico. Estas operaciones son adecuadas para actualizaciones incrementales y escrituras transaccionales. Para cargar datos desde Amazon S3, utilice el [Uso del programa de carga masiva de Amazon Neptune para adquirir datos](bulk-load.md) para conjuntos de datos grandes que requieran un rendimiento optimizado. Para conjuntos de datos más pequeños en uno o varios archivos de Amazon S3, puede utilizar las funciones de carga basadas en consultas para leer y procesar los datos directamente dentro de sus consultas. Están disponibles las siguientes funciones de carga basadas en consultas: ## OpenCypher: neptune.read () La `neptune.read()` función lee archivos CSV o Parquet de Amazon S3 dentro de una `CALL` subconsulta, lo que le permite procesar y cargar datos en el momento de la consulta. ``` CALL neptune.read({ source: "s3://bucket/data.csv", format: "csv" }) YIELD row CREATE (n:Person {id: row.id, name: row.name}) ``` Para obtener la documentación completa, consulte[neptune.read ()](access-graph-opencypher-21-extensions-s3-read.md). ## SPARQL: CARGA Y DESCARGA `LOAD`Las operaciones de SPARQL importan datos RDF de un URI a un gráfico con nombre. `UNLOAD`exporta datos de un gráfico a Amazon S3. ``` LOAD INTO GRAPH ``` Para obtener la documentación completa, consulte[Uso de SPARQL UPDATE LOAD para importar datos a Neptune](sparql-api-reference-update-load.md). ## Gremlin: io () step También puedes usar el `g.io(URL).read()` paso de Gremlin para leer archivos de datos en [GraphML](https://tinkerpop.apache.org/docs/current/dev/io/#graphml) (un formato XML), [GraphSon](https://tinkerpop.apache.org/docs/current/dev/io/#graphson) (un formato JSON) y otros formatos. ``` g.io("s3://bucket/data.graphml").read().iterate() ``` [Consulta la documentación para obtener más informaciónTinkerPop.](https://tinkerpop.apache.org/docs/current/reference/#io-step)