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. # Conexión a la base de datos de Amazon Neptune mediante autenticación AWS Identity and Access Management Los recursos de Amazon Neptune que tienen habilitada la autenticación de base de datos de IAM requieren que todas las solicitudes HTTP se firmen con AWS Signature Version 4. Para obtener información general sobre la firma de solicitudes con la versión 4 de AWS Signature, consulte [Firmar solicitudes de AWS API](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_aws-signing.html). AWS La versión 4 de Signature es el proceso para añadir información de autenticación a AWS las solicitudes. Por motivos de seguridad, la mayoría de las solicitudes AWS deben firmarse con una clave de acceso, que consiste en un identificador de clave de acceso y una clave de acceso secreta. **nota** Si utiliza las credenciales temporales, caducan después de un intervalo especificado, *incluido el token de sesión*. Tiene que actualizar el token de sesión cuando solicite nuevas credenciales. Para obtener más información, consulte [Uso de credenciales de seguridad temporales para solicitar acceso a AWS los recursos](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_temp_use-resources.html). **importante** Para tener acceso a Neptune con la autenticación basada en IAM, debe crear solicitudes HTTP y firmarlas usted mismo. **Cómo funciona Signature Version 4** 1. Se crea una solicitud canónica. 1. Utiliza la solicitud canónica y alguna otra información para crear una. string-to-sign 1. Usas tu clave de acceso AWS secreta para obtener una clave de firma y, a continuación, usas esa clave de firma y la string-to-sign para crear una firma. 1. Se añade la firma resultante a la solicitud HTTP en un encabezado o como parámetro de cadena de consulta. Cuando Neptune recibe la solicitud, lleva a cabo los mismos pasos realizados para calcular la firma. A continuación, Neptune compara la firma calculada con la que se ha enviado con la solicitud. Si las firmas coinciden, la solicitud se procesa. Si las firmas no coinciden, la solicitud se deniega. Para obtener información general sobre la firma de solicitudes con AWS la versión 4 de la [firma, consulte el proceso de firma de la versión 4](https://docs.aws.amazon.com/general/latest/gr/signature-version-4.html) en *Referencia general de AWS*. Las siguientes secciones contienen ejemplos que muestran cómo enviar solicitudes firmadas a los puntos de conexión de Gremlin y SPARQL de una instancia de base de datos de Neptune con la autenticación de IAM habilitada. **Topics** + [Requisitos previos para conectar bases de datos de Amazon Neptune mediante la autenticación de IAM](iam-auth-connect-prerq.md) + [Conexión a bases de datos de Amazon Neptune mediante la autenticación de IAM desde la línea de comandos](iam-auth-connect-command-line.md) + [Conexión a bases de datos de Amazon Neptune mediante la autenticación de IAM con la consola de Gremlin](iam-auth-connecting-gremlin-console.md) + [Conexión a bases de datos de Amazon Neptune mediante IAM con Java de Gremlin](iam-auth-connecting-gremlin-java.md) + [Conexión a bases de datos de Amazon Neptune mediante la autenticación de IAM con Java y SPARQL](iam-auth-connecting-sparql-java.md) + [Conexión a bases de datos de Amazon Neptune mediante la autenticación de IAM con SPARQL y Node.js](iam-auth-connecting-sparql-node.md) + [Conexión a bases de datos de Amazon Neptune mediante la autenticación de IAM con Python](iam-auth-connecting-python.md) + [Conexión a bases de datos de Amazon Neptune mediante la autenticación de IAM con Python de Gremlin](gremlin-python-iam-auth.md) + [Conexión a las bases de datos de Amazon Neptune mediante la autenticación de IAM con Gremlin JavaScript](gremlin-javascript-iam-auth.md) + [Conexión a bases de datos de Amazon Neptune mediante la autenticación de IAM con Go de Gremlin](gremlin-go-iam-auth.md) + [Conexión a bases de datos de Amazon Neptune mediante la autenticación de IAM con .NET de Gremlin](gremlin-dotnet-iam-auth.md) # Requisitos previos para conectar bases de datos de Amazon Neptune mediante la autenticación de IAM A continuación se muestran instrucciones para instalar Apache Maven y Java 8 en una instancia de Amazon EC2. Estos son necesarios para los ejemplos de autenticación de Signature Version 4 de Amazon Neptune. **Para instalar Apache Maven y Java 8 en la instancia EC2** 1. Conéctese con la instancia de Amazon EC2 por medio de un cliente SSH. 1. Instale Apache Maven en la instancia EC2. Si utiliza Amazon Linux 2023 (preferido), utilice: ``` sudo dnf update -y sudo dnf install maven -y ``` Si utiliza Amazon Linux 2, descargue el archivo binario más reciente desde [https://maven.apache.org/download.cgi:](https://maven.apache.org/download.cgi:) ``` sudo yum remove maven -y wget https://dlcdn.apache.org/maven/maven-3/ /binaries/apache-maven--bin.tar.gz sudo tar -xzf apache-maven--bin.tar.gz -C /opt/ sudo ln -sf /opt/apache-maven- /opt/maven echo 'export MAVEN_HOME=/opt/maven' >> ~/.bashrc echo 'export PATH=$MAVEN_HOME/bin:$PATH' >> ~/.bashrc source ~/.bashrc ``` 1. Las bibliotecas de Gremlin requieren Java 8. Escriba lo siguiente para instalar Java 8 en la instancia EC2. ``` sudo yum install java-1.8.0-devel ``` 1. Escriba lo siguiente para establecer Java 8 como tiempo de ejecución predeterminado en la instancia EC2. ``` sudo /usr/sbin/alternatives --config java ``` Cuando se le solicite, escriba el número para Java 8. 1. Escriba lo siguiente para establecer Java 8 como compilador predeterminado en la instancia EC2. ``` sudo /usr/sbin/alternatives --config javac ``` Cuando se le solicite, escriba el número para Java 8. # Conexión a bases de datos de Amazon Neptune mediante la autenticación de IAM desde la línea de comandos Es muy práctico disponer de una herramienta de línea de comandos para enviar consultas al clúster de base de datos de Neptune, como se ilustra en muchos de los ejemplos de esta documentación. La herramienta [curl](https://curl.haxx.se/) es una excelente opción para comunicarse con los puntos de conexión de Neptune si la autenticación de IAM no está habilitada. **Sin embargo, para mantener sus datos seguros, es mejor habilitar la autenticación de IAM.** Cuando la autenticación de IAM está habilitada, cada una de las solicitudes debe [firmarse con Signature Version 4 (Sig4)](https://docs.aws.amazon.com/general/latest/gr/signing-aws-api-requests.html). La herramienta de línea de comandos [awscurl](https://github.com/okigan/awscurl) de terceros utiliza la misma sintaxis que `curl` y puede firmar consultas mediante la firma Sig4. En la sección [Uso de `awscurl`](#iam-auth-connect-awscurl) a continuación, se explica cómo utilizar `awscurl` de forma segura con credenciales temporales. ## Configuración de una herramienta de línea de comandos para usar HTTPS Neptune requiere que todas las conexiones usen HTTPS. Cualquier herramienta de línea de comandos, como `curl` o `awscurl`, necesita acceso a los certificados correspondientes para poder usar HTTPS. Mientras `curl` o `awscurl` puedan localizar los certificados apropiados, gestionan las conexiones HTTPS igual que las HTTP, sin necesidad de parámetros adicionales. Los ejemplos de esta documentación se basan en ese escenario. Para saber cómo obtener dichos certificados y cómo formatearlos correctamente en un almacén de certificados de autoridad de certificación (CA) que `curl` pueda utilizar, consulte [SSL Certificate Verification](https://curl.haxx.se/docs/sslcerts.html) en la documentación de `curl`. A continuación, puede especificar la ubicación de este almacén de certificados de CA mediante la variable de entorno `CURL_CA_BUNDLE`. En Windows, `curl` lo busca de forma automática en un archivo llamado `curl-ca-bundle.crt`. Primero busca en el mismo directorio que `curl.exe` y después en el resto de sitios de la ruta. Para obtener más información, consulte [Certificados SSL](https://curl.haxx.se/docs/sslcerts.html). ## Uso de `awscurl` con credenciales temporales para conectarse de forma segura a un clúster de base de datos con la autenticación de IAM habilitada La herramienta [awscurl](https://github.com/okigan/awscurl) usa la misma sintaxis que `curl`, pero también necesita información adicional: + **`--access_key`**: una clave de acceso válida. Si no se proporciona con este parámetro, debe proporcionarse en la variable de entorno `AWS_ACCESS_KEY_ID` o en un archivo de configuración. + **`--secret_key`**: clave de acceso secreta que corresponde a la clave de acceso. Si no se proporciona con este parámetro, debe proporcionarse en la variable de entorno `AWS_SECRET_ACCESS_KEY` o en un archivo de configuración. + **`--security_token`**: un token de sesión válido. Si no se proporciona con este parámetro, debe proporcionarse en la variable de entorno `AWS_SECURITY_TOKEN` o en un archivo de configuración. En el pasado, era una práctica habitual utilizar credenciales persistentes con `awscurl`, como las credenciales de usuario de IAM o incluso las credenciales raíz, pero no se recomienda. [En su lugar, genere credenciales temporales utilizando uno de los [servicios de token de AWS seguridad (STS) APIs](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_temp_request.html) o uno de sus contenedores.AWS CLI](https://docs.aws.amazon.com/cli/latest/reference/sts/index.html) Es mejor colocar los valores `AccessKeyId`, `SecretAccessKey` y `SessionToken` que devuelve la llamada de STS en las variables de entorno adecuadas de la sesión del intérprete de comandos, en lugar de en un archivo de configuración. A continuación, cuando el intérprete de comandos finaliza, las credenciales se descartan automáticamente, lo que no ocurre con un archivo de configuración. Del mismo modo, no solicite una duración mayor para las credenciales temporales de la que es probable que necesite. El siguiente ejemplo muestra los pasos que puede seguir en un intérprete de comandos de Linux para obtener credenciales temporales que sean válidas durante media hora utilizando [sts assume-role](https://docs.aws.amazon.com/cli/latest/reference/sts/assume-role) y, a continuación, colocarlas en variables de entorno donde `awscurl` pueda encontrarlas: ``` aws sts assume-role \ --duration-seconds 1800 \ --role-arn "arn:aws:iam::(account-id):role/(rolename)" \ --role-session-name AWSCLI-Session > $output AccessKeyId=$(echo $output | jq '.Credentials''.AccessKeyId') SecretAccessKey=$(echo $output | jq '.Credentials''.SecretAccessKey') SessionToken=$(echo $output | jq '.Credentials''.SessionToken') export AWS_ACCESS_KEY_ID=$AccessKeyId export AWS_SECRET_ACCESS_KEY=$SecretAccessKey export AWS_SESSION_TOKEN=$SessionToken ``` A continuación, puede utilizar `awscurl` para realizar una solicitud firmada a su clúster de base de datos de una forma similar a la siguiente: ``` awscurl (your cluster endpoint):8182/status \ --region us-east-1 \ --service neptune-db ``` # Conexión a bases de datos de Amazon Neptune mediante la autenticación de IAM con la consola de Gremlin Para conectarse a Amazon Neptune mediante la consola Gremlin con la autenticación Signature Version 4, debe conectar un firmante SiGv4 `requestInterceptor()` a la conexión establecida por el comando. `:remote` Esto requiere que configure el `Cluster` objeto manualmente y, a continuación, lo pase al comando. `:remote` Tenga en cuenta que esto es muy diferente de la situación típica en la que el comando `:remote` utiliza un archivo de configuración para formar la conexión. El enfoque del archivo de configuración no funciona porque `requestInterceptor()` debe configurarse mediante programación y no puede cargar su configuración desde un archivo. **nota** En los siguientes ejemplos se utiliza`requestInterceptor()`, que se introdujo en la versión TinkerPop 3.6.6. Si utiliza una TinkerPop versión anterior a la 3.6.6 (pero 3.5.5 o superior), utilícela en `handshakeInterceptor()` lugar de `requestInterceptor()` en los ejemplos de código que aparecen a continuación. Son necesarios los siguientes requisitos previos: + Debe tener las credenciales de IAM necesarias para firmar las solicitudes. Consulte [Uso de la cadena de proveedores de credenciales predeterminada](https://docs.aws.amazon.com//sdk-for-java/latest/developer-guide/credentials-chain.html) en la Guía para AWS SDK para Java desarrolladores. + Debe tener instalada una versión de consola de Gremlin que sea compatible con la versión del motor de Neptune que utiliza su clúster de base de datos. Si usa credenciales temporales, estas caducan después de un intervalo específico, al igual que el token de sesión, por lo que debe actualizar su token de sesión cuando solicite nuevas credenciales. Consulte [Uso de credenciales de seguridad temporales para solicitar acceso a AWS los recursos](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_temp_use-resources.html) en la Guía del usuario de IAM. Si necesita ayuda para conectarse mediante SSL/TLS, consulte [Configuración de SSL/TLS](access-graph-gremlin-java.md#access-graph-gremlin-java-ssl). **Conecta la consola Gremlin con la firma Sig4** 1. Inicie la consola de Gremlin: ``` $ bin/gremlin.sh ``` 1. En el símbolo del sistema de `gremlin>`, instale la biblioteca `amazon-neptune-sigv4-signer` (esto solo debe hacerse una vez para la consola): ``` :install com.amazonaws amazon-neptune-sigv4-signer 2.4.0 ``` [Si tiene problemas con este paso, puede ser útil consultar la [TinkerPop documentación sobre la configuración de Grape](https://tinkerpop.apache.org/docs/current/reference/#gremlin-applications).](http://docs.groovy-lang.org/latest/html/documentation/grape.html) **nota** Si utiliza un proxy HTTP, es posible que encuentre errores en este paso si el comando `:install` no se completa. Para solucionar este problema, ejecute los siguientes comandos para informar a la consola acerca del proxy: ``` System.setProperty("https.proxyHost", "(the proxy IP address)") System.setProperty("https.proxyPort", "(the proxy port)") ``` 1. Importe la clase necesaria para gestionar el inicio de sesión en `requestInterceptor()`: ``` :import software.amazon.awssdk.auth.credentials.DefaultCredentialsProvider :import com.amazonaws.neptune.auth.NeptuneNettyHttpSigV4Signer ``` 1. Si utiliza credenciales temporales, también tendrá que proporcionar su token de sesión de la siguiente manera: ``` System.setProperty("aws.sessionToken","(your session token)") ``` 1. Si no ha establecido las credenciales de su cuenta de otro modo, puede asignarlas de la siguiente manera: ``` System.setProperty("aws.accessKeyId","(your access key)") System.setProperty("aws.secretKey","(your secret key)") ``` 1. Construya manualmente el objeto `Cluster` para conectarlo a Neptune: ``` cluster = Cluster.build("(host name)") \ .enableSsl(true) \ .requestInterceptor { r -> \ def sigV4Signer = new NeptuneNettyHttpSigV4Signer("(Amazon region)", \ DefaultCredentialsProvider.create()); \ sigV4Signer.signRequest(r); \ return r; } \ .create() ``` Para obtener ayuda para encontrar el nombre de host de una instancia de base de datos de Neptune, consulte [Conexión a los puntos de conexión de Amazon Neptune](feature-overview-endpoints.md). 1. Establezca la conexión `:remote` mediante el nombre de la variable del objeto `Cluster` en el paso anterior: ``` :remote connect tinkerpop.server cluster ``` 1. Introduzca el siguiente comando para cambiar al modo remoto. Esto envía todas las consultas de Gremlin a la conexión remota: ``` :remote console ``` # Conexión a bases de datos de Amazon Neptune mediante IAM con Java de Gremlin Este es un ejemplo de cómo conectarse a Neptune mediante la API Java de Gremlin con firma Sig4 (se supone tener conocimientos generales sobre el uso de Maven). En este ejemplo, se utiliza la biblioteca [Amazon Neptune SigV4 Signer](https://github.com/aws/amazon-neptune-sigv4-signer) para facilitar la firma de solicitudes. Primero, defina las dependencias como parte del archivo `pom.xml`: **nota** En los siguientes ejemplos se utiliza`requestInterceptor()`, la cual se introdujo en la versión 3.6.6. TinkerPop Si utiliza una TinkerPop versión anterior a la 3.6.6 (pero 3.5.5 o superior), utilícela en `handshakeInterceptor()` lugar de `requestInterceptor()` en los ejemplos de código que aparecen a continuación. ``` com.amazonaws amazon-neptune-sigv4-signer 3.1.0 ``` El Sigv4 Signer de Amazon Neptune es compatible con las versiones 1.x y 2.x del SDK de Java. AWS En los ejemplos siguientes se utiliza la versión 2.x, donde es una instancia. `DefaultCredentialsProvider` `software.amazon.awssdk.auth.credentials.AwsCredentialsProvider` Si vas a actualizar de la versión 1.x a la 2.x, consulta los [cambios en el proveedor de credenciales](https://docs.aws.amazon.com//sdk-for-java/latest/developer-guide/migration-client-credentials.html) en la documentación de AWS SDK for Java 2.x. ``` import software.amazon.awssdk.auth.credentials.DefaultCredentialsProvider; import com.amazonaws.neptune.auth.NeptuneNettyHttpSigV4Signer; import com.amazonaws.neptune.auth.NeptuneSigV4SignerException; ... System.setProperty("aws.accessKeyId","your-access-key"); System.setProperty("aws.secretKey","your-secret-key"); ... Cluster cluster = Cluster.build((your cluster)) .enableSsl(true) .requestInterceptor( r -> { try { NeptuneNettyHttpSigV4Signer sigV4Signer = new NeptuneNettyHttpSigV4Signer("(your region)", DefaultCredentialsProvider.create()); sigV4Signer.signRequest(r); } catch (NeptuneSigV4SignerException e) { throw new RuntimeException("Exception occurred while signing the request", e); } return r; } ).create(); try { Client client = cluster.connect(); client.submit("g.V().has('code','IAD')").all().get(); } catch (Exception e) { throw new RuntimeException("Exception occurred while connecting to cluster", e); } ``` ## Autenticación de IAM entre cuentas Amazon Neptune admite la autenticación de IAM entre cuentas mediante el uso de la asunción de roles, también conocida como [encadenamiento de roles](https://docs.aws.amazon.com//neptune/latest/userguide/bulk-load-tutorial-chain-roles.html#bulk-load-tutorial-chain-cross-account). Para proporcionar acceso a un clúster de Neptune desde una aplicación alojada en una cuenta diferente AWS : + Cree un nuevo usuario o rol de IAM en la AWS cuenta de la aplicación, con una política de confianza que permita al usuario o rol asumir otro rol de IAM. Asigne este rol al servicio de computación que aloja la aplicación (instancia EC2, función de Lambda, tarea de ECS, etc.). ------ #### [ JSON ] **** ``` { "Version":"2012-10-17", "Statement": [ { "Sid": "assumeRolePolicy", "Effect": "Allow", "Action": "sts:AssumeRole", "Resource": "arn:aws:iam::111122223333:role/role-name" } ] } ``` ------ + Cree un nuevo rol de IAM en la cuenta de base de datos de Neptuno que permita el acceso a la AWS base de datos de Neptune y permita la asunción del rol desde el usuario/rol de IAM de la cuenta de aplicación. Utilice una política de confianza de: ------ #### [ JSON ] **** ``` { "Version":"2012-10-17", "Statement": [ { "Effect": "Allow", "Principal": { "AWS": [ "(ARN of application account IAM user or role)" ] }, "Action": "sts:AssumeRole", "Condition": {} } ] } ``` ------ + Utilice el siguiente ejemplo de código como guía para utilizar estos dos roles y permitir que la aplicación acceda a Neptune. En este ejemplo, el rol de la cuenta de la aplicación se asumirá mediante el al crear el. [DefaultCredentialProviderChain](https://docs.aws.amazon.com//sdk-for-java/v1/developer-guide/credentials.html)`STSclient` Luego, `STSclient` se usa a través de `STSAssumeRoleSessionCredentialsProvider` para asumir la función alojada en la cuenta de la base AWS de datos de Neptune. ``` public static void main( String[] args ) { /* * Establish an STS client from the application account. */ AWSSecurityTokenService client = AWSSecurityTokenServiceClientBuilder .standard() .build(); /* * Define the role ARN that you will be assuming in the database account where the Neptune cluster resides. */ String roleArnToAssume = "arn:aws:iam::012345678901:role/CrossAccountNeptuneRole"; String crossAccountSessionName = "cross-account-session-" + UUID.randomUUID(); /* * Change the Credentials Provider in the SigV4 Signer to use the STSAssumeRole Provider and provide it * with both the role to be assumed, the original STS client, and a session name (which can be * arbitrary.) */ Cluster cluster = Cluster.build() .addContactPoint("neptune-cluster.us-west-2.neptune.amazonaws.com") .enableSsl(true) .port(8182) .requestInterceptor( r -> { try { NeptuneNettyHttpSigV4Signer sigV4Signer = // new NeptuneNettyHttpSigV4Signer("us-west-2", DefaultCredentialsProvider.create()); new NeptuneNettyHttpSigV4Signer( "us-west-2", new STSAssumeRoleSessionCredentialsProvider .Builder(roleArnToAssume, crossAccountSessionName) .withStsClient(client) .build()); sigV4Signer.signRequest(r); } catch (NeptuneSigV4SignerException e) { throw new RuntimeException("Exception occurred while signing the request", e); } return r; } ).create(); GraphTraversalSource g = traversal().withRemote(DriverRemoteConnection.using(cluster)); /* whatever application code is necessary */ cluster.close(); } ``` # Conexión a bases de datos de Amazon Neptune mediante la autenticación de IAM con Java y SPARQL En esta sección se muestra cómo conectarse a Neptune mediante RDF4 J o Apache Jena con la autenticación Signature Version 4. **Requisitos previos** + Java 8 o superior. + Apache Maven 3.3 o superior. Para obtener información sobre la instalación de estos requisitos previos en una instancia EC2 que ejecuta Amazon Linux, consulte [Requisitos previos para conectar bases de datos de Amazon Neptune mediante la autenticación de IAM](iam-auth-connect-prerq.md). + Credenciales de IAM para firmar las solicitudes. Para obtener más información, consulte [Using the Default Credential Provider Chain](https://docs.aws.amazon.com/sdk-for-java/v1/developer-guide/credentials.html#credentials-default) en la *Guía para desarrolladores de AWS SDK para Java *. **nota** Si utiliza las credenciales temporales, caducan después de un intervalo especificado, *incluido el token de sesión*. Tiene que actualizar el token de sesión cuando solicite nuevas credenciales. Para obtener más información, consulte [Uso de credenciales de seguridad temporales para solicitar acceso a AWS los recursos](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_temp_use-resources.html) en la Guía del usuario de *IAM*. + Establezca la variable `SERVICE_REGION` en una de las siguientes e indique la región de su instancia de base de datos de Neptune: + 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` **Para conectarse a Neptune mediante RDF4 J o Apache Jena con firma Signature Version 4** 1. Clona el repositorio de muestras desde. GitHub ``` git clone https://github.com/aws/amazon-neptune-sparql-java-sigv4.git ``` 1. Cambie al directorio clonado. ``` cd amazon-neptune-sparql-java-sigv4 ``` 1. Obtenga la versión más reciente del proyecto al revisar la ramificación con la etiqueta más reciente. ``` git checkout $(git describe --tags `git rev-list --tags --max-count=1`) ``` 1. Introduzca uno de los siguientes comandos para compilar y ejecutar el código de ejemplo. *your-neptune-endpoint*Sustitúyalo por el nombre de host o la dirección IP de la instancia de base de datos de Neptune. El puerto predeterminado es 8182. **nota** 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). **Eclipse J. RDF4** Introduzca lo siguiente para ejecutar el ejemplo de RDF4 J. ``` mvn compile exec:java \ -Dexec.mainClass="com.amazonaws.neptune.client.rdf4j.NeptuneRdf4JSigV4Example" \ -Dexec.args="https://your-neptune-endpoint:portsparql region-name" ``` **Apache Jena** Para ejecutar el ejemplo de Apache Jena, introduzca lo siguiente. ``` mvn compile exec:java \ -Dexec.mainClass="com.amazonaws.neptune.client.jena.NeptuneJenaSigV4Example" \ -Dexec.args="https://your-neptune-endpoint:port" ``` 1. Para ver el código fuente del ejemplo, consulte los ejemplos del directorio `src/main/java/com/amazonaws/neptune/client/`. Para utilizar el controlador de firma SigV4 en su propia aplicación de Java, añada el paquete de Maven `amazon-neptune-sigv4-signer` a la sección `` del archivo `pom.xml`. Recomendamos que utilice los ejemplos como punto de partida. # Conexión a bases de datos de Amazon Neptune mediante la autenticación de IAM con SPARQL y Node.js ## Consultas mediante la firma Signature V4 y el AWS SDK para Javascript V3 A continuación, se muestra un ejemplo de cómo conectarse a Neptune SPARQL mediante Node.js con la autenticación Signature Version 4 y el AWS SDK para Javascript V3: ``` const { HttpRequest } = require('@smithy/protocol-http'); const { fromNodeProviderChain } = require('@aws-sdk/credential-providers'); const { SignatureV4 } = require('@smithy/signature-v4'); const { Sha256 } = require('@aws-crypto/sha256-universal'); const https = require('https'); var region = 'us-west-2'; // e.g. us-west-1 var neptune_endpoint = 'your-Neptune-cluster-endpoint'; // like: 'cluster-id.region.neptune.amazonaws.com' var query = `query=PREFIX rdf: PREFIX class: PREFIX resource: PREFIX prop: PREFIX objprop: SELECT ?movies ?title WHERE { ?jel prop:name "James Earl Jones" . ?movies ?p2 ?jel . ?movies prop:title ?title } LIMIT 10`; runQuery(query); function runQuery(q) { var request = new HttpRequest({ hostname: neptune_endpoint, port: 8182, path: 'sparql', body: encodeURI(query), headers: { 'Content-Type': 'application/x-www-form-urlencoded', 'host': neptune_endpoint + ':8182', }, method: 'POST', }); const credentialProvider = fromNodeProviderChain(); let credentials = credentialProvider(); credentials.then( (cred)=>{ var signer = new SignatureV4({credentials: cred, region: region, sha256: Sha256, service: 'neptune-db'}); signer.sign(request).then( (req)=>{ var responseBody = ''; var sendreq = https.request( { host: req.hostname, port: req.port, path: req.path, method: req.method, headers: req.headers, }, (res) => { res.on('data', (chunk) => { responseBody += chunk; }); res.on('end', () => { console.log(JSON.parse(responseBody)); }); }); sendreq.write(req.body); sendreq.end(); } ); }, (err)=>{ console.error(err); } ); } ``` ## Consultas mediante la firma Signature V4 y el SDK para Javascript V2 AWS A continuación, se muestra un ejemplo de cómo conectarse a Neptune SPARQL mediante Node.js con la autenticación Signature Version 4 y el AWS SDK para Javascript V2: ``` var AWS = require('aws-sdk'); var region = 'us-west-2'; // e.g. us-west-1 var neptune_endpoint = 'your-Neptune-cluster-endpoint'; // like: 'cluster-id.region.neptune.amazonaws.com' var query = `query=PREFIX rdf: PREFIX class: PREFIX resource: PREFIX prop: PREFIX objprop: SELECT ?movies ?title WHERE { ?jel prop:name "James Earl Jones" . ?movies ?p2 ?jel . ?movies prop:title ?title } LIMIT 10`; runQuery(query); function runQuery(q) { var endpoint = new AWS.Endpoint(neptune_endpoint); endpoint.port = 8182; var request = new AWS.HttpRequest(endpoint, region); request.path += 'sparql'; request.body = encodeURI(query); request.headers['Content-Type'] = 'application/x-www-form-urlencoded'; request.headers['host'] = neptune_endpoint; request.method = 'POST'; var credentials = new AWS.CredentialProviderChain(); credentials.resolve((err, cred)=>{ var signer = new AWS.Signers.V4(request, 'neptune-db'); signer.addAuthorization(cred, new Date()); }); var client = new AWS.HttpClient(); client.handleRequest(request, null, function(response) { console.log(response.statusCode + ' ' + response.statusMessage); var responseBody = ''; response.on('data', function (chunk) { responseBody += chunk; }); response.on('end', function (chunk) { console.log('Response body: ' + responseBody); }); }, function(error) { console.log('Error: ' + error); }); } ``` # Conexión a bases de datos de Amazon Neptune mediante la autenticación de IAM con Python En esta sección, se muestra un programa de ejemplo escrito en Python que ilustra cómo trabajar con Signature Version 4 para Amazon Neptune. Se basa en los ejemplos de la sección [Proceso de firma Signature Version 4](https://docs.aws.amazon.com/general/latest/gr/sigv4-signed-request-examples.html) en la *Referencia general de Amazon Web Services*. Para utilizar este programa de ejemplo, se necesita lo siguiente: + Python 3.x instalado en el equipo; puede obtenerlo en el [sitio de Python](https://www.python.org/downloads/). Estos programas se han probado con Python 3.6. + La [biblioteca requests de Python](https://pypi.python.org/pypi/requests), que se utiliza en el script de ejemplo para realizar solicitudes web. Una forma cómoda de instalar paquetes de Python es utilizar `pip`, que obtiene los paquetes del sitio web Python Package Index. A continuación, puede instalar `requests` ejecutando `pip install requests` en la línea de comandos. + Una clave de acceso (ID de clave de acceso y clave de acceso secreta) en las variables de entorno denominadas `AWS_ACCESS_KEY_ID` y `AWS_SECRET_ACCESS_KEY`. Como práctica recomendada, es conveniente que *no* incluya las credenciales en el código. Para más información, consulte [Prácticas recomendadas para cuentas de AWS](https://docs.aws.amazon.com//accounts/latest/reference/best-practices.html) en la *Guía de referencia de AWS Account Management *. La región de su clúster de base de datos de Neptune en la variable de entorno denominada `SERVICE_REGION`. Si está utilizando credenciales temporales, debe especificar `AWS_SESSION_TOKEN` además de `AWS_ACCESS_KEY_ID`, `AWS_SECRET_ACCESS_KEY` y `SERVICE_REGION`. **nota** Si utiliza las credenciales temporales, caducan después de un intervalo especificado, *incluido el token de sesión*. Tiene que actualizar el token de sesión cuando solicite nuevas credenciales. Para obtener más información, consulte [Uso de credenciales de seguridad temporales para solicitar acceso a los recursos de AWS](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_temp_use-resources.html). En el siguiente ejemplo, se muestra cómo realizar solicitudes firmadas a Neptune mediante Python. Se realiza una solicitud GET o POST. La información de autenticación se pasa mediante el encabezado `Authorization` de la solicitud. Este ejemplo también funciona como una AWS Lambda función. Para obtener más información, consulte [Configuración de AWS Lambda para la autenticación IAM de Neptune](iam-auth-temporary-credentials.md#iam-auth-temporary-credentials-lambda). **Para realizar solicitudes firmadas a los puntos de conexión de Gremlin y SPARQL en Neptune** 1. Cree un archivo con el nombre `neptunesigv4.py` y ábralo en un editor de texto. 1. Copie el siguiente código y péguelo en el archivo `neptunesigv4.py`. ``` # Amazon Neptune version 4 signing example (version v3) # The following script requires python 3.6+ # (sudo yum install python36 python36-virtualenv python36-pip) # => the reason is that we're using urllib.parse() to manually encode URL # parameters: the problem here is that SIGV4 encoding requires whitespaces # to be encoded as %20 rather than not or using '+', as done by previous/ # default versions of the library. # See: https://docs.aws.amazon.com/general/latest/gr/sigv4_signing.html import sys, datetime, hashlib, hmac import requests # pip3 install requests import urllib import os import json from botocore.auth import SigV4Auth from botocore.awsrequest import AWSRequest from botocore.credentials import ReadOnlyCredentials from types import SimpleNamespace from argparse import RawTextHelpFormatter from argparse import ArgumentParser # Configuration. https is required. protocol = 'https' # The following lines enable debugging at httplib level (requests->urllib3->http.client) # You will see the REQUEST, including HEADERS and DATA, and RESPONSE with HEADERS but without DATA. # # The only thing missing will be the response.body which is not logged. # # import logging # from http.client import HTTPConnection # HTTPConnection.debuglevel = 1 # logging.basicConfig() # logging.getLogger().setLevel(logging.DEBUG) # requests_log = logging.getLogger("requests.packages.urllib3") # requests_log.setLevel(logging.DEBUG) # requests_log.propagate = True # Read AWS access key from env. variables. Best practice is NOT # to embed credentials in code. access_key = os.getenv('AWS_ACCESS_KEY_ID', '') secret_key = os.getenv('AWS_SECRET_ACCESS_KEY', '') region = os.getenv('SERVICE_REGION', '') # AWS_SESSION_TOKEN is optional environment variable. Specify a session token only if you are using temporary # security credentials. session_token = os.getenv('AWS_SESSION_TOKEN', '') ### Note same script can be used for AWS Lambda (runtime = python3.6). ## Steps to use this python script for AWS Lambda # 1. AWS_ACCESS_KEY_ID, AWS_SECRET_ACCESS_KEY and AWS_SESSION_TOKEN and AWS_REGION variables are already part of Lambda's Execution environment # No need to set them up explicitly. # 3. Create Lambda deployment package https://docs.aws.amazon.com/lambda/latest/dg/lambda-python-how-to-create-deployment-package.html # 4. Create a Lambda function in the same VPC and assign an IAM role with neptune access def lambda_handler(event, context): # sample_test_input = { # "host": "END_POINT:8182", # "method": "GET", # "query_type": "gremlin", # "query": "g.V().count()" # } # Lambda uses AWS_REGION instead of SERVICE_REGION global region region = os.getenv('AWS_REGION', '') host = event['host'] method = event['method'] query_type = event['query_type'] query = event['query'] return make_signed_request(host, method, query_type, query) def validate_input(method, query_type): # Supporting GET and POST for now: if (method != 'GET' and method != 'POST'): print('First parameter must be "GET" or "POST", but is "' + method + '".') sys.exit() # SPARQL UPDATE requires POST if (method == 'GET' and query_type == 'sparqlupdate'): print('SPARQL UPDATE is not supported in GET mode. Please choose POST.') sys.exit() def get_canonical_uri_and_payload(query_type, query, method): # Set the stack and payload depending on query_type. if (query_type == 'sparql'): canonical_uri = '/sparql/' payload = {'query': query} elif (query_type == 'sparqlupdate'): canonical_uri = '/sparql/' payload = {'update': query} elif (query_type == 'gremlin'): canonical_uri = '/gremlin/' payload = {'gremlin': query} if (method == 'POST'): payload = json.dumps(payload) elif (query_type == 'openCypher'): canonical_uri = '/openCypher/' payload = {'query': query} elif (query_type == "loader"): canonical_uri = "/loader/" payload = query elif (query_type == "status"): canonical_uri = "/status/" payload = {} elif (query_type == "gremlin/status"): canonical_uri = "/gremlin/status/" payload = {} elif (query_type == "openCypher/status"): canonical_uri = "/openCypher/status/" payload = {} elif (query_type == "sparql/status"): canonical_uri = "/sparql/status/" payload = {} else: print( 'Third parameter should be from ["gremlin", "sparql", "sparqlupdate", "loader", "status] but is "' + query_type + '".') sys.exit() ## return output as tuple return canonical_uri, payload def make_signed_request(host, method, query_type, query): service = 'neptune-db' endpoint = protocol + '://' + host print() print('+++++ USER INPUT +++++') print('host = ' + host) print('method = ' + method) print('query_type = ' + query_type) print('query = ' + query) # validate input validate_input(method, query_type) # get canonical_uri and payload canonical_uri, payload = get_canonical_uri_and_payload(query_type, query, method) # assign payload to data or params data = payload if method == 'POST' else None params = payload if method == 'GET' else None # create request URL request_url = endpoint + canonical_uri # create and sign request creds = SimpleNamespace( access_key=access_key, secret_key=secret_key, token=session_token, region=region, ) request = AWSRequest(method=method, url=request_url, data=data, params=params) SigV4Auth(creds, service, region).add_auth(request) r = None # ************* SEND THE REQUEST ************* if (method == 'GET'): print('++++ BEGIN GET REQUEST +++++') print('Request URL = ' + request_url) r = requests.get(request_url, headers=request.headers, verify=False, params=params) elif (method == 'POST'): print('\n+++++ BEGIN POST REQUEST +++++') print('Request URL = ' + request_url) if (query_type == "loader"): request.headers['Content-type'] = 'application/json' r = requests.post(request_url, headers=request.headers, verify=False, data=data) else: print('Request method is neither "GET" nor "POST", something is wrong here.') if r is not None: print() print('+++++ RESPONSE +++++') print('Response code: %d\n' % r.status_code) response = r.text r.close() print(response) return response help_msg = ''' export AWS_ACCESS_KEY_ID=[MY_ACCESS_KEY_ID] export AWS_SECRET_ACCESS_KEY=[MY_SECRET_ACCESS_KEY] export AWS_SESSION_TOKEN=[MY_AWS_SESSION_TOKEN] export SERVICE_REGION=[us-east-1|us-east-2|us-west-2|eu-west-1] python version >=3.6 is required. Examples: For help python3 program_name.py -h Examples: Queries python3 program_name.py -ho your-neptune-endpoint -p 8182 -a GET -q status python3 program_name.py -ho your-neptune-endpoint -p 8182 -a GET -q sparql/status python3 program_name.py -ho your-neptune-endpoint -p 8182 -a GET -q sparql -d "SELECT ?s WHERE { ?s ?p ?o }" python3 program_name.py -ho your-neptune-endpoint -p 8182 -a POST -q sparql -d "SELECT ?s WHERE { ?s ?p ?o }" python3 program_name.py -ho your-neptune-endpoint -p 8182 -a POST -q sparqlupdate -d "INSERT DATA { }" python3 program_name.py -ho your-neptune-endpoint -p 8182 -a GET -q gremlin/status python3 program_name.py -ho your-neptune-endpoint -p 8182 -a GET -q gremlin -d "g.V().count()" python3 program_name.py -ho your-neptune-endpoint -p 8182 -a POST -q gremlin -d "g.V().count()" python3 program_name.py -ho your-neptune-endpoint -p 8182 -a GET -q openCypher/status python3 program_name.py -ho your-neptune-endpoint -p 8182 -a GET -q openCypher -d "MATCH (n1) RETURN n1 LIMIT 1;" python3 program_name.py -ho your-neptune-endpoint -p 8182 -a POST -q openCypher -d "MATCH (n1) RETURN n1 LIMIT 1;" python3 program_name.py -ho your-neptune-endpoint -p 8182 -a GET -q loader -d '{"loadId": "68b28dcc-8e15-02b1-133d-9bd0557607e6"}' python3 program_name.py -ho your-neptune-endpoint -p 8182 -a GET -q loader -d '{}' python3 program_name.py -ho your-neptune-endpoint -p 8182 -a POST -q loader -d '{"source": "source", "format" : "csv", "failOnError": "fail_on_error", "iamRoleArn": "iam_role_arn", "region": "region"}' Environment variables must be defined as AWS_ACCESS_KEY_ID, AWS_SECRET_ACCESS_KEY and SERVICE_REGION. You should also set AWS_SESSION_TOKEN environment variable if you are using temporary credentials (ex. IAM Role or EC2 Instance profile). Current Limitations: - Query mode "sparqlupdate" requires POST (as per the SPARQL 1.1 protocol) ''' def exit_and_print_help(): print(help_msg) exit() def parse_input_and_query_neptune(): parser = ArgumentParser(description=help_msg, formatter_class=RawTextHelpFormatter) group_host = parser.add_mutually_exclusive_group() group_host.add_argument("-ho", "--host", type=str) group_port = parser.add_mutually_exclusive_group() group_port.add_argument("-p", "--port", type=int, help="port ex. 8182, default=8182", default=8182) group_action = parser.add_mutually_exclusive_group() group_action.add_argument("-a", "--action", type=str, help="http action, default = GET", default="GET") group_endpoint = parser.add_mutually_exclusive_group() group_endpoint.add_argument("-q", "--query_type", type=str, help="query_type, default = status ", default="status") group_data = parser.add_mutually_exclusive_group() group_data.add_argument("-d", "--data", type=str, help="data required for the http action", default="") args = parser.parse_args() print(args) # Read command line parameters host = args.host port = args.port method = args.action query_type = args.query_type query = args.data if (access_key == ''): print('!!! ERROR: Your AWS_ACCESS_KEY_ID environment variable is undefined.') exit_and_print_help() if (secret_key == ''): print('!!! ERROR: Your AWS_SECRET_ACCESS_KEY environment variable is undefined.') exit_and_print_help() if (region == ''): print('!!! ERROR: Your SERVICE_REGION environment variable is undefined.') exit_and_print_help() if host is None: print('!!! ERROR: Neptune DNS is missing') exit_and_print_help() host = host + ":" + str(port) make_signed_request(host, method, query_type, query) if __name__ == "__main__": parse_input_and_query_neptune() ``` 1. En un terminal, vaya a la ubicación del archivo `neptunesigv4.py`. 1. Introduzca los siguientes comandos, reemplazando la clave de acceso, la clave secreta y la región por los valores correctos. ``` export AWS_ACCESS_KEY_ID=MY_ACCESS_KEY_ID export AWS_SECRET_ACCESS_KEY=MY_SECRET_ACCESS_KEY export SERVICE_REGION=us-east-1 or us-east-2 or us-west-1 or us-west-2 or ca-central-1 or ca-west-1 or sa-east-1 or eu-north-1 or eu-south-2 or eu-west-1 or eu-west-2 or eu-west-3 or eu-central-1 or me-south-1 or me-central-1 or il-central-1 or af-south-1 or ap-east-1 or ap-northeast-1 or ap-northeast-2 or ap-northeast-3 or ap-southeast-1 or ap-southeast-2 or ap-southeast-3 or ap-southeast-4 or ap-southeast-5 or ap-south-1 or ap-south-2 or cn-north-1 or cn-northwest-1 or us-gov-east-1 or us-gov-west-1 ``` Si está utilizando credenciales temporales, debe especificar `AWS_SESSION_TOKEN` además de `AWS_ACCESS_KEY_ID`, `AWS_SECRET_ACCESS_KEY` y `SERVICE_REGION`. ``` export AWS_SESSION_TOKEN=MY_AWS_SESSION_TOKEN ``` **nota** Si utiliza las credenciales temporales, caducan después de un intervalo especificado, *incluido el token de sesión*. Tiene que actualizar el token de sesión cuando solicite nuevas credenciales. Para obtener más información, consulte [Uso de credenciales de seguridad temporales para solicitar acceso a los recursos de AWS](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_temp_use-resources.html). 1. Introduzca uno de los siguientes comandos para enviar una solicitud firmada a la instancia de base de datos de Neptune. Estos ejemplos utilizan Python versión 3.6. **Estado de punto de enlace** ``` python3.6 neptunesigv4.py -ho your-neptune-endpoint -p 8182 -a GET -q status ``` **Gremlin** ``` python3.6 neptunesigv4.py -ho your-neptune-endpoint -p 8182 -a GET -q gremlin -d "g.V().count()" python3.6 neptunesigv4.py -ho your-neptune-endpoint -p 8182 -a POST -q gremlin -d "g.V().count()" ``` **Estado de Gremlin** ``` python3.6 neptunesigv4.py -ho your-neptune-endpoint -p 8182 -a GET -q gremlin/status ``` **SPARQL** ``` python3.6 neptunesigv4.py -ho your-neptune-endpoint -p 8182 -a GET -q sparql -d "SELECT ?s WHERE { ?s ?p ?o }" ``` **SPARQL UPDATE** ``` python3.6 neptunesigv4.py -ho your-neptune-endpoint -p 8182 -a POST -q sparqlupdate -d "INSERT DATA { }" ``` **Estado de SPARQL** ``` python3.6 neptunesigv4.py -ho your-neptune-endpoint -p 8182 -a GET -q sparql/status ``` **openCypher** ``` python3.6 neptunesigv4.py -ho your-neptune-endpoint -p 8182 -a GET -q openCypher -d "MATCH (n1) RETURN n1 LIMIT 1;" python3.6 neptunesigv4.py -ho your-neptune-endpoint -p 8182 -a POST -q openCypher -d "MATCH (n1) RETURN n1 LIMIT 1;" ``` **Estado de openCypher** ``` python3.6 neptunesigv4.py -ho your-neptune-endpoint -p 8182 -a GET -q openCypher/status ``` **Programa de carga** ``` python3.6 neptunesigv4.py -ho your-neptune-endpoint -p 8182 -a GET -q loader -d '{"loadId": "68b28dcc-8e15-02b1-133d-9bd0557607e6"}' python3.6 neptunesigv4.py -ho your-neptune-endpoint -p 8182 -a GET -q loader -d '{}' python3.6 neptunesigv4.py -ho your-neptune-endpoint -p 8182 -a POST -q loader -d '{"source": "source", "format" : "csv", "failOnError": "fail_on_error", "iamRoleArn": "iam_role_arn", "region": "region"}' ``` 1. La sintaxis para ejecutar el script de Python es la siguiente: ``` python3.6 neptunesigv4.py -ho your-neptune-endpoint -p port -a GET|POST -q gremlin|sparql|sparqlupdate|loader|status -d "string0data" ``` SPARQL UPDATE requiere `POST`. # Conexión a bases de datos de Amazon Neptune mediante la autenticación de IAM con Python de Gremlin ## Descripción general de Esta guía muestra cómo conectarse a una base de datos de Amazon Neptune con la autenticación de IAM habilitada mediante el controlador Gremlin Python, con la autenticación Signature Version 4 y el AWS SDK para Python (Boto3). ## Creación de una conexión básica Utilice el siguiente ejemplo de código como guía para establecer una conexión básica con autenticación de IAM mediante el controlador Python de Gremlin. ``` from boto3 import Session from botocore.auth import SigV4Auth from botocore.awsrequest import AWSRequest from gremlin_python.process.anonymous_traversal import traversal from gremlin_python.driver.driver_remote_connection import DriverRemoteConnection def main(): endpoint = 'your.cluster.endpoint.neptune.amazonaws.com' conn_string = 'wss://' + endpoint + ':8182/gremlin' default_region = 'us-east-1' service = 'neptune-db' credentials = Session().get_credentials() if credentials is None: raise Exception("No AWS credentials found") creds = credentials.get_frozen_credentials() # region set inside config profile or via AWS_DEFAULT_REGION environment variable will be loaded region = Session().region_name if Session().region_name else default_region request = AWSRequest(method='GET', url=conn_string, data=None) SigV4Auth(creds, service, region).add_auth(request) rc = DriverRemoteConnection(conn_string, 'g', headers=request.headers.items()) g = traversal().with_remote(rc) # simple query to verify connection count = g.V().count().next() print('Vertex count: ' + str(count)) # cleanup rc.close() if __name__ == "__main__": main() ``` # Conexión a las bases de datos de Amazon Neptune mediante la autenticación de IAM con Gremlin JavaScript ## Descripción general de Esta guía muestra cómo conectarse a una base de datos de Amazon Neptune con la autenticación de IAM habilitada mediante el JavaScript controlador Gremlin, con la autenticación Signature Version 4 y el AWS SDK para Javascript v3. ## Requisitos previos + Un clúster de Amazon Neptune con la autenticación de IAM habilitada. + [Node 13 o posterior (consulte las versiones mínimas para Gremlin y el SDK para Javascript v3 JavaScript ).AWS](https://docs.aws.amazon.com//AWSJavaScriptSDK/v3/latest/introduction/#release-cadence) + AWS credenciales configuradas (mediante variables de entorno, un archivo de credenciales compartido o una función de IAM). ## Creación de una conexión básica Utilice el siguiente ejemplo de código como guía sobre cómo establecer una conexión básica con la autenticación de IAM mediante el controlador JavaScript Gremlin. ``` const { fromNodeProviderChain } = require('@aws-sdk/credential-providers'); const { getUrlAndHeaders } = require('gremlin-aws-sigv4/lib/utils'); const { loadConfig } = require("@smithy/node-config-provider"); const { NODE_REGION_CONFIG_FILE_OPTIONS, NODE_REGION_CONFIG_OPTIONS } = require("@smithy/config-resolver"); const gremlin = require('gremlin'); const DriverRemoteConnection = gremlin.driver.DriverRemoteConnection; const traversal = gremlin.process.AnonymousTraversalSource.traversal; const DEFAULT_REGION = 'us-east-1'; const getCredentials = async () => { try { // Loads the default credential provider chain return await fromNodeProviderChain(); } catch (e) { console.error("No credentials found", e); throw e; } }; (main = async () => { console.log('Starting'); const credentials = await getCredentials(); try { // region set inside config profile or via AWS_REGION environment variable will be loaded credentials['region'] = await loadConfig(NODE_REGION_CONFIG_OPTIONS, NODE_REGION_CONFIG_FILE_OPTIONS)(); } catch (e) { credentials['region'] = DEFAULT_REGION } const connInfo = getUrlAndHeaders( 'you.cluster.endpoint.neptune.amazonaws.com', '8182', credentials, '/gremlin', 'wss'); const dc = new DriverRemoteConnection(connInfo['url'], {headers: connInfo['headers']}); const g = traversal().withRemote(dc); const query = g.V().limit(5).count(); const count = await query.next(); console.log("Vertex count: " + count.value); await dc.close(); }) main(); ``` # Conexión a bases de datos de Amazon Neptune mediante la autenticación de IAM con Go de Gremlin ## Descripción general de Esta guía muestra cómo conectarse a una base de datos de Amazon Neptune con la autenticación de IAM habilitada mediante el controlador Gremlin Go, con la autenticación Signature versión 4 y el AWS SDK para GO v2. ## Requisitos previos + Un clúster de Amazon Neptune con la autenticación de IAM habilitada. + Go 1.22 o posterior (consulte las versiones mínimas compatibles para [Go de Gremlin](https://pkg.go.dev/github.com/apache/tinkerpop/gremlin-go/v3/driver) y [AWS SDK para Go v2](https://pkg.go.dev/github.com/aws/aws-sdk-go-v2)). + AWS credenciales configuradas (mediante variables de entorno, un archivo de credenciales compartido o una función de IAM) ## Creación de una conexión básica Utilice el siguiente ejemplo de código como guía sobre para establecer una conexión básica con autenticación de IAM mediante el controlador de Go de Gremlin. ``` package main import ( "context" "fmt" "github.com/aws/aws-sdk-go-v2/config" "net/http" "strings" "time" gremlingo "github.com/apache/tinkerpop/gremlin-go/v3/driver" v4 "github.com/aws/aws-sdk-go-v2/aws/signer/v4" ) const emptyStringSHA256 = `e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855` func main() { neptuneEndpoint := "you.cluster.endpoint.neptune.amazonaws.com" connString := "wss://" + neptuneEndpoint + ":8182/gremlin" service := "neptune-db" defaultRegion := "us-east-1" // Create request to sign req, err := http.NewRequest(http.MethodGet, connString, strings.NewReader("")) if err != nil { fmt.Println(err) return } // Loads the default config with default credentials provider // See https://github.com/aws/aws-sdk-go-v2 for additional docs on API usage cfg, err := config.LoadDefaultConfig(context.TODO()) if err != nil { fmt.Println(err) return } // Retrieve loaded credentials cr, err := cfg.Credentials.Retrieve(context.TODO()) if err != nil { fmt.Println(err) return } region := defaultRegion if cfg.Region != "" { // region set inside config profile, or via AWS_REGION or AWS_DEFAULT_REGION environment variable will be loaded region = cfg.Region } signer := v4.NewSigner() // Sign request err = signer.SignHTTP(context.TODO(), cr, req, emptyStringSHA256, service, "us-east-2", time.Now()) if err != nil { fmt.Println(err) return } // Pass the signed request header into gremlingo.HeaderAuthInfo() driverRemoteConnection, err := gremlingo.NewDriverRemoteConnection(connString, func(settings *gremlingo.DriverRemoteConnectionSettings) { settings.TraversalSource = "g" settings.AuthInfo = gremlingo.HeaderAuthInfo(req.Header) // settings.TlsConfig = &tls.Config{InsecureSkipVerify: true} // Use this only if you're on a Mac running Go 1.18+ doing local dev. See https://github.com/golang/go/issues/51991 }) if err != nil { fmt.Println(err) return } // Cleanup defer driverRemoteConnection.Close() // Creating graph traversal g := gremlingo.Traversal_().WithRemote(driverRemoteConnection) // Query execution count, err := g.V().Limit(5).Count().Next() if err != nil { fmt.Println(err) return } fmt.Println("Vertex count:", *count) } ``` ## Actualización dinámica de credenciales de Go de Gremlin Gremlin Go permite insertar un puntero de función para recuperar las credenciales y generar el encabezado, lo que evita que el encabezado caduque en el caso de conexiones de larga duración. DynamicAuth ``` package main import ( "context" "crypto/tls" "fmt" "github.com/aws/aws-sdk-go-v2/config" "net/http" "strings" "time" gremlingo "github.com/apache/tinkerpop/gremlin-go/v3/driver" v4 "github.com/aws/aws-sdk-go-v2/aws/signer/v4" ) const emptyStringSHA256 = `e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855` func main() { neptuneEndpoint := "you.cluster.endpoint.neptune.amazonaws.com" connString := "wss://" + neptuneEndpoint + ":8182/gremlin" service := "neptune-db" defaultRegion := "us-east-1" //Create the request to sign req, err := http.NewRequest(http.MethodGet, connString, strings.NewReader("")) if err != nil { fmt.Println(err) return } // Loads the default config with default credentials provider // See https://github.com/aws/aws-sdk-go-v2 for additional docs on API usage cfg, err := config.LoadDefaultConfig(context.TODO()) if err != nil { fmt.Println(err) return } region := defaultRegion if cfg.Region != "" { // region set inside config profile, or via AWS_REGION or AWS_DEFAULT_REGION environment variable will be loaded region = cfg.Region } signer := v4.NewSigner() // This is the function that will be used for dynamic refreseh of credentials and signed headers gen := func() gremlingo.AuthInfoProvider { // Retrieve loaded credentials cr, err := cfg.Credentials.Retrieve(context.TODO()) fmt.Println("AWS Credentials: ", cr) if err != nil { fmt.Println(err) return } // Sign request err = signer.SignHTTP(context.TODO(), cr, req, emptyStringSHA256, service, region, time.Now()) if err != nil { fmt.Println(err) return } fmt.Println(req.Header) return gremlingo.HeaderAuthInfo(req.Header) } // Pass the function into gremlingo.NewDynamicAuth(), which will generate the AuthInfoProvider to pass into gremlingo.DriverRemoteConnectionSettings below auth := gremlingo.NewDynamicAuth(gen) driverRemoteConnection, err := gremlingo.NewDriverRemoteConnection(connString, func(settings *gremlingo.DriverRemoteConnectionSettings) { settings.TraversalSource = "g" settings.AuthInfo = auth // settings.TlsConfig = &tls.Config{InsecureSkipVerify: true} // Use this only if you're on a Mac running Go 1.18+ doing local dev. See https://github.com/golang/go/issues/51991 }) if err != nil { fmt.Println(err) return } // Cleanup defer driverRemoteConnection.Close() // Creating graph traversal g := gremlingo.Traversal_().WithRemote(driverRemoteConnection) // Query execution count, err := g.V().Limit(5).Count().Next() if err != nil { fmt.Println(err) return } fmt.Println("Vertex count:", *count) } ``` # Conexión a bases de datos de Amazon Neptune mediante la autenticación de IAM con .NET de Gremlin ## Descripción general de Esta guía muestra cómo conectarse a una base de datos de Amazon Neptune con la autenticación de IAM habilitada mediante el controlador Gremlin.NET, con la autenticación Signature Version 4 y el SDK para .NET AWS v3. ## Creación de una conexión básica [Para conectarse a Gremlin.NET, utilice el archivo `SigV4RequestSigner` fuente de la biblioteca personalizada -sigv4. https://github.com/aws/ amazon-neptune-gremlin-dotnet](https://github.com/aws/amazon-neptune-gremlin-dotnet-sigv4) Un ejemplo de configuración de proyecto se encuentra en [ https://github.com/aws/amazon-neptune-gremlin-dotnettree/main/example-sigv4/](https://github.com/aws/amazon-neptune-gremlin-dotnet-sigv4/tree/main/example) y se refleja a continuación. Archivo de proyecto: ``` Exe netcoreapp8.0 ``` Programa de ejemplo: ``` using System; using System.Collections.Generic; using System.Net.WebSockets; using System.Linq; using System.Net.Http; using System.Security.Cryptography; using System.Text; using System.Threading; using System.Threading.Tasks; using System.Web; using Gremlin.Net; using Gremlin.Net.Driver; using Gremlin.Net.Driver.Remote; using Gremlin.Net.Process; using Gremlin.Net.Process.Traversal; using Gremlin.Net.Structure; using static Gremlin.Net.Process.Traversal.AnonymousTraversalSource; using static Gremlin.Net.Process.Traversal.__; using static Gremlin.Net.Process.Traversal.P; using static Gremlin.Net.Process.Traversal.Order; using static Gremlin.Net.Process.Traversal.Operator; using static Gremlin.Net.Process.Traversal.Pop; using static Gremlin.Net.Process.Traversal.Scope; using static Gremlin.Net.Process.Traversal.TextP; using static Gremlin.Net.Process.Traversal.Column; using static Gremlin.Net.Process.Traversal.Direction; using static Gremlin.Net.Process.Traversal.T; using Amazon.Runtime.CredentialManagement; using Amazon.Runtime; using Amazon; using Amazon.Util; using Amazon.Neptune.Gremlin.Driver; namespace NeptuneExample { class Program { static void Main(string[] args) { /* Include your Neptune endpoint and port below. */ var neptune_host = "neptune-endpoint"; // ex: mycluster.cluster.us-east-1.neptune.amazonaws.com var neptune_port = 8182; var gremlinServer = new GremlinServer(neptune_host, neptune_port); var gremlinClient = new GremlinClient(gremlinServer, webSocketConfiguration: new SigV4RequestSigner().signRequest(neptune_host, neptune_port)); var remoteConnection = new DriverRemoteConnection(gremlinClient); var g = Traversal().WithRemote(remoteConnection); /* Example code to pull the first 5 vertices in a graph. */ Console.WriteLine("Get List of Node Labels:"); Int32 limitValue = 5; var output = g.V().Limit(limitValue).ToList(); foreach(var item in output) { Console.WriteLine(item); } } } } ```