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 aux bases de données Amazon Neptune à l'aide de l'authentification IAM avec Python
Le `boto3` `neptunedata` client fournit le moyen le plus simple de se connecter à une base de données IAM-enabled Neptune à partir de Python. Le client gère automatiquement la signature de Signature Version 4, vous n'avez donc pas besoin de signer vous-même les demandes.
## Conditions préalables
+ Python 3.x
+ La `boto3` bibliothèque : `pip install boto3`
+ AWS informations d'identification configurées via n'importe quelle méthode standard (variables d'environnement, fichier de AWS configuration, profil d'instance ou rôle d'exécution Lambda)
+ Une politique IAM qui autorise `neptune-db:*` des actions sur votre cluster Neptune
## Connexion avec les informations d'identification par défaut
Cette approche fonctionne lorsqu'il est `boto3` possible de résoudre automatiquement les informations d'identification, par exemple sur les instances Amazon Elastic Compute Cloud avec des profils d'instance, dans des AWS Lambda fonctions ou avec AWS des profils configurés.
Remplacez l'URL du point de terminaison par le point de terminaison de votre cluster Neptune.
**Gremlin et OpenCypher**
```
import boto3
from botocore.config import Config
cfg = Config(retries={"total_max_attempts": 1, "mode": "standard"}, read_timeout=None)
neptune = boto3.client('neptunedata', config=cfg,
region_name='{{us-east-1}}',
endpoint_url='https://{{your-neptune-endpoint}}:8182')
# Gremlin
resp = neptune.execute_gremlin_query(gremlinQuery='g.V().limit(1)')
print(resp['result'])
# openCypher
resp = neptune.execute_open_cypher_query(openCypherQuery='MATCH (n) RETURN n LIMIT 1')
print(resp['results'])
```
**SPARQL**
Le `boto3` `neptunedata` client ne prend actuellement pas en charge le SPARQL. Pour envoyer des requêtes SPARQL à IAM-enabled une base de données Neptune, signez les demandes manuellement à l'aide de Signature Version 4 avec `botocore` les utilitaires de signature de demandes et `requests` la bibliothèque (). `pip install boto3 requests`
```
import requests
from botocore.auth import SigV4Auth
from botocore.awsrequest import AWSRequest
from botocore.session import Session
endpoint = 'https://{{your-neptune-endpoint}}:8182'
region = '{{us-east-1}}'
query = 'SELECT ?s ?p ?o WHERE { ?s ?p ?o } LIMIT 1'
request = AWSRequest(method='POST', url=f'{endpoint}/sparql/',
data={'query': query})
SigV4Auth(Session().get_credentials(), 'neptune-db', region).add_auth(request)
resp = requests.post(f'{endpoint}/sparql/', headers=request.headers,
data={'query': query})
print(resp.json())
```
**Note**
Cet exemple permet `botocore.session.Session` de résoudre automatiquement les AWS informations d'identification à partir de variables d'environnement, de fichiers de AWS configuration, de profils d'instance ou de rôles d'exécution Lambda. Il n'est pas nécessaire de définir les informations d'identification de manière explicite.
## Utilisation d'informations d'identification temporaires
Pour un accès entre comptes, des sessions limitées dans le temps ou comme meilleure pratique de sécurité afin d'éviter des identifiants de longue durée, utilisez-le AWS STS pour obtenir des informations d'identification temporaires et créer un. `boto3.Session`
**Gremlin et OpenCypher**
```
import boto3
from botocore.config import Config
sts = boto3.client('sts')
creds = sts.assume_role(
RoleArn='arn:aws:iam::{{123456789012}}:role/{{NeptuneRole}}',
RoleSessionName='neptune-session'
)['Credentials']
session = boto3.Session(
aws_access_key_id=creds['AccessKeyId'],
aws_secret_access_key=creds['SecretAccessKey'],
aws_session_token=creds['SessionToken'],
region_name='{{us-east-1}}'
)
cfg = Config(retries={"total_max_attempts": 1, "mode": "standard"}, read_timeout=None)
neptune = session.client('neptunedata', config=cfg,
endpoint_url='https://{{your-neptune-endpoint}}:8182')
# Gremlin
resp = neptune.execute_gremlin_query(gremlinQuery='g.V().limit(1)')
print(resp['result'])
# openCypher
resp = neptune.execute_open_cypher_query(openCypherQuery='MATCH (n) RETURN n LIMIT 1')
print(resp['results'])
```
**Note**
Les informations d'identification temporaires expirent après un intervalle spécifié (la valeur par défaut est de 1 heure) et ne sont pas automatiquement actualisées par le client. Pour les applications de longue durée, utilisez plutôt des informations d'identification basées sur des profils ou des profils d'instance.
**SPARQL**
Étant donné que le `boto3` `neptunedata` client ne prend pas actuellement en charge le SPARQL, vous devez signer les demandes manuellement à l'aide des informations d'identification temporaires.
```
import boto3
import requests
from botocore.auth import SigV4Auth
from botocore.awsrequest import AWSRequest
from botocore.credentials import ReadOnlyCredentials
sts = boto3.client('sts')
creds = sts.assume_role(
RoleArn='arn:aws:iam::{{123456789012}}:role/{{NeptuneRole}}',
RoleSessionName='neptune-session'
)['Credentials']
endpoint = 'https://{{your-neptune-endpoint}}:8182'
region = '{{us-east-1}}'
query = 'SELECT ?s ?p ?o WHERE { ?s ?p ?o } LIMIT 1'
request = AWSRequest(method='POST', url=f'{endpoint}/sparql/',
data={'query': query})
SigV4Auth(ReadOnlyCredentials(
creds['AccessKeyId'], creds['SecretAccessKey'], creds['SessionToken']
), 'neptune-db', region).add_auth(request)
resp = requests.post(f'{endpoint}/sparql/', headers=request.headers,
data={'query': query})
print(resp.json())
```
## Utilisation avec AWS Lambda
Dans Lambda, le rôle d'exécution fournit automatiquement des informations d'identification via. `boto3` L'exemple d'informations d'identification par défaut fonctionne sans modification.
Pour un exemple Lambda complet avec gestion des connexions et logique de nouvelle tentative, voir. [AWS Lambda exemples de fonctions pour Amazon Neptune](lambda-functions-examples.md)