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 depuis Python. Le client gère automatiquement la signature de Signature Version 4, vous n'avez donc pas besoin de signer les demandes vous-même.
## 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 les `neptune-db:*` actions sur votre cluster Neptune
## Connexion avec les informations d'identification par défaut
Cette approche fonctionne lorsque vous `boto3` pouvez résoudre les informations d'identification automatiquement, par exemple sur les instances Amazon Elastic Compute Cloud avec des profils d'instance, des AWS Lambda fonctions ou des AWS 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 pas en charge SPARQL pour le moment. Pour envoyer des requêtes SPARQL à une base de données IAM-enabled Neptune, signez les demandes manuellement en utilisant Signature Version 4 avec les utilitaires de `botocore` signature de demandes et la `requests` 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. Vous n'avez pas besoin 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é pour éviter des informations d'identification de longue durée, utilisez 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 d'une 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**
Le `boto3` `neptunedata` client ne prenant pas actuellement en charge 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, consultez. [AWS Lambda exemples de fonctions pour Amazon Neptune](lambda-functions-examples.md)