Les traductions sont fournies par des outils de traduction automatique. En cas de conflit entre le contenu d'une traduction et celui de la version originale en anglais, la version anglaise prévaudra. # Connexion à votre base de données Amazon Neptune à l'aide de l'authentification Gestion des identités et des accès AWS Les ressources Amazon Neptune pour lesquelles l'authentification IAM DB est activée nécessitent que toutes les requêtes HTTP soient signées à l'aide de AWS Signature Version 4. Pour obtenir des informations générales sur les demandes de AWS signature avec Signature version 4, consultez [la section Signing AWS API requests](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_aws-signing.html). AWS Signature Version 4 est le processus permettant d'ajouter des informations d'authentification aux AWS demandes. Pour des raisons de sécurité, la plupart des demandes AWS doivent être signées avec une clé d'accès, qui consiste en un identifiant de clé d'accès et une clé d'accès secrète. **Note** Si vous utilisez des informations d'identification temporaires, celles-ci expirent après un intervalle spécifique, *y compris le jeton de session*. Vous devez mettre à jour votre jeton de session lorsque vous demandez de nouvelles informations d'identification. Pour plus d'informations, consultez la section [Utilisation d'informations d'identification de sécurité temporaires pour demander l'accès aux AWS ressources](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_temp_use-resources.html). **Important** L'accès à Neptune avec l'authentification IAM exige que vous créiez des demandes HTTP et que vous les signiez vous-même. **Fonctionnement de Signature Version 4** 1. Vous créez une demande canonique. 1. Vous utilisez la demande canonique et d'autres informations pour créer un string-to-sign. 1. Vous utilisez votre clé d'accès AWS secrète pour obtenir une clé de signature, puis vous utilisez cette clé de signature string-to-sign pour créer une signature. 1. Vous ajoutez la signature obtenue à la demande HTTP dans un en-tête ou en tant que paramètre de chaîne de requête. Lorsque Neptune reçoit la demande, ce service exécute les mêmes étapes que celles que vous avez suivies pour calculer la signature. Neptune compare ensuite la signature calculée à celle que vous avez envoyée avec la demande. Si les signatures correspondent, la demande est traitée. Si les signatures ne correspondent pas, la demande est rejetée. Pour des informations générales sur les demandes de AWS signature avec la version 4 de [Signature, voir Processus de signature de la version 4](https://docs.aws.amazon.com/general/latest/gr/signature-version-4.html) dans le *Références générales AWS*. Les sections suivantes contiennent des exemples qui illustrent l'envoi de demandes signées aux points de terminaison Gremlin et SPARQL d'une instance de base de données Neptune avec l'authentification IAM activée. **Topics** + [Conditions requises pour connecter les bases de données Amazon Neptune à l'aide de l'authentification IAM](iam-auth-connect-prerq.md) + [Connexion aux bases de données Amazon Neptune à l'aide de l'authentification IAM depuis la ligne de commande](iam-auth-connect-command-line.md) + [Connexion aux bases de données Amazon Neptune à l'aide de l'authentification IAM avec la console Gremlin](iam-auth-connecting-gremlin-console.md) + [Connexion aux bases de données Amazon Neptune à l'aide d'IAM avec Gkremlin Java](iam-auth-connecting-gremlin-java.md) + [Connexion aux bases de données Amazon Neptune à l'aide de l'authentification IAM avec Java et SPARQL](iam-auth-connecting-sparql-java.md) + [Connexion aux bases de données Amazon Neptune à l'aide de l'authentification IAM avec SPARQL et Node.js](iam-auth-connecting-sparql-node.md) + [Connexion aux bases de données Amazon Neptune à l'aide de l'authentification IAM avec Python](iam-auth-connecting-python.md) + [Connexion aux bases de données Amazon Neptune à l'aide de l'authentification IAM avec Gremlin Python](gremlin-python-iam-auth.md) + [Connexion aux bases de données Amazon Neptune à l'aide de l'authentification IAM avec G705 JavaScript](gremlin-javascript-iam-auth.md) + [Connexion aux bases de données Amazon Neptune à l'aide de l'authentification IAM avec Gremlin Go](gremlin-go-iam-auth.md) + [Connexion aux bases de données Amazon Neptune à l'aide de l'authentification IAM avec Gremlin .NET](gremlin-dotnet-iam-auth.md) # Conditions requises pour connecter les bases de données Amazon Neptune à l'aide de l'authentification IAM Voici les instructions d'installation d'Apache Maven et de Java 8 sur une instance Amazon EC2. Elles sont nécessaires pour les exemples d'authentification avec Amazon Neptune Signature Version 4. **Pour installer Apache Maven et Java 8 sur votre instance EC2** 1. Connectez-vous à votre instance Amazon EC2 avec un client SSH. 1. Installez Apache Maven sur votre instance EC2. Si vous utilisez Amazon Linux 2023 (de préférence), utilisez : ``` sudo dnf update -y sudo dnf install maven -y ``` Si vous utilisez Amazon Linux 2, téléchargez le dernier fichier binaire [sur 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. Les bibliothèques Gremlin nécessitent Java 8. Entrez ce qui suit pour installer Java 8 sur votre instance EC2. ``` sudo yum install java-1.8.0-devel ``` 1. Entrez la commande suivante pour définir Java 8 en tant qu'exécution par défaut sur votre instance EC2. ``` sudo /usr/sbin/alternatives --config java ``` Lorsque vous y êtes invité, saisissez le nombre pour Java 8. 1. Saisissez la commande suivante pour définir Java 8 en tant que compilateur par défaut de votre instance EC2. ``` sudo /usr/sbin/alternatives --config javac ``` Lorsque vous y êtes invité, saisissez le nombre pour Java 8. # Connexion aux bases de données Amazon Neptune à l'aide de l'authentification IAM depuis la ligne de commande Il est particulièrement utile d'avoir recours à un outil en ligne de commande pour envoyer des requêtes à votre cluster de bases de données Neptune, comme l'illustrent de nombreux exemples dans cette documentation. L'outil [curl](https://curl.haxx.se/) est une excellente option pour communiquer avec les points de terminaison Neptune si l'authentification IAM n'est pas activée. **Toutefois, pour garantir la sécurité de vos données, il est préférable d'activer l'authentification IAM.** Lorsque l'authentification de base de données IAM est activée, chaque demande doit être [signée à l'aide de Signature Version 4 (Sig4)](https://docs.aws.amazon.com/general/latest/gr/signing-aws-api-requests.html). L'outil de ligne de commande tiers [awscurl](https://github.com/okigan/awscurl) utilise la même syntaxe que `curl` et peut signer les requêtes à l'aide de la signature Sig4. La section [Utilisation de `awscurl`](#iam-auth-connect-awscurl) ci-dessous explique comment utiliser `awscurl` en toute sécurité avec des informations d'identification temporaires. ## Configuration d'un outil de ligne de commande pour utiliser le protocole HTTPS Neptune exige que toutes les connexions utilisent le protocole HTTPS. Tout outil de ligne de commande comme `curl` ou `awscurl` doit accéder aux certificats appropriés pour pouvoir utiliser le protocole HTTPS. Dans la mesure où `curl` ou `awscurl` peut localiser les certificats appropriés, il gère les connexions HTTPS comme des connexions HTTP, sans paramètres supplémentaires. Les exemples de cette documentation sont basés sur ce scénario. Pour découvrir comment obtenir ces certificats et comment les mettre correctement en forme dans un magasin de certificats CA utilisable par `curl`, consultez [SSL Certificate Verification (Vérification des certificats SSL)](https://curl.haxx.se/docs/sslcerts.html) dans la documentation `curl`. Vous pouvez ensuite spécifier l'emplacement de ce magasin de certificats CA à l'aide de la variable d'environnement `CURL_CA_BUNDLE`. Sous Windows, `curl` le recherche automatiquement dans un fichier nommé `curl-ca-bundle.crt`. Il examine d'abord dans le même répertoire que `curl.exe`, puis ailleurs sur le chemin. Pour plus d’informations, consultez [SSL Certificate Verification (Vérification des certificats SSL)](https://curl.haxx.se/docs/sslcerts.html). ## Utilisation d'informations d'identification temporaires `awscurl` pour se connecter en toute sécurité à un cluster de bases de données avec l'authentification IAM activée L'outil [awscurl](https://github.com/okigan/awscurl) utilise la même syntaxe que `curl`, mais nécessite également des informations supplémentaires : + **`--access_key`** : clé d'accès valide. Si cet élément n'est pas fourni à l'aide de ce paramètre, il doit être fourni dans la variable d'environnement `AWS_ACCESS_KEY_ID` ou dans un fichier de configuration. + **`--secret_key`** : clé secrète valide qui correspond à la clé d'accès. Si cet élément n'est pas fourni à l'aide de ce paramètre, il doit être fourni dans la variable d'environnement `AWS_SECRET_ACCESS_KEY` ou dans un fichier de configuration. + **`--security_token`** : jeton de session valide. Si cet élément n'est pas fourni à l'aide de ce paramètre, il doit être fourni dans la variable d'environnement `AWS_SECURITY_TOKEN` ou dans un fichier de configuration. Auparavant, il était courant d'utiliser des informations d'identification persistantes avec `awscurl`, telles que les informations d'identification utilisateur IAM ou même les informations d'identification root, mais cela n'est pas recommandé. Générez plutôt des informations d'identification temporaires à l'aide de l'un des [AWS Security Token Service (STS) APIs](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_temp_request.html) ou de l'un de ses [AWS CLI wrappers.](https://docs.aws.amazon.com/cli/latest/reference/sts/index.html) Il est préférable de placer les valeurs `AccessKeyId`, `SecretAccessKey` et `SessionToken` renvoyées par l'appel STS dans les variables d'environnement appropriées de la session shell plutôt que dans un fichier de configuration. Lorsque le shell se terminera, les informations d'identification seront automatiquement supprimées, ce qui n'est pas le cas avec un fichier de configuration. De même, ne demandez pas une durée plus longue que celle dont vous aurez probablement besoin pour les informations d'identification temporaires. L'exemple suivant présente les étapes que vous pouvez suivre dans un shell Linux pour obtenir des informations d'identification temporaires valables pendant une demi-heure à l'aide de [sts assume-role](https://docs.aws.amazon.com/cli/latest/reference/sts/assume-role), puis pour les placer dans des variables d'environnement où `awscurl` peux les trouver : ``` 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 ``` Vous pouvez ensuite utiliser `awscurl` pour envoyer une demande signée au cluster de bases de données comme suit : ``` awscurl (your cluster endpoint):8182/status \ --region us-east-1 \ --service neptune-db ``` # Connexion aux bases de données Amazon Neptune à l'aide de l'authentification IAM avec la console Gremlin Pour vous connecter à Amazon Neptune à l'aide de la console Gremlin avec authentification Signature Version 4, vous devez `requestInterceptor()` connecter un signataire SigV4 à la connexion établie par la commande. `:remote` Cela nécessite que vous configuriez l'`Cluster`objet manuellement, puis que vous le transmettiez à la `:remote` commande. Notez que cela est très différent de la situation typique où la commande `:remote` utilise un fichier de configuration pour établir la connexion. L'approche utilisant le fichier de configuration ne fonctionne pas, car `requestInterceptor()` doit être défini par programmation et ne peut pas charger sa configuration à partir d'un fichier. **Note** Les exemples suivants utilisent`requestInterceptor()`, qui a été introduit dans la version TinkerPop 3.6.6. Si vous utilisez une TinkerPop version antérieure à 3.6.6 (mais 3.5.5 ou supérieure), utilisez `handshakeInterceptor()` plutôt que `requestInterceptor()` dans les exemples de code ci-dessous. Les prérequis suivants sont nécessaires : + Vous devez fournir les informations d'identification IAM nécessaires pour signer les demandes. Consultez la section [Utilisation de la chaîne de fournisseurs d'informations d'identification par défaut](https://docs.aws.amazon.com//sdk-for-java/latest/developer-guide/credentials-chain.html) dans le Guide du AWS SDK pour Java développeur. + Vous devez avoir installé une version de la console Gremlin compatible avec la version du moteur Neptune utilisée par le cluster de bases de données. Si vous utilisez des informations d'identification temporaires, elles expirent après un intervalle spécifié, tout comme le jeton de session. Vous devez donc mettre à jour le jeton de session lorsque vous demandez de nouvelles informations d'identification. Consultez la section [Utilisation d'informations d'identification de sécurité temporaires pour demander l'accès aux AWS ressources](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_temp_use-resources.html) dans le guide de l'utilisateur IAM. Pour obtenir de l'aide sur la connexion via SSL/TLS, consultez [Configuration SSL/TLS](access-graph-gremlin-java.md#access-graph-gremlin-java-ssl). **Connect la console G705 avec la signature Sig4** 1. Démarrez la console Gremlin : ``` $ bin/gremlin.sh ``` 1. À l'invite `gremlin>`, installez la bibliothèque `amazon-neptune-sigv4-signer` (cette opération ne doit être effectuée qu'une seule fois pour la console) : ``` :install com.amazonaws amazon-neptune-sigv4-signer 2.4.0 ``` Si vous rencontrez des problèmes lors de cette étape, il peut être utile de consulter la [TinkerPop documentation relative](https://tinkerpop.apache.org/docs/current/reference/#gremlin-applications) à la configuration de [Grape](http://docs.groovy-lang.org/latest/html/documentation/grape.html). **Note** Si vous utilisez un proxy HTTP, vous risquez de rencontrer des erreurs lors de cette étape où la commande `:install` ne s’exécute pas. Afin de résoudre ce problème, exécutez les commandes suivantes pour informer la console de l’existence du proxy : ``` System.setProperty("https.proxyHost", "(the proxy IP address)") System.setProperty("https.proxyPort", "(the proxy port)") ``` 1. Importez la classe requise pour gérer la signature dans `requestInterceptor()` : ``` :import software.amazon.awssdk.auth.credentials.DefaultCredentialsProvider :import com.amazonaws.neptune.auth.NeptuneNettyHttpSigV4Signer ``` 1. Si vous utilisez des informations d'identification temporaires, vous devrez également fournir votre jeton de session comme suit : ``` System.setProperty("aws.sessionToken","(your session token)") ``` 1. Si vous n'avez pas encore établi les informations d'identification de votre compte, vous pouvez les attribuer comme suit : ``` System.setProperty("aws.accessKeyId","(your access key)") System.setProperty("aws.secretKey","(your secret key)") ``` 1. Construisez manuellement l'objet `Cluster` à connecter à Neptune : ``` cluster = Cluster.build("(host name)") \ .enableSsl(true) \ .requestInterceptor { r -> \ def sigV4Signer = new NeptuneNettyHttpSigV4Signer("(Amazon region)", \ DefaultCredentialsProvider.create()); \ sigV4Signer.signRequest(r); \ return r; } \ .create() ``` Pour découvrir comment trouver le nom d'hôte de l'instance de base de données Neptune, consultez [Connexion aux points de terminaison Amazon Neptune](feature-overview-endpoints.md). 1. Pour établir la connexion `:remote`, utilisez le nom de variable de l'objet `Cluster` à l'étape précédente : ``` :remote connect tinkerpop.server cluster ``` 1. Entrez la commande suivante pour passer en mode distant. Toutes les requêtes Gremlin sont alors envoyées à la connexion distante. ``` :remote console ``` # Connexion aux bases de données Amazon Neptune à l'aide d'IAM avec Gkremlin Java Voici un exemple de connexion à Neptune à l'aide de l'API Java Gkremlin avec signature Sig4 (cela suppose des connaissances générales sur l'utilisation de Maven). Cet exemple utilise la bibliothèque [Amazon Neptune SigV4 Signer](https://github.com/aws/amazon-neptune-sigv4-signer) pour faciliter la signature des demandes. Définissez d'abord les dépendances dans le cadre du fichier `pom.xml` : **Note** Les exemples suivants utilisent`requestInterceptor()`, qui a été introduit dans la version TinkerPop 3.6.6. Si vous utilisez une TinkerPop version antérieure à 3.6.6 (mais 3.5.5 ou supérieure), utilisez `handshakeInterceptor()` plutôt que `requestInterceptor()` dans les exemples de code ci-dessous. ``` com.amazonaws amazon-neptune-sigv4-signer 3.1.0 ``` Amazon Neptune SigV4 Signer prend en charge les versions 1.x et 2.x du SDK Java. AWS Les exemples suivants utilisent 2.x, où `DefaultCredentialsProvider` est une `software.amazon.awssdk.auth.credentials.AwsCredentialsProvider` instance. Si vous passez de la version 1.x à la version 2.x, consultez les [modifications apportées au fournisseur d'informations d'identification](https://docs.aws.amazon.com//sdk-for-java/latest/developer-guide/migration-client-credentials.html) dans la documentation du 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); } ``` ## Authentification IAM entre comptes [Amazon Neptune prend en charge l'authentification IAM entre comptes grâce à l'utilisation de l'hypothèse de rôles, parfois appelée chaînage de rôles.](https://docs.aws.amazon.com//neptune/latest/userguide/bulk-load-tutorial-chain-roles.html#bulk-load-tutorial-chain-cross-account) Pour donner accès à un cluster Neptune à partir d'une application hébergée sur un autre AWS compte, procédez comme suit : + Créez un nouvel utilisateur ou rôle IAM dans le AWS compte d'application, avec une politique de confiance qui permet à l'utilisateur ou au rôle d'assumer un autre rôle IAM. Attribuez ce rôle au calcul hébergeant l'application (instance EC2, fonction Lambda, tâche ECS, etc.). ------ #### [ JSON ] **** ``` { "Version":"2012-10-17", "Statement": [ { "Sid": "assumeRolePolicy", "Effect": "Allow", "Action": "sts:AssumeRole", "Resource": "arn:aws:iam::111122223333:role/role-name" } ] } ``` ------ + Créez un nouveau rôle IAM dans le compte de base de données Neptune qui permet d'accéder à la AWS base de données Neptune et d'assumer un rôle à partir du compte d'application IAM utilisateur/rôle. Utilisez une politique de confiance basée sur : ------ #### [ JSON ] **** ``` { "Version":"2012-10-17", "Statement": [ { "Effect": "Allow", "Principal": { "AWS": [ "(ARN of application account IAM user or role)" ] }, "Action": "sts:AssumeRole", "Condition": {} } ] } ``` ------ + Utilisez l'exemple de code suivant pour savoir comment utiliser ces deux rôles pour autoriser l'application à accéder à Neptune. Dans cet exemple, le rôle du compte d'application sera assumé via le [DefaultCredentialProviderChain](https://docs.aws.amazon.com//sdk-for-java/v1/developer-guide/credentials.html)lors de la création du`STSclient`. `STSclient`Il est ensuite utilisé via le `STSAssumeRoleSessionCredentialsProvider` pour assumer le rôle hébergé dans le compte de base AWS de données 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(); } ``` # Connexion aux bases de données Amazon Neptune à l'aide de l'authentification IAM avec Java et SPARQL Cette section explique comment se connecter à Neptune en utilisant RDF4 J ou Apache Jena avec l'authentification Signature Version 4. **Conditions préalables** + Java 8 ou une version ultérieure. + Apache Maven 3.3 ou version ultérieure. Pour plus d'informations sur l'installation de ces logiciels prérequis sur une instance EC2 exécutant Amazon Linux, consultez [Conditions requises pour connecter les bases de données Amazon Neptune à l'aide de l'authentification IAM](iam-auth-connect-prerq.md). + Informations d'identification IAM pour signer les demandes. Pour plus d'informations, consultez [Utilisation de la chaîne de fournisseur d'informations d'identification par défaut](https://docs.aws.amazon.com/sdk-for-java/v1/developer-guide/credentials.html#credentials-default) dans le *Manuel du développeur AWS SDK pour Java *. **Note** Si vous utilisez des informations d'identification temporaires, celles-ci expirent après un intervalle spécifique, *y compris le jeton de session*. Vous devez mettre à jour votre jeton de session lorsque vous demandez de nouvelles informations d'identification. Pour plus d'informations, consultez la section [Utilisation d'informations d'identification de sécurité temporaires pour demander l'accès aux AWS ressources](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_temp_use-resources.html) dans le *guide de l'utilisateur IAM*. + Définissez la variable `SERVICE_REGION` sur l'une des valeurs suivantes, en indiquant la région de votre instance de base de données Neptune : + USA Est (Virginie du Nord) : `us-east-1` + USA Est (Ohio) : `us-east-2` + USA Ouest (Californie du Nord) : `us-west-1` + USA Ouest (Oregon) : `us-west-2` + Canada (Centre) : `ca-central-1` + Canada-Ouest (Calgary) : `ca-west-1` + Amérique du Sud (São Paulo) : `sa-east-1` + Europe (Stockholm) : `eu-north-1` + Europe (Espagne) : `eu-south-2` + Europe (Irlande) : `eu-west-1` + Europe (Londres) : `eu-west-2` + Europe (Paris) : `eu-west-3` + Europe (Francfort) : `eu-central-1` + Moyen-Orient (Bahreïn) : `me-south-1` + Moyen-Orient (EAU) : `me-central-1` + Israël (Tel Aviv) : `il-central-1` + Afrique (Le Cap) : `af-south-1` + Asie-Pacifique (Hong Kong) : `ap-east-1` + Asie-Pacifique (Tokyo) : `ap-northeast-1` + Asie-Pacifique (Séoul) : `ap-northeast-2` + Asie-Pacifique (Osaka) : `ap-northeast-3` + Asie-Pacifique (Singapour) : `ap-southeast-1` + Asie-Pacifique (Sydney) : `ap-southeast-2` + Asie-Pacifique (Jakarta) : `ap-southeast-3` + Asie-Pacifique (Melbourne) : `ap-southeast-4` + Asie-Pacifique (Malaisie) : `ap-southeast-5` + Asie-Pacifique (Mumbai) : `ap-south-1` + Asie-Pacifique (Hyderabad) : `ap-south-2` + Chine (Beijing) : `cn-north-1` + Chine (Ningxia) : `cn-northwest-1` + AWS GovCloud (US-Ouest) : `us-gov-west-1` + AWS GovCloud (USA Est) : `us-gov-east-1` **Pour vous connecter à Neptune en utilisant RDF4 J ou Apache Jena avec signature Signature Version 4** 1. Clonez le référentiel d'échantillons à partir de GitHub. ``` git clone https://github.com/aws/amazon-neptune-sparql-java-sigv4.git ``` 1. Accédez au répertoire cloné. ``` cd amazon-neptune-sparql-java-sigv4 ``` 1. Obtenez la dernière version du projet en vérifiant la branche avec la dernière balise. ``` git checkout $(git describe --tags `git rev-list --tags --max-count=1`) ``` 1. Saisissez l'une des commandes suivantes pour compiler et exécuter l'exemple de code. *your-neptune-endpoint*Remplacez-le par le nom d'hôte ou l'adresse IP de votre instance de base de données Neptune. La valeur par défaut du port est 8182. **Note** Consultez la section [Connexion aux points de terminaison Amazon Neptune](feature-overview-endpoints.md) pour découvrir comment trouver le nom d'hôte de votre instance de base de données Neptune. **Éclipse RDF4 J** Entrez ce qui suit pour exécuter l'exemple 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** Saisissez la commande suivante pour exécuter l'exemple Apache Jena. ``` mvn compile exec:java \ -Dexec.mainClass="com.amazonaws.neptune.client.jena.NeptuneJenaSigV4Example" \ -Dexec.args="https://your-neptune-endpoint:port" ``` 1. Pour afficher le code source de l'exemple, consultez les exemples du répertoire `src/main/java/com/amazonaws/neptune/client/`. Pour utiliser le pilote de signature SigV4 dans votre propre application Java, ajoutez le package Maven `amazon-neptune-sigv4-signer` à la section `` de votre fichier `pom.xml`. Nous vous recommandons d'utiliser les exemples comme point de départ. # Connexion aux bases de données Amazon Neptune à l'aide de l'authentification IAM avec SPARQL et Node.js ## Interrogation à l'aide de la signature Signature V4 et du AWS SDK pour Javascript V3 Voici un exemple de connexion à Neptune SPARQL à l'aide de Node.js avec l'authentification Signature Version 4 et le AWS SDK pour 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); } ); } ``` ## Interrogation à l'aide de la signature Signature V4 et du AWS SDK pour Javascript V2 Voici un exemple de connexion à Neptune SPARQL à l'aide de Node.js avec l'authentification Signature Version 4 et le AWS SDK pour 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); }); } ``` # Connexion aux bases de données Amazon Neptune à l'aide de l'authentification IAM avec Python Cette section présente un exemple de programme écrit en Python qui décrit l'utilisation de Signature Version 4 pour Amazon Neptune. Cet exemple est basé sur les exemples dans la section [Signature Version 4 Signing Process (Processus de signature de la signature Version 4)](https://docs.aws.amazon.com/general/latest/gr/sigv4-signed-request-examples.html) dans le *Référence générale d'Amazon Web Services*. Pour utiliser cet exemple de programme, vous avez besoin des éléments suivants : + Python 3.x installé sur votre ordinateur, que vous pouvez obtenir à partir du [site Python](https://www.python.org/downloads/). Ces programmes ont été testés avec Python 3.6. + La [bibliothèque de demandes Python](https://pypi.python.org/pypi/requests), qui est utilisée dans l'exemple de script pour créer des demandes web. Un moyen simple d'installer des packages Python consiste à utiliser `pip`, qui obtient les packages à partir du site d'index des packages Python. Vous pouvez installer `requests` en exécutant `pip install requests` dans la ligne de commande. + Une clé d'accès (ID de clé d'accès et clé d'accès secrète) dans les variables d'environnement nommées `AWS_ACCESS_KEY_ID` et `AWS_SECRET_ACCESS_KEY`. Comme bonne pratique, nous vous recommandons *de ne pas* incorporer d’informations d’identification dans le code. Pour plus d’informations, veuillez consulter la rubrique [Bonnes pratiques pour les comptes AWS](https://docs.aws.amazon.com//accounts/latest/reference/best-practices.html) dans le *Guide de référence Gestion de compte AWS *. Région de votre cluster de bases de données Neptune dans une variable d'environnement désignée `SERVICE_REGION`. Si vous utilisez des informations d'identification temporaires, vous devez spécifier `AWS_SESSION_TOKEN` en plus de `AWS_ACCESS_KEY_ID`, `AWS_SECRET_ACCESS_KEY` et `SERVICE_REGION`. **Note** Si vous utilisez des informations d'identification temporaires, celles-ci expirent après un intervalle spécifique, *y compris le jeton de session*. Vous devez mettre à jour votre jeton de session lorsque vous demandez de nouvelles informations d'identification. Pour plus d'informations, consultez [Utilisation d'informations d'identification de sécurité temporaires pour demander l'accès aux ressources AWS](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_temp_use-resources.html). L'exemple suivant montre comment envoyer des demandes signées à Neptune avec Python. La demande exécute une demande GET ou POST. Les informations d'authentification sont transmises à l'aide de l'en-tête de demande `Authorization`. Cet exemple fonctionne également en tant que AWS Lambda fonction. Pour de plus amples informations, veuillez consulter [Configuration de AWS Lambda pour l'authentification Neptune IAM](iam-auth-temporary-credentials.md#iam-auth-temporary-credentials-lambda). **Pour envoyer des demandes signées aux points de terminaison Gremlin et SPARQL Neptune** 1. Créez un fichier nommé `neptunesigv4.py` et ouvrez-le dans un éditeur de texte. 1. Copiez le code suivant et collez-le dans le fichier `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. Dans un terminal, accédez à l'emplacement du fichier `neptunesigv4.py`. 1. Saisissez les commandes suivantes en remplaçant la clé d'accès, la clé secrète et la région par les valeurs correctes. ``` 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 vous utilisez des informations d'identification temporaires, vous devez spécifier `AWS_SESSION_TOKEN` en plus de `AWS_ACCESS_KEY_ID`, `AWS_SECRET_ACCESS_KEY` et `SERVICE_REGION`. ``` export AWS_SESSION_TOKEN=MY_AWS_SESSION_TOKEN ``` **Note** Si vous utilisez des informations d'identification temporaires, celles-ci expirent après un intervalle spécifique, *y compris le jeton de session*. Vous devez mettre à jour votre jeton de session lorsque vous demandez de nouvelles informations d'identification. Pour plus d'informations, consultez [Utilisation d'informations d'identification de sécurité temporaires pour demander l'accès aux ressources AWS](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_temp_use-resources.html). 1. Saisissez l'une des commandes suivantes pour envoyer une demande signée à l'instance de base de données Neptune. Ces exemples utilisent Python version 3.6. **Statut du point de terminaison** ``` 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()" ``` **Statut 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 { }" ``` **Statut 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;" ``` **Statut openCypher** ``` python3.6 neptunesigv4.py -ho your-neptune-endpoint -p 8182 -a GET -q openCypher/status ``` **Chargeur** ``` 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 syntaxe pour exécuter le script Python est la suivante : ``` python3.6 neptunesigv4.py -ho your-neptune-endpoint -p port -a GET|POST -q gremlin|sparql|sparqlupdate|loader|status -d "string0data" ``` SPARQL UPDATE nécessite `POST`. # Connexion aux bases de données Amazon Neptune à l'aide de l'authentification IAM avec Gremlin Python ## Présentation de Ce guide explique comment se connecter à une base de données Amazon Neptune avec l'authentification IAM activée à l'aide du pilote Python Gremlin, avec l'authentification Signature Version 4 et le AWS SDK for Python (Boto3). ## Création d'une connexion de base Utilisez l'exemple de code suivant pour savoir comment établir une connexion de base avec l'authentification IAM à l'aide du pilote Python Garmlin. ``` 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() ``` # Connexion aux bases de données Amazon Neptune à l'aide de l'authentification IAM avec G705 JavaScript ## Présentation de Ce guide explique comment se connecter à une base de données Amazon Neptune avec l'authentification IAM activée à l'aide du JavaScript pilote G705, avec l'authentification Signature version 4 et le AWS SDK pour Javascript v3. ## Conditions préalables + Un cluster Amazon Neptune sur lequel l'authentification IAM est activée. + Node 13 ou version ultérieure (reportez-vous aux versions minimales pour Gremlin JavaScript et au [AWS SDK pour Javascript v3](https://docs.aws.amazon.com//AWSJavaScriptSDK/v3/latest/introduction/#release-cadence)). + AWS informations d'identification configurées (via des variables d'environnement, un fichier d'informations d'identification partagé ou un rôle IAM). ## Création d'une connexion de base Utilisez l'exemple de code suivant pour savoir comment établir une connexion de base avec l'authentification IAM à l'aide du pilote Gremlin JavaScript . ``` 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(); ``` # Connexion aux bases de données Amazon Neptune à l'aide de l'authentification IAM avec Gremlin Go ## Présentation de Ce guide explique comment se connecter à une base de données Amazon Neptune avec l'authentification IAM activée à l'aide du pilote G705 Go, avec l'authentification Signature version 4 et le AWS SDK pour GO v2. ## Conditions préalables + Un cluster Amazon Neptune sur lequel l'authentification IAM est activée. + Go 1.22 ou version ultérieure (reportez-vous aux versions minimales prises en charge pour [Gremlin Go](https://pkg.go.dev/github.com/apache/tinkerpop/gremlin-go/v3/driver) et [AWS SDK for](https://pkg.go.dev/github.com/aws/aws-sdk-go-v2) Go v2). + AWS informations d'identification configurées (via des variables d'environnement, un fichier d'informations d'identification partagé ou un rôle IAM) ## Création d'une connexion de base Utilisez l'exemple de code suivant pour savoir comment établir une connexion de base avec l'authentification IAM à l'aide du pilote Gremlin Go. ``` 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) } ``` ## Actualisation dynamique des informations d'identification G705 Go Gremlin Go permet d'injecter un pointeur de fonction pour récupérer les informations d'identification et générer l'en-tête, ce qui empêche l'expiration de l'en-tête en cas de connexions de longue durée. 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) } ``` # Connexion aux bases de données Amazon Neptune à l'aide de l'authentification IAM avec Gremlin .NET ## Présentation de Ce guide explique comment se connecter à une base de données Amazon Neptune avec l'authentification IAM activée à l'aide du pilote .NET G705, avec l'authentification Signature version 4 et le SDK pour AWS .NET v3. ## Création d'une connexion de base Pour vous connecter à Gremlin .NET, utilisez le fichier `SigV4RequestSigner` source de la bibliothèque personnalisée [ https://github.com/aws/amazon-neptune-gremlin-dotnet-sigv4](https://github.com/aws/amazon-neptune-gremlin-dotnet-sigv4). Un exemple de configuration de projet se trouve dans [ https://github.com/aws/amazon-neptune-gremlin-dotnet-sigv4/ tree/main/example](https://github.com/aws/amazon-neptune-gremlin-dotnet-sigv4/tree/main/example) et est illustré ci-dessous. Dossier du projet : ``` Exe netcoreapp8.0 ``` Exemple de programme : ``` 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); } } } } ```