Le traduzioni sono generate tramite traduzione automatica. In caso di conflitto tra il contenuto di una traduzione e la versione originale in Inglese, quest'ultima prevarrà. # Connessione al database Amazon Neptune tramite autenticazione AWS Identity and Access Management Le risorse Amazon Neptune con autenticazione IAM DB abilitata richiedono che tutte le richieste HTTP siano firmate AWS utilizzando Signature Version 4. Per informazioni generali sulla firma delle richieste con AWS Signature Version 4, consulta [Signing AWS API request](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_aws-signing.html). AWS Signature Version 4 è il processo per aggiungere informazioni di autenticazione alle AWS richieste. Per motivi di sicurezza, la maggior parte delle richieste AWS deve essere firmata con una chiave di accesso, che consiste in un ID della chiave di accesso e una chiave di accesso segreta. **Nota** Se utilizzi credenziali temporanee, queste scadono dopo un intervallo specificato, *comprensivo del token di sessione*. Devi aggiornare il token di sessione quando richiedi le nuove credenziali. Per ulteriori informazioni, vedere [Utilizzo di credenziali di sicurezza temporanee per richiedere l'accesso alle AWS risorse](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_temp_use-resources.html). **Importante** L'accesso a Neptune con l'autenticazione basata su IAM richiede la creazione di richieste HTTP e la firma personale delle richieste stesse. **Come funziona Signature Version 4** 1. Si crea una richiesta canonica. 1. Utilizzi la richiesta canonica e alcune altre informazioni per creare un. string-to-sign 1. Utilizzi la tua chiave di accesso AWS segreta per derivare una chiave di firma, quindi usi quella chiave di firma e poi string-to-sign per creare una firma. 1. Si aggiunge la firma risultante alla richiesta HTTP in un'intestazione o come parametro della stringa di query. Quando Neptune riceve la richiesta, esegue le stesse operazioni che sono state effettuate per calcolare la firma. Neptune quindi confronta la firma calcolata con quella inviata insieme alla richiesta. Se le firme corrispondono, la richiesta viene elaborata. In caso contrario, viene rifiutata. Per informazioni generali sulla firma delle richieste con AWS Signature Version 4, vedere [Processo di firma della versione 4](https://docs.aws.amazon.com/general/latest/gr/signature-version-4.html) di Signature in. *Riferimenti generali di AWS* Le sezioni successive illustrano esempi di come inviare le richieste firmate agli endpoint Gremlin e SPARQL di un'istanza database Neptune con l'autenticazione IAM abilitata. **Topics** + [Prerequisiti per la connessione dei database Amazon Neptune tramite l'autenticazione IAM](iam-auth-connect-prerq.md) + [Connessione ai database Amazon Neptune utilizzando l'autenticazione IAM dalla riga di comando](iam-auth-connect-command-line.md) + [Connessione ai database Amazon Neptune utilizzando l'autenticazione IAM con la console Gremlin](iam-auth-connecting-gremlin-console.md) + [Connessione ai database Amazon Neptune tramite IAM con Gremlin Java](iam-auth-connecting-gremlin-java.md) + [Connessione ai database Amazon Neptune utilizzando l'autenticazione IAM con Java e SPARQL](iam-auth-connecting-sparql-java.md) + [Connessione ai database Amazon Neptune utilizzando l'autenticazione IAM con SPARQL e Node.js](iam-auth-connecting-sparql-node.md) + [Connessione ai database Amazon Neptune utilizzando l'autenticazione IAM con Python](iam-auth-connecting-python.md) + [Connessione ai database Amazon Neptune utilizzando l'autenticazione IAM con Gremlin Python](gremlin-python-iam-auth.md) + [Connessione ai database Amazon Neptune utilizzando l'autenticazione IAM con Gremlin JavaScript](gremlin-javascript-iam-auth.md) + [Connessione ai database Amazon Neptune utilizzando l'autenticazione IAM con Gremlin Go](gremlin-go-iam-auth.md) + [Connessione ai database Amazon Neptune utilizzando l'autenticazione IAM con Gremlin.NET](gremlin-dotnet-iam-auth.md) # Prerequisiti per la connessione dei database Amazon Neptune tramite l'autenticazione IAM Di seguito sono riportate le istruzioni per l'installazione di Apache Maven e Java 8 su un'istanza Amazon EC2. Questi sono necessari per gli esempi di autenticazione di Signature Version 4 di Amazon Neptune. **Installazione di Apache Maven e Java 8 sull'istanza EC2.** 1. Collegare l'istanza Amazon EC2 a un client SSH. 1. Installare Apache Maven sull'istanza EC2. Se usi Amazon Linux 2023 (preferito), usa: ``` sudo dnf update -y sudo dnf install maven -y ``` Se usi Amazon Linux 2, scarica il file binario più recente da [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. Le librerie della console Gremlin richiedono Java 8. Per installare Java 8 sull'istanza EC2, digita quanto segue. ``` sudo yum install java-1.8.0-devel ``` 1. Per impostare Java 8 come runtime predefinito sull'istanza EC2, digitare quanto segue. ``` sudo /usr/sbin/alternatives --config java ``` Quando richiesto, immetti il numero per Java 8. 1. Per impostare Java 8 come compilatore predefinito sull'istanza EC2, immetti quanto segue: ``` sudo /usr/sbin/alternatives --config javac ``` Quando richiesto, immetti il numero per Java 8. # Connessione ai database Amazon Neptune utilizzando l'autenticazione IAM dalla riga di comando Avere uno strumento a riga di comando per inviare query al cluster database Neptune è molto utile, come illustrato in molti esempi di questa documentazione. Lo strumento [curl](https://curl.haxx.se/) è un'opzione eccellente per comunicare con gli endpoint Neptune se l'autenticazione IAM non è abilitata. **Tuttavia, per proteggere i dati è meglio abilitare l'autenticazione IAM.** Quando è abilitata l'autenticazione IAM, ogni richiesta deve essere [firmata utilizzando Signature Version 4 (Sig4)](https://docs.aws.amazon.com/general/latest/gr/signing-aws-api-requests.html). Lo strumento a riga di comando [awscurl](https://github.com/okigan/awscurl) di terze parti utilizza la stessa sintassi di `curl` e può firmare le query utilizzando la firma Sig4. La sezione [Uso di `awscurl`](#iam-auth-connect-awscurl) seguente spiega come utilizzare `awscurl` in modo sicuro con le credenziali temporanee. ## Configurazione di uno strumento a riga di comando per l'utilizzo di HTTPS Neptune richiede che tutte le connessioni utilizzino HTTPS. Qualsiasi strumento a riga di comando come `curl` o `awscurl` necessita dell'accesso ai certificati appropriati per poter utilizzare HTTPS. Se `curl` o `awscurl` sono in grado di individuare i certificati adeguati, gestiscono le connessioni HTTPS in modo analogo alle connessioni HTTP, senza parametri aggiuntivi. Gli esempi di questa documentazione si basano su questo scenario. Per scoprire come ottenere tali certificati e come formattarli correttamente in un archivio di certificati CA (Certificate Authority) che `curl` può utilizzare, consulta [Verifica certificati SSL](https://curl.haxx.se/docs/sslcerts.html) nella documentazione di `curl`. È possibile specificare il percorso di questo archivio di certificati CA utilizzando la variabile di ambiente `CURL_CA_BUNDLE`. In Windows, `curl` cerca automaticamente un file denominato `curl-ca-bundle.crt`. Cerca prima nella stessa cartella di `curl.exe`, quindi in altri punti del percorso. Per ulteriori informazioni, consulta [Verifica certificati SSL](https://curl.haxx.se/docs/sslcerts.html). ## Utilizzo di `awscurl` con credenziali temporanee per connettersi in modo sicuro a un cluster database con autenticazione IAM abilitata Lo strumento [awscurl](https://github.com/okigan/awscurl) utilizza la stessa sintassi di `curl`, ma necessita anche di informazioni aggiuntive: + **`--access_key`**: chiave di accesso valida. Se non viene fornita utilizzando questo parametro, deve essere fornita nella variabile di ambiente `AWS_ACCESS_KEY_ID` o in un file di configurazione. + **`--secret_key`**: chiave segreta valida corrispondente alla chiave di accesso. Se non viene fornita utilizzando questo parametro, deve essere fornita nella variabile di ambiente `AWS_SECRET_ACCESS_KEY` o in un file di configurazione. + **`--security_token`**: token di sessione valido. Se non viene fornita utilizzando questo parametro, deve essere fornita nella variabile di ambiente `AWS_SECURITY_TOKEN` o in un file di configurazione. In passato, era prassi comune utilizzare credenziali persistenti con `awscurl`, come le credenziali utente IAM o anche le credenziali root, ma ciò non è consigliato. [Genera invece credenziali temporanee utilizzando uno dei [AWS Security Token Service (STS)](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_temp_request.html) o uno dei relativi APIs wrapper.AWS CLI](https://docs.aws.amazon.com/cli/latest/reference/sts/index.html) È preferibile inserire i valori `AccessKeyId`, `SecretAccessKey` e `SessionToken` restituiti dalla chiamata STS nelle variabili di ambiente appropriate nella sessione della shell anziché in un file di configurazione. In questo modo, quando la shell termina, le credenziali vengono automaticamente eliminate, cosa che non avviene con un file di configurazione. Allo stesso modo, non richiedere per le credenziali temporanee una durata più lunga di quella di cui si potrebbe aver bisogno. L'esempio seguente mostra i passaggi da eseguire in una shell Linux per ottenere credenziali temporanee valide per mezz'ora usando [sts assume-role](https://docs.aws.amazon.com/cli/latest/reference/sts/assume-role), per poi inserirle in variabili di ambiente dove `awscurl` può trovarle: ``` 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 ``` È possibile quindi usare `awscurl` per effettuare una richiesta firmata al cluster database in questo modo: ``` awscurl (your cluster endpoint):8182/status \ --region us-east-1 \ --service neptune-db ``` # Connessione ai database Amazon Neptune utilizzando l'autenticazione IAM con la console Gremlin Per connetterti ad Amazon Neptune utilizzando la console Gremlin con autenticazione Signature Version 4, devi `requestInterceptor()` collegare un firmatario SigV4 alla connessione stabilita dal comando. `:remote` Ciò richiede di configurare l'`Cluster`oggetto manualmente e poi passarlo al comando. `:remote` Tenere presente che questo è molto diverso dalla situazione tipica in cui il comando `:remote` richiede un file di configurazione per formare la connessione. L'approccio del file di configurazione non funzionerà perché `requestInterceptor()` deve essere impostato a livello di codice e non può caricare la configurazione da un file. **Nota** Gli esempi seguenti utilizzano`requestInterceptor()`, che è stato introdotto nella versione TinkerPop 3.6.6. Se stai usando una TinkerPop versione precedente alla 3.6.6 (ma 3.5.5 o successiva), usa `handshakeInterceptor()` invece che negli esempi di `requestInterceptor()` codice seguenti. Sono necessari i seguenti prerequisiti: + È necessario disporre delle credenziali IAM necessarie per firmare le richieste. Vedi [Utilizzo della catena di fornitori di credenziali predefinita nella Guida](https://docs.aws.amazon.com//sdk-for-java/latest/developer-guide/credentials-chain.html) per gli AWS SDK per Java sviluppatori. + È necessario aver installato una versione della console Gremlin compatibile con la versione del motore Neptune utilizzata dal cluster database. Se si utilizzano credenziali temporanee, queste scadono dopo un intervallo specificato, così come il token di sessione, quindi è necessario aggiornare il token di sessione quando si richiedono nuove credenziali. Vedi [Utilizzo di credenziali di sicurezza temporanee per richiedere l'accesso alle AWS risorse nella Guida per](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_temp_use-resources.html) l'utente IAM. Per informazioni sulla connessione tramite SSL/TLS, consulta [Configurazione SSL/TLS](access-graph-gremlin-java.md#access-graph-gremlin-java-ssl). **Connect la console Gremlin con la firma Sig4** 1. Avviare la console Gremlin: ``` $ bin/gremlin.sh ``` 1. Al prompt `gremlin>`, installare la libreria `amazon-neptune-sigv4-signer` (questa operazione deve essere eseguita solo una volta per la console): ``` :install com.amazonaws amazon-neptune-sigv4-signer 2.4.0 ``` [Se riscontri problemi con questo passaggio, può essere utile consultare la [TinkerPop documentazione](https://tinkerpop.apache.org/docs/current/reference/#gremlin-applications) sulla configurazione di Grape.](http://docs.groovy-lang.org/latest/html/documentation/grape.html) **Nota** Se si utilizza un proxy HTTP, è possibile che si verifichino errori in questo passaggio in cui il comando `:install` non viene completato. Per risolvere questo problema, esegui i comandi seguenti per fornire alla console informazioni sul proxy: ``` System.setProperty("https.proxyHost", "(the proxy IP address)") System.setProperty("https.proxyPort", "(the proxy port)") ``` 1. Importare la classe richiesta per gestire l'accesso a `requestInterceptor()`: ``` :import software.amazon.awssdk.auth.credentials.DefaultCredentialsProvider :import com.amazonaws.neptune.auth.NeptuneNettyHttpSigV4Signer ``` 1. Se si utilizzano credenziali temporanee, è necessario fornire anche il token di sessione come segue: ``` System.setProperty("aws.sessionToken","(your session token)") ``` 1. Se non si sono ancora stabilite le credenziali dell'account, è possibile assegnarle come segue: ``` System.setProperty("aws.accessKeyId","(your access key)") System.setProperty("aws.secretKey","(your secret key)") ``` 1. Costruire manualmente l'oggetto `Cluster` da connettere 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() ``` Per informazioni su come trovare il nome host di un'istanza database Neptune, consulta [Connessione agli endpoint Amazon Neptune](feature-overview-endpoints.md). 1. Stabilire la connessione `:remote` utilizzando il nome della variabile dell'oggetto `Cluster` nel passaggio precedente: ``` :remote connect tinkerpop.server cluster ``` 1. Immettere il seguente comando per passare alla modalità remota. In questo modo tutte le query Gremlin vengono inviate alla connessione remota: ``` :remote console ``` # Connessione ai database Amazon Neptune tramite IAM con Gremlin Java Ecco un esempio di come connettersi a Neptune utilizzando l'API Java Gremlin con firma Sig4 (si presuppone una conoscenza generale dell'uso di Maven). Questo esempio utilizza la libreria [Amazon Neptune SigV4 Signer](https://github.com/aws/amazon-neptune-sigv4-signer) per facilitare la firma delle richieste. Innanzitutto, definire le dipendenze come parte del file `pom.xml`: **Nota** I seguenti esempi utilizzano`requestInterceptor()`, che è stata introdotta nella versione 3.6.6. TinkerPop Se stai usando una TinkerPop versione precedente alla 3.6.6 (ma 3.5.5 o successiva), usa `handshakeInterceptor()` invece che negli esempi di `requestInterceptor()` codice seguenti. ``` com.amazonaws amazon-neptune-sigv4-signer 3.1.0 ``` Amazon Neptune SigV4 Signer supporta entrambe le versioni 1.x e 2.x di Java SDK. AWS I seguenti esempi utilizzano 2.x, dove è un'istanza. `DefaultCredentialsProvider` `software.amazon.awssdk.auth.credentials.AwsCredentialsProvider` Se stai effettuando l'aggiornamento da 1.x a 2.x, consulta le [modifiche al provider Credentials nella documentazione](https://docs.aws.amazon.com//sdk-for-java/latest/developer-guide/migration-client-credentials.html) di SDK for AWS 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); } ``` ## Autenticazione IAM tra account [Amazon Neptune supporta l'autenticazione IAM tra account attraverso l'uso dell'assunzione di ruolo, a volte chiamata anche concatenazione dei ruoli.](https://docs.aws.amazon.com//neptune/latest/userguide/bulk-load-tutorial-chain-roles.html#bulk-load-tutorial-chain-cross-account) Per fornire l'accesso a un cluster Neptune da un'applicazione ospitata in un account diverso: AWS + Crea un nuovo utente o ruolo IAM nell' AWS account dell'applicazione, con una policy di fiducia che consenta all'utente o al ruolo di assumere un altro ruolo IAM. Assegna questo ruolo al computer che ospita l'applicazione (istanza EC2, funzione Lambda, ECS Task, ecc.). ------ #### [ JSON ] **** ``` { "Version":"2012-10-17", "Statement": [ { "Sid": "assumeRolePolicy", "Effect": "Allow", "Action": "sts:AssumeRole", "Resource": "arn:aws:iam::111122223333:role/role-name" } ] } ``` ------ + Crea un nuovo ruolo IAM nell'account del database Neptune che consenta l'accesso al AWS database Neptune e consenta l'assunzione del ruolo dall'utente/ruolo IAM dell'account dell'applicazione. Utilizza una politica di fiducia di: ------ #### [ JSON ] **** ``` { "Version":"2012-10-17", "Statement": [ { "Effect": "Allow", "Principal": { "AWS": [ "(ARN of application account IAM user or role)" ] }, "Action": "sts:AssumeRole", "Condition": {} } ] } ``` ------ + Utilizzate il seguente esempio di codice come guida su come utilizzare questi due ruoli per consentire all'applicazione di accedere a Neptune. In questo esempio, il ruolo dell'account dell'applicazione verrà assunto tramite [DefaultCredentialProviderChain](https://docs.aws.amazon.com//sdk-for-java/v1/developer-guide/credentials.html)durante la creazione di. `STSclient` `STSclient`Viene quindi utilizzato tramite il `STSAssumeRoleSessionCredentialsProvider` per assumere il ruolo ospitato nell'account del database AWS 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(); } ``` # Connessione ai database Amazon Neptune utilizzando l'autenticazione IAM con Java e SPARQL Questa sezione mostra come connettersi a Neptune utilizzando J RDF4 o Apache Jena con autenticazione Signature Version 4. **Prerequisiti** + Java 8 o versione successiva. + Apache Maven 3.3 o versione successiva. Per informazioni sull'installazione di questi prerequisiti su un'istanza EC2 che esegue Amazon Linux, consulta [Prerequisiti per la connessione dei database Amazon Neptune tramite l'autenticazione IAM](iam-auth-connect-prerq.md). + Le credenziali di IAM per firmare le richieste. Per ulteriori informazioni, consulta [Utilizzo della catena di provider delle credenziali predefinita](https://docs.aws.amazon.com/sdk-for-java/v1/developer-guide/credentials.html#credentials-default) nella *Guida per gli sviluppatori di AWS SDK per Java * **Nota** Se utilizzi credenziali temporanee, queste scadono dopo un intervallo specificato, *comprensivo del token di sessione*. Devi aggiornare il token di sessione quando richiedi le nuove credenziali. *Per ulteriori informazioni, consulta [Utilizzo di credenziali di sicurezza temporanee per richiedere l'accesso alle AWS risorse nella Guida per l'utente](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_temp_use-resources.html) IAM.* + Imposta la variabile `SERVICE_REGION` su uno dei valori seguenti per indicare la regione dell'istanza database Neptune: + Stati Uniti orientali (Virginia settentrionale): `us-east-1` + Stati Uniti orientali (Ohio): `us-east-2` + Stati Uniti occidentali (California settentrionale): `us-west-1` + Stati Uniti occidentali (Oregon): `us-west-2` + Canada (Centrale): `ca-central-1` + Canada occidentale (Calgary): `ca-west-1` + Sud America (San Paolo): `sa-east-1` + Europa (Stoccolma): `eu-north-1` + Europa (Spagna): `eu-south-2` + Europa (Irlanda): `eu-west-1` + Europa (Londra): `eu-west-2` + Europa (Parigi): `eu-west-3` + Europa (Francoforte): `eu-central-1` + Medio Oriente (Bahrein): `me-south-1` + Medio Oriente (Emirati Arabi Uniti): `me-central-1` + Israele (Tel Aviv):   `il-central-1` + Africa (Città del Capo): `af-south-1` + Asia Pacifico (Hong Kong): `ap-east-1` + Asia Pacifico (Tokyo): `ap-northeast-1` + Asia Pacifico (Seoul): `ap-northeast-2` + Asia Pacifico (Osaka): `ap-northeast-3` + Asia Pacifico (Singapore): `ap-southeast-1` + Asia Pacifico (Sydney): `ap-southeast-2` + Asia Pacifico (Giacarta): `ap-southeast-3` + Asia Pacifico (Melbourne): `ap-southeast-4` + Asia Pacifico (Malesia): `ap-southeast-5` + Asia Pacifico (Mumbai): `ap-south-1` + Asia Pacifico (Hyderabad): `ap-south-2` + Cina (Pechino): `cn-north-1` + Cina (Ningxia): `cn-northwest-1` + AWS GovCloud (Stati Uniti occidentali): `us-gov-west-1` + AWS GovCloud (Stati Uniti orientali): `us-gov-east-1` **Per connettersi a Neptune usando J RDF4 o Apache Jena con firma Signature Version 4** 1. Clona il repository di esempio da. GitHub ``` git clone https://github.com/aws/amazon-neptune-sparql-java-sigv4.git ``` 1. Passa alla directory clonata. ``` cd amazon-neptune-sparql-java-sigv4 ``` 1. Scarica la versione più recente del progetto controllando il ramo con il tag più recente. ``` git checkout $(git describe --tags `git rev-list --tags --max-count=1`) ``` 1. Inserisci uno dei seguenti comandi per compilare ed eseguire il codice di esempio. Sostituisci *your-neptune-endpoint* con il nome host o l'indirizzo IP dell'istanza DB di Neptune. La porta predefinita è 8182. **Nota** Per informazioni su come trovare il nome host dell'istanza database Neptune, consulta la sezione [Connessione agli endpoint Amazon Neptune](feature-overview-endpoints.md). **RDF4Eclipse J** Immettere quanto segue per eseguire l'esempio 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** Immetti quanto segue per eseguire l'esempio di Apache Jena. ``` mvn compile exec:java \ -Dexec.mainClass="com.amazonaws.neptune.client.jena.NeptuneJenaSigV4Example" \ -Dexec.args="https://your-neptune-endpoint:port" ``` 1. Per visualizzare il codice sorgente dell'esempio, consulta gli esempi disponibili nella directory `src/main/java/com/amazonaws/neptune/client/`. Per utilizzare il driver di firma SigV4 nella tua applicazione Java, aggiungi il pacchetto Maven `amazon-neptune-sigv4-signer` alla sezione `` di `pom.xml`. Ti consigliamo di usare gli esempi come punto di partenza. # Connessione ai database Amazon Neptune utilizzando l'autenticazione IAM con SPARQL e Node.js ## Esecuzione di query utilizzando la firma Signature V4 e l' AWS SDK per Javascript V3 Ecco un esempio di come connettersi a Neptune SPARQL utilizzando Node.js con l'autenticazione Signature Version 4 e AWS l'SDK per 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); } ); } ``` ## Esecuzione di query utilizzando la firma Signature V4 e l'SDK per Javascript V2 AWS Ecco un esempio di come connettersi a Neptune SPARQL utilizzando Node.js con l'autenticazione Signature Version 4 e AWS l'SDK per 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); }); } ``` # Connessione ai database Amazon Neptune utilizzando l'autenticazione IAM con Python In questa sezione viene mostrato un programma di esempio scritto in Python che spiega come lavorare con Signature Version 4 per Amazon Neptune. Questo esempio si basa sugli esempi nella sezione [processo di firma Signature Version 4](https://docs.aws.amazon.com/general/latest/gr/sigv4-signed-request-examples.html) in *Riferimenti generali di Amazon Web Services*. Per lavorare con questo programma di esempio, è necessario: + Python 3.x installato nel computer, scaricabile dal [sito Python](https://www.python.org/downloads/). Questi programmi sono stati testati utilizzando Python 3.6. + La [libreria di richieste Python](https://pypi.python.org/pypi/requests), utilizzata nello script di esempio per creare richieste Web. Un modo comodo per installare i pacchetti Python è utilizzare `pip`, che consente di ottenere i pacchetti dal sito del'indice dei pacchetti Python. È quindi possibile installare `requests` eseguendo `pip install requests` alla riga di comando. + Una chiave di accesso (ID della chiave di accesso e chiave di accesso segreta) nelle variabili di ambiente denominate `AWS_ACCESS_KEY_ID` e `AWS_SECRET_ACCESS_KEY`. Come best practice, è consigliabile *non* incorporare le credenziali nel codice. Per ulteriori informazioni, consulta [Best practice per gli account AWS](https://docs.aws.amazon.com//accounts/latest/reference/best-practices.html) nella *Guida di riferimento Gestione dell'account AWS *. La regione del tuo cluster database Neptune nella variabile di ambiente denominata `SERVICE_REGION`. Se usi credenziali temporanee, devi specificare `AWS_SESSION_TOKEN` oltre a `AWS_ACCESS_KEY_ID`, `AWS_SECRET_ACCESS_KEY` e `SERVICE_REGION`. **Nota** Se utilizzi credenziali temporanee, queste scadono dopo un intervallo specificato, *comprensivo del token di sessione*. Devi aggiornare il token di sessione quando richiedi le nuove credenziali. Per ulteriori informazioni, consulta [Utilizzo delle credenziali di sicurezza temporanee per richiedere l'accesso alle risorse AWS](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_temp_use-resources.html). L'esempio seguente mostra come effettuare richieste firmate a Neptune utilizzando Python. La richiesta effettua una richiesta GET o POST. Le informazioni di autenticazione vengono trasferite utilizzando l'intestazione della richiesta `Authorization`. Questo esempio funziona anche come AWS Lambda funzione. Per ulteriori informazioni, consulta [Configurazione di AWS Lambda per l'autenticazione IAM di Neptune](iam-auth-temporary-credentials.md#iam-auth-temporary-credentials-lambda). **Per effettuare richieste firmate agli endpoint Neptune Gremlin e SPARQL** 1. Crea un nuovo file denominato `neptunesigv4.py` e aprilo in un editor di testo. 1. Copia la seguente chiave pubblica e incollala nel file `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. In un terminale, individua la posizione del file `neptunesigv4.py`. 1. Inserisci i seguenti comandi, sostituendo la chiave di accesso, la chiave segreta e la regione con i valori corretti. ``` 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 ``` Se usi credenziali temporanee, devi specificare `AWS_SESSION_TOKEN` oltre a `AWS_ACCESS_KEY_ID`, `AWS_SECRET_ACCESS_KEY` e `SERVICE_REGION`. ``` export AWS_SESSION_TOKEN=MY_AWS_SESSION_TOKEN ``` **Nota** Se utilizzi credenziali temporanee, queste scadono dopo un intervallo specificato, *comprensivo del token di sessione*. Devi aggiornare il token di sessione quando richiedi le nuove credenziali. Per ulteriori informazioni, consulta [Utilizzo delle credenziali di sicurezza temporanee per richiedere l'accesso alle risorse AWS](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_temp_use-resources.html). 1. Inserisci uno dei seguenti comandi per inviare una richiesta firmata all'istanza database Neptune. Questi esempi utilizzano Python versione 3.6. **Stato endpoint** ``` 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()" ``` **Stato 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 { }" ``` **Stato 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;" ``` **Stato openCypher** ``` python3.6 neptunesigv4.py -ho your-neptune-endpoint -p 8182 -a GET -q openCypher/status ``` **Loader** ``` 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 sintassi per eseguire lo script Python è la seguente: ``` python3.6 neptunesigv4.py -ho your-neptune-endpoint -p port -a GET|POST -q gremlin|sparql|sparqlupdate|loader|status -d "string0data" ``` SPARQL UPDATE richiede `POST`. # Connessione ai database Amazon Neptune utilizzando l'autenticazione IAM con Gremlin Python ## Panoramica di Questa guida dimostra come connettersi a un database Amazon Neptune con l'autenticazione IAM abilitata utilizzando il driver Gremlin Python, con l'autenticazione Signature Version 4 e l'SDK AWS for Python (Boto3). ## Crea una connessione di base Usa il seguente esempio di codice come guida su come stabilire una connessione di base con l'autenticazione IAM utilizzando il driver Gremlin Python. ``` 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() ``` # Connessione ai database Amazon Neptune utilizzando l'autenticazione IAM con Gremlin JavaScript ## Panoramica di Questa guida dimostra come connettersi a un database Amazon Neptune con l'autenticazione IAM abilitata utilizzando il driver Gremlin, con l'autenticazione Signature Version 4 e JavaScript l'SDK per Javascript v3. AWS ## Prerequisiti + Un cluster Amazon Neptune con autenticazione IAM abilitata. + Node 13 o successivo (fai riferimento alle versioni minime per Gremlin JavaScript e [AWS SDK](https://docs.aws.amazon.com//AWSJavaScriptSDK/v3/latest/introduction/#release-cadence) per Javascript v3). + AWS credenziali configurate (tramite variabili di ambiente, file di credenziali condivise o ruolo IAM). ## Crea una connessione di base Utilizza il seguente esempio di codice come guida su come stabilire una connessione di base con l'autenticazione IAM utilizzando il driver 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(); ``` # Connessione ai database Amazon Neptune utilizzando l'autenticazione IAM con Gremlin Go ## Panoramica di Questa guida dimostra come connettersi a un database Amazon Neptune con l'autenticazione IAM abilitata utilizzando il driver Gremlin Go, con l'autenticazione Signature Version 4 e l' AWS SDK per GO v2. ## Prerequisiti + Un cluster Amazon Neptune con autenticazione IAM abilitata. + Go 1.22 o successivo (fai riferimento alle versioni minime supportate per [Gremlin Go e SDK for AWS Go](https://pkg.go.dev/github.com/apache/tinkerpop/gremlin-go/v3/driver) [v2](https://pkg.go.dev/github.com/aws/aws-sdk-go-v2)). + AWS credenziali configurate (tramite variabili di ambiente, file di credenziali condivise o ruolo IAM) ## Crea una connessione di base Utilizza il seguente esempio di codice come guida su come stabilire una connessione di base con l'autenticazione IAM utilizzando il driver 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) } ``` ## Aggiornamento dinamico delle credenziali Gremlin Go Gremlin Go consente l'iniezione di un puntatore di funzione per recuperare le credenziali e generare l'intestazione, il DynamicAuth che impedisce la scadenza dell'intestazione in caso di connessioni di lunga durata. ``` 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) } ``` # Connessione ai database Amazon Neptune utilizzando l'autenticazione IAM con Gremlin.NET ## Panoramica di Questa guida dimostra come connettersi a un database Amazon Neptune con l'autenticazione IAM abilitata utilizzando il driver Gremlin .NET, con l'autenticazione Signature Version 4 e l'SDK AWS for .NET v3. ## Crea una connessione di base [Per connetterti con Gremlin .NET, usa il file `SigV4RequestSigner` sorgente dalla libreria https://github.com/aws/ amazon-neptune-gremlin-dotnet personalizzata -sigv4.](https://github.com/aws/amazon-neptune-gremlin-dotnet-sigv4) [Un esempio di configurazione del progetto si trova in -sigv4/ ed è riportato di seguito. https://github.com/aws/ amazon-neptune-gremlin-dotnet tree/main/example](https://github.com/aws/amazon-neptune-gremlin-dotnet-sigv4/tree/main/example) File di progetto: ``` Exe netcoreapp8.0 ``` Programma di esempio: ``` 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); } } } } ```