翻訳は機械翻訳により提供されています。提供された翻訳内容と英語版の間で齟齬、不一致または矛盾がある場合、英語版が優先します。
# AWS Identity and Access Management 認証を使用した Amazon Neptune データベースへの接続
IAM DB 認証が有効になっている Amazon Neptune リソースでは、 AWS 署名バージョン 4 を使用してすべての HTTP リクエストに署名する必要があります。 AWS 署名バージョン 4 を使用したリクエストの署名に関する一般的な情報については、[AWS 「 API リクエストの署名](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_aws-signing.html)」を参照してください。
AWS 署名バージョン 4 は、リクエストに AWS 認証情報を追加するプロセスです。セキュリティのため、 へのほとんどのリクエストは、アクセスキー ID とシークレットアクセスキーで構成されるアクセスキーで署名 AWS する必要があります。
**注記**
一時的なセキュリティ認証情報を使用している場合は、*セッショントークンを含めて*、指定した期間が過ぎると失効します。
新しい認証情報をリクエストするときは、セッショントークンを更新する必要があります。詳細については、[「一時的なセキュリティ認証情報を使用して AWS リソースへのアクセスをリクエストする](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_temp_use-resources.html)」を参照してください。
**重要**
IAM ベースの認証を使用して Neptune にアクセスするには、HTTP リクエストを作成してリクエストに自分で署名することが必要です。
**署名バージョン 4 の仕組み**
1. 正規リクエストを作成します。
1. 正規リクエストなどの情報を使用して署名文字列を作成します。
1. AWS シークレットアクセスキーを使用して署名キーを取得し、その署名キーとstring-to-signを使用して署名を作成します。
1. 作成した署名をヘッダーの HTTP リクエストに追加するか、クエリ文字列パラメータとして追加します。
Neptune は、リクエストを受信すると、お客様が行ったのと同じステップで署名を計算します。次に、Neptune は、計算した署名とリクエストで送信された署名を比較します。署名が一致すると、リクエストが処理されます。署名が一致しない場合、リクエストは拒否されます。
AWS 署名バージョン 4 でリクエストに署名する一般的な情報については、の[「署名バージョン 4 の署名プロセス](https://docs.aws.amazon.com/general/latest/gr/signature-version-4.html)」を参照してください*AWS 全般のリファレンス*。
以下のセクションでは、 認証を有効にして Neptune DB インスタンスの Gremlin エンドポイントおよび SPARQL エンドポイントに署名付きリクエストを送信する方法について、例を挙げて説明します。
**Topics**
+ [IAM 認証を使用して Amazon Neptune データベースを接続するための前提条件](iam-auth-connect-prerq.md)
+ [IAM 認証を使用することによるコマンドラインからの Amazon Neptune データベースへの接続](iam-auth-connect-command-line.md)
+ [Gremlin コンソールでの IAM 認証を使用した Amazon Neptune データベースへの接続](iam-auth-connecting-gremlin-console.md)
+ [Gremlin Java による IAM を使用した Amazon Neptune データベースへの接続](iam-auth-connecting-gremlin-java.md)
+ [Java および SPARQL による IAM 認証を使用した Amazon Neptune データベースへの接続](iam-auth-connecting-sparql-java.md)
+ [SPARQL と Node.js による IAM 認証を使用した Amazon Neptune データベースへの接続](iam-auth-connecting-sparql-node.md)
+ [Python による IAM 認証を使用した Amazon Neptune データベースへの接続](iam-auth-connecting-python.md)
+ [Gremlin Python による IAM 認証を使用した Amazon Neptune データベースへの接続](gremlin-python-iam-auth.md)
+ [Gremlin JavaScript による IAM 認証を使用した Amazon Neptune データベースへの接続](gremlin-javascript-iam-auth.md)
+ [Gremlin Go による IAM 認証を使用した Amazon Neptune データベースへの接続](gremlin-go-iam-auth.md)
+ [Gremlin .NET による IAM 認証を使用した Amazon Neptune データベースへの接続](gremlin-dotnet-iam-auth.md)
# IAM 認証を使用して Amazon Neptune データベースを接続するための前提条件
以下に示しているのは、Apache Maven と Java 8 を Amazon EC2 インスタンスにインストールする手順です。これらは、Amazon Neptune 署名バージョン 4 認証サンプルで必要です。
**Apache Maven と Java 8 を EC2 インスタンスにインストールするには**
1. SSH クライアントを使用して Amazon EC2 インスタンスに接続します。
1. Apache Maven を EC2 インスタンスにインストールします。Amazon Linux 2023 (推奨) を使用している場合は、以下の対象を使用します。
```
sudo dnf update -y
sudo dnf install maven -y
```
Amazon Linux 2 を使用している場合は、[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. Gremlin ライブラリには Java 8 が必要です。EC2 インスタンスで Java 8 をインストールするには、次のように入力します。
```
sudo yum install java-1.8.0-devel
```
1. EC2 インスタンスで Java 8 をデフォルトランタイムとして設定するには、次のように入力します。
```
sudo /usr/sbin/alternatives --config java
```
プロンプトが表示されたら、Java 8 の数を入力します。
1. EC2 インスタンスで Java 8 をデフォルトコンパイラとして設定するには、次のように入力します。
```
sudo /usr/sbin/alternatives --config javac
```
プロンプトが表示されたら、Java 8 の数を入力します。
# IAM 認証を使用することによるコマンドラインからの Amazon Neptune データベースへの接続
このドキュメントの多くの例に示されるように、Neptune DB クラスターにクエリを送信するためのコマンドラインツールがあると非常に便利です。[curl](https://curl.haxx.se/) ツールは、IAM 認証が有効になっていない場合に Neptune エンドポイントと通信するための優れたオプションです。
**ただし、データを安全に保つには、IAM 認証を有効にするのが最善です。**
IAM 認証が有効になっている場合、各リクエストに[署名バージョン 4 (Sig4) を使用して署名する](https://docs.aws.amazon.com/general/latest/gr/signing-aws-api-requests.html)必要があります。サードパーティの [awscurl](https://github.com/okigan/awscurl) コマンドラインツールは、`curl` と同じ構文を使用し、Sig4 署名を使用してクエリに署名できます。以下の [`awscurl`の使用](#iam-auth-connect-awscurl) セクションでは、一時的な認証情報で `awscurl` を安全に使用する方法について説明します。
## HTTPS を使用するコマンドラインツールのセットアップ
Neptune では、すべての接続で HTTPS を使用する必要があります。HTTPS を使用するには、`curl` または `awscurl` などのコマンドラインツールが適切な証明書にアクセスする必要があります。`curl` または `awscurl` が適切な証明書を見つけられる限り、HTTP 接続と同じように HTTPS 接続を処理し、追加のパラメータを必要としません。このドキュメントの例はこのシナリオに基づいています。
そのような証明書を取得する方法と、`curl` が使える証明書を認証局 (CA) 証明書ストアに適切にフォーマットする方法については、`curl` ドキュメント内の「[SSL 証明書の検証](https://curl.haxx.se/docs/sslcerts.html)」を参照してください。
次に、`CURL_CA_BUNDLE` 環境変数を使用してこの CA 証明書ストアの場所を指定できます。Windows では、`curl` は自動的に `curl-ca-bundle.crt` という名前のファイルを検索します。まず `curl.exe` と同じディレクトリで curl.exe を検索し、次にこのパスの他の場所を検索します。詳細については、「[SSL Certificate Verification](https://curl.haxx.se/docs/sslcerts.html)」を参照してください。
## 一時的な認証情報で `awscurl` を使用して、IAM 認証が有効になっている DB クラスターに安全に接続する
[awscurl](https://github.com/okigan/awscurl) ツールは、`curl` と同じ構文を使用しますが、追加情報も必要です。
+ **`--access_key`** — 有効なアクセスキー。このパラメータを使用して指定しなかった場合は、`AWS_ACCESS_KEY_ID` 環境変数または設定ファイルで指定する必要があります。
+ **`--secret_key`** - アクセスキーに対応する有効なシークレットキー。このパラメータを使用して指定しなかった場合は、`AWS_SECRET_ACCESS_KEY` 環境変数または設定ファイルで指定する必要があります。
+ **`--security_token`** — 有効なセッショントークン。このパラメータを使用して指定しなかった場合は、`AWS_SECURITY_TOKEN` 環境変数または設定ファイルで指定する必要があります。
以前は、IAM ユーザー認証情報やルート認証情報などの永続認証情報を `awscurl` で使用するのが一般的でしたが、これは推奨されません。代わりに、[AWS セキュリティトークンサービス (STS) API](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_temp_request.html) のいずれか、またはその[AWS CLI ラッパー](https://docs.aws.amazon.com/cli/latest/reference/sts/index.html)のいずれかを使用して、一時的な認証情報を生成してください。
STS 呼び出しによって返される `AccessKeyId`、`SecretAccessKey`、および `SessionToken` 値は、設定ファイルではなく、シェルセッション内の適切な環境変数に置くのが最善です。その後、シェルを終了すると、認証情報は自動的に破棄されますが、設定ファイルの場合はそうではありません。同様に、一時的な認証情報について、必要と思われる期間よりも長い期間をリクエストしないでください。
次の例は、Linux シェルで [sts assume-role](https://docs.aws.amazon.com/cli/latest/reference/sts/assume-role) を使用して 30 分有効な一時的な認証情報を取得し、`awscurl` で検索できる環境変数に格納する手順を示しています。
```
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
```
その後、`awscurl` を使用して DB クラスターに次のような署名付きリクエストを行うことができます。
```
awscurl (your cluster endpoint):8182/status \
--region us-east-1 \
--service neptune-db
```
# Gremlin コンソールでの IAM 認証を使用した Amazon Neptune データベースへの接続
署名バージョン 4 認証で Gremlin コンソールを使用して Amazon Neptune に接続するには、 `requestInterceptor()` を使用して SigV4 署名者を `:remote` コマンドによって確立された接続に接続します。そのためには、`Cluster`オブジェクトを手動で設定し、 `:remote` コマンドに渡す必要があります。
これは、`:remote` コマンドが設定ファイルを使用して接続を形成する一般的な状況とはかなり異なる点に注意してください。設定ファイルによるアプローチでは、`requestInterceptor()` をプログラムで設定する必要があり、ファイルから設定を読み込むことができないため、機能しません。
**注記**
次の例では`requestInterceptor()`、TinkerPop 3.6.6 で導入された を使用します。3.6.6 より前の TinkerPop バージョン (ただし 3.5.5 以降) を使用している場合は、以下のコード例`requestInterceptor()`で `handshakeInterceptor()` の代わりに を使用します。
以下の前提条件が必要です。
+ リクエストに署名するために必要な IAM 認証情報を持っている必要があります。「 AWS SDK for Java デベロッパーガイド[」の「デフォルトの認証情報プロバイダーチェーン](https://docs.aws.amazon.com//sdk-for-java/latest/developer-guide/credentials-chain.html)の使用」を参照してください。
+ DB クラスターで使用されている Neptune エンジンのバージョンと互換性のある Gremlin コンソールバージョンをインストールしておく必要があります。
一時的な認証情報を使用している場合、セッショントークンと同様に、指定した間隔が過ぎると有効期限が切れるため、新しい認証情報をリクエストするときはセッショントークンを更新する必要があります。IAM [ユーザーガイドの「一時的なセキュリティ認証情報を使用して AWS リソースへのアクセスをリクエスト](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_temp_use-resources.html)する」を参照してください。
SSL/TLS を使用して接続する方法については、「[SSL/TLS 設定](access-graph-gremlin-java.md#access-graph-gremlin-java-ssl)」を参照してください。
**Sig4 署名を使用して Gremlin コンソールを接続する**
1. Gremlin コンソールを起動します。
```
$ bin/gremlin.sh
```
1. `gremlin>` プロンプトで、`amazon-neptune-sigv4-signer` ライブラリをインストールします (これはコンソールで 1 回だけ行う必要があります)。
```
:install com.amazonaws amazon-neptune-sigv4-signer 2.4.0
```
このステップで問題が発生した場合は、[TinkerPop ドキュメント](https://tinkerpop.apache.org/docs/current/reference/#gremlin-applications)で [Grape](http://docs.groovy-lang.org/latest/html/documentation/grape.html) の設定を確認すると役立つ場合があります。
**注記**
HTTP プロキシを使用している場合、このステップで `:install` コマンドが完了しないというエラーが発生することがあります。この問題を解決するには、以下のコマンドを実行して、プロキシについてコンソールに通知します。
```
System.setProperty("https.proxyHost", "(the proxy IP address)")
System.setProperty("https.proxyPort", "(the proxy port)")
```
1. `requestInterceptor()` へのサインインの処理に必要なクラスをインポートします。
```
:import software.amazon.awssdk.auth.credentials.DefaultCredentialsProvider
:import com.amazonaws.neptune.auth.NeptuneNettyHttpSigV4Signer
```
1. 一時的な認証情報を使用する場合は、以下のようにセッショントークンも指定する必要があります。
```
System.setProperty("aws.sessionToken","(your session token)")
```
1. アカウント認証情報をまだ設定していない場合は、以下のように割り当てることができます。
```
System.setProperty("aws.accessKeyId","(your access key)")
System.setProperty("aws.secretKey","(your secret key)")
```
1. Neptune に接続するように、`Cluster` オブジェクトを手動で設定します。
```
cluster = Cluster.build("(host name)") \
.enableSsl(true) \
.requestInterceptor { r -> \
def sigV4Signer = new NeptuneNettyHttpSigV4Signer("(Amazon region)", \
DefaultCredentialsProvider.create()); \
sigV4Signer.signRequest(r); \
return r; } \
.create()
```
Neptune DB インスタンスのホスト名を見つける方法については、「[Amazon Neptune エンドポイントに接続する](feature-overview-endpoints.md)」を参照してください。
1. 前のステップの `Cluster` オブジェクトの変数名を使用して `:remote` 接続を確立します。
```
:remote connect tinkerpop.server cluster
```
1. 次のコマンドを入力して、リモートモードに切り替えます。これにより、すべての Gremlin クエリがリモート接続に送信されます。
```
:remote console
```
# Gremlin Java による IAM を使用した Amazon Neptune データベースへの接続
Sig4 署名で Gremlin Java API を使用して Neptune に接続する方法の例を示します (Maven の使用に関する一般的な知識を前提としています）。この例では、[Amazon Neptune SigV4 Signer](https://github.com/aws/amazon-neptune-sigv4-signer) ライブラリを使用して署名をリクエストすることを支援します。まず、`pom.xml` ファイルの一部として依存関係を定義します。
**注記**
次の例では`requestInterceptor()`、TinkerPop 3.6.6 で導入された を使用します。3.6.6 より前の TinkerPop バージョン (ただし 3.5.5 以降) を使用している場合は、以下のコード例`requestInterceptor()`で `handshakeInterceptor()` の代わりに を使用します。
```
com.amazonaws
amazon-neptune-sigv4-signer
3.1.0
```
Amazon Neptune SigV4 Signer は、Java SDK のバージョン 1.x と 2.x AWS の両方をサポートしています。次の例では 2.x を使用していますが、 `DefaultCredentialsProvider`は`software.amazon.awssdk.auth.credentials.AwsCredentialsProvider`インスタンスです。1.x から 2.x にアップグレードする場合は、 AWS SDK for Java 2.x ドキュメントの[「認証情報プロバイダーの変更](https://docs.aws.amazon.com//sdk-for-java/latest/developer-guide/migration-client-credentials.html)」を参照してください。
```
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);
}
```
## クロスアカウント IAM 認証
Amazon Neptune は、ロールの仮定を使用することによるクロスアカウント IAM 認証をサポートしています。これは、[ロールの連鎖](https://docs.aws.amazon.com//neptune/latest/userguide/bulk-load-tutorial-chain-roles.html#bulk-load-tutorial-chain-cross-account)とも呼ばれます。別の AWS アカウントでホストされているアプリケーションから Neptune クラスターへのアクセスを提供するには:
+ ユーザーまたはロールが別の IAM ロールを引き受けることを許可する信頼ポリシーを使用して、アプリケーション AWS アカウントに新しい IAM ユーザーまたはロールを作成します。このロールをアプリケーションをホストするコンピューティング (EC2 インスタンス、Lambda 関数、ECS タスクなど) に割り当てます。
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Sid": "assumeRolePolicy",
"Effect": "Allow",
"Action": "sts:AssumeRole",
"Resource": "arn:aws:iam::111122223333:role/role-name"
}
]
}
```
------
+ Neptune データベースへのアクセスを許可し、アプリケーション AWS アカウントの IAM ユーザー/ロールからのロールの引き受けを許可する新しい IAM ロールを Neptune データベースアカウントに作成します。次の信頼ポリシーを使用します。
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Principal": {
"AWS": [
"(ARN of application account IAM user or role)"
]
},
"Action": "sts:AssumeRole",
"Condition": {}
}
]
}
```
------
+ これらの 2 つのロールを使用してアプリケーションが Neptune にアクセスできるようにする方法のガイダンスとして次のコード例を使用します。この例では、アプリケーションアカウントロールは、`STSclient` の作成時に [DefaultCredentialProviderChain](https://docs.aws.amazon.com//sdk-for-java/v1/developer-guide/credentials.html) を介して引き受けられます。その後、 `STSclient`は を介して使用され`STSAssumeRoleSessionCredentialsProvider`、Neptune データベース AWS アカウントでホストされているロールを引き受けます。
```
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();
}
```
# Java および SPARQL による IAM 認証を使用した Amazon Neptune データベースへの接続
このセクションでは、RDF4J または Apache Jena で署名バージョン 4 認証を使用して Neptune に接続する方法を示します。
**前提条件**
+ Java 8 以上
+ Apache Maven 3.3 以上
Amazon Linux を実行している EC2 インスタンスに前提条件となっているこれらのソフトウェアをインストールする方法については、「[IAM 認証を使用して Amazon Neptune データベースを接続するための前提条件](iam-auth-connect-prerq.md)」を参照してください。
+ リクエストに署名するための IAM 認証情報。詳細については、*AWS SDK for Java デベロッパーガイド*の[デフォルトの認証情報プロバイダーチェーンの使用](https://docs.aws.amazon.com/sdk-for-java/v1/developer-guide/credentials.html#credentials-default)を参照してください。
**注記**
一時的なセキュリティ認証情報を使用している場合は、*セッショントークンを含めて*、指定した期間が過ぎると失効します。
新しい認証情報をリクエストするときは、セッショントークンを更新する必要があります。詳細については、*IAM ユーザーガイド*の[「一時的なセキュリティ認証情報を使用して AWS リソースへのアクセスをリクエストする](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_temp_use-resources.html)」を参照してください。
+ `SERVICE_REGION` 変数を次のいずれかに設定し、Neptune DB インスタンスのリージョンを指定します。
+ 米国東部 (バージニア北部): `us-east-1`
+ 米国東部 (オハイオ): `us-east-2`
+ 米国西部 (北カリフォルニア): `us-west-1`
+ 米国西部 (オレゴン): `us-west-2`
+ カナダ (中部): `ca-central-1`
+ カナダ西部 (カルガリー): `ca-west-1`
+ 南米 (サンパウロ): `sa-east-1`
+ 欧州 (ストックホルム): `eu-north-1`
+ 欧州 (スペイン): `eu-south-2`
+ 欧州 (アイルランド): `eu-west-1`
+ 欧州 (ロンドン): `eu-west-2`
+ 欧州 (パリ): `eu-west-3`
+ 欧州 (フランクフルト): `eu-central-1`
+ 中東 (バーレーン): `me-south-1`
+ 中東 (アラブ首長国連邦): `me-central-1`
+ イスラエル (テルアビブ): `il-central-1`
+ アフリカ (ケープタウン): `af-south-1`
+ アジアパシフィック (香港): `ap-east-1`
+ アジアパシフィック (東京): `ap-northeast-1`
+ アジアパシフィック (ソウル): `ap-northeast-2`
+ アジアパシフィック (大阪): `ap-northeast-3`
+ アジアパシフィック (シンガポール): `ap-southeast-1`
+ アジアパシフィック (シドニー): `ap-southeast-2`
+ アジアパシフィック (ジャカルタ): `ap-southeast-3`
+ アジアパシフィック (メルボルン): `ap-southeast-4`
+ アジアパシフィック (マレーシア): `ap-southeast-5`
+ アジアパシフィック (ムンバイ): `ap-south-1`
+ アジアパシフィック (ハイデラバード): `ap-south-2`
+ 中国 (北京): `cn-north-1`
+ 中国 (寧夏): `cn-northwest-1`
+ AWS GovCloud (米国西部): `us-gov-west-1`
+ AWS GovCloud (米国東部): `us-gov-east-1`
**RDF4J または Apache Jena でバージョン 4 署名を使用して Neptune に接続するには**
1. GitHub からサンプルリポジトリを複製します。
```
git clone https://github.com/aws/amazon-neptune-sparql-java-sigv4.git
```
1. 複製したディレクトリに変更します。
```
cd amazon-neptune-sparql-java-sigv4
```
1. 最新のタグブランチをチェックアウトして、プロジェクトの最新バージョンを取得します。
```
git checkout $(git describe --tags `git rev-list --tags --max-count=1`)
```
1. 以下のいずれかのコマンドを入力して、サンプルコードをコンパイルして実行します。
*your-neptune-endpoint*を Neptune DB インスタンスのホスト名または IP アドレスで置き換えます。デフォルトのポート番号は 8182 です。
**注記**
Neptune DB インスタンスのホスト名を見つける方法については、[Amazon Neptune エンドポイントに接続する](feature-overview-endpoints.md) セクションを参照してください。
**Eclipse RDF4J**
以下のように入力して、RDF4J の例を実行します。
```
mvn compile exec:java \
-Dexec.mainClass="com.amazonaws.neptune.client.rdf4j.NeptuneRdf4JSigV4Example" \
-Dexec.args="https://your-neptune-endpoint:portsparql region-name"
```
**Apache Jena**
Apache Jena 例を実行する次のコマンドを入力します。
```
mvn compile exec:java \
-Dexec.mainClass="com.amazonaws.neptune.client.jena.NeptuneJenaSigV4Example" \
-Dexec.args="https://your-neptune-endpoint:port"
```
1. この例のソースコードを表示するには、`src/main/java/com/amazonaws/neptune/client/` ディレクトリにある例を参照してください。
独自の Java アプリケーションで SigV4 署名ドライバーを使用するには、`pom.xml` の `` セクションに `amazon-neptune-sigv4-signer` Maven パッケージを追加します。これらの例を出発点として使用することをお勧めします。
# SPARQL と Node.js による IAM 認証を使用した Amazon Neptune データベースへの接続
## 署名 V4 署名と AWS SDK for Javascript V3 を使用したクエリ
署名バージョン 4 認証と AWS SDK for Javascript V3 で Node.js を使用して Neptune SPARQL に接続する方法の例を次に示します。
```
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);
}
);
}
```
## 署名 V4 署名と AWS SDK for Javascript V2 を使用したクエリ
署名バージョン 4 認証と AWS SDK for Javascript V2 で Node.js を使用して Neptune SPARQL に接続する方法の例を次に示します。
```
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);
});
}
```
# Python による IAM 認証を使用した Amazon Neptune データベースへの接続
このセクションでは、署名バージョン 4 を使用して Amazon Neptune に接続する方法について、Python で記述されたプログラム例を挙げて説明します。この例は、[https://docs.aws.amazon.com/general/latest/gr/sigv4-signed-request-examples.html](https://docs.aws.amazon.com/general/latest/gr/sigv4-signed-request-examples.html)* のセクション「Amazon Web Services 全般のリファレンス署名バージョン 4 の署名プロセス*」内の例に基づいています。
このプログラム例を使用するには、以下が必要です。
+ コンピュータにインストール済みの Python 3.x。[Python のサイト](https://www.python.org/downloads/)から入手できます。これらのプログラムは、Python 3.6 でテスト済みです。
+ [Python のリクエストライブラリ](https://pypi.python.org/pypi/requests)。これは、ウェブリクエストを作成するスクリプト例で使用します。Python パッケージをインストールする便利な方法は、`pip` を使用することです。これは、Python パッケージインデックスサイトからパッケージを取得します。その後で、コマンドラインから `requests` を実行すると、`pip install requests` をインストールすることができます。
+ `AWS_ACCESS_KEY_ID` および `AWS_SECRET_ACCESS_KEY` という名前の環境変数で指定したアクセスキー（アクセスキー ID およびシークレットアクセスキー）。ベストプラクティスとして、認証情報をコードに埋め込ま*ない*ことをお勧めします。詳細については、*AWS アカウント管理 リファレンスガイド*の「[AWS アカウントのベストプラクティス](https://docs.aws.amazon.com//accounts/latest/reference/best-practices.html)」を参照してください。
`SERVICE_REGION` という環境変数の Neptune DB クラスターのリージョン。
一時的なセキュリティ認証情報を使用している場合は、`AWS_ACCESS_KEY_ID`、`AWS_SECRET_ACCESS_KEY`、`SERVICE_REGION` に加えて `AWS_SESSION_TOKEN` を指定する必要があります。
**注記**
一時的なセキュリティ認証情報を使用している場合は、*セッショントークンを含めて*、指定した期間が過ぎると失効します。
新しい認証情報をリクエストするときは、セッショントークンを更新する必要があります。詳細については、[一時的なセキュリティ認証情報を使用して AWS リソースへのアクセスをリクエストする](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_temp_use-resources.html)をご参照ください。
以下の例では、Python を使用して Neptune に署名付きリクエストを行う方法を示します。このリクエストは、GET リクエストまたは POST リクエストのいずれかを行います。認証情報は、`Authorization` リクエストヘッダーを使用して渡されます。
この例では、 AWS Lambda 関数としても機能します。詳細については、「[Neptune IAM 認証用の AWS Lambda のセットアップ](iam-auth-temporary-credentials.md#iam-auth-temporary-credentials-lambda)」を参照してください。
**Gremlin および SPARQL Neptune エンドポイントへの署名付きリクエストを行うには**
1. `neptunesigv4.py` という名前のファイルを作成し、テキストエディタで開きます。
1. 以下のテキストを `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. ターミナルで、`neptunesigv4.py` ファイルの場所に移動します。
1. 以下のコマンドを入力して、アクセスキー、シークレットキー、リージョンを正しい値に置き換えます。
```
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
```
一時的なセキュリティ認証情報を使用している場合は、`AWS_ACCESS_KEY_ID`、`AWS_SECRET_ACCESS_KEY`、`SERVICE_REGION` に加えて `AWS_SESSION_TOKEN` を指定する必要があります。
```
export AWS_SESSION_TOKEN=MY_AWS_SESSION_TOKEN
```
**注記**
一時的なセキュリティ認証情報を使用している場合は、*セッショントークンを含めて*、指定した期間が過ぎると失効します。
新しい認証情報をリクエストするときは、セッショントークンを更新する必要があります。詳細については、[一時的なセキュリティ認証情報を使用して AWS リソースへのアクセスをリクエストする](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_temp_use-resources.html)をご参照ください。
1. 以下のコマンドのいずれかを入力して、Neptune DB インスタンスに署名付きリクエストを送信します。これらの例では Python バージョン 3.6 を使用します。
**エンドポイントのステータス**
```
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()"
```
**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 { }"
```
**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;"
```
**OpenCypherのステータス**
```
python3.6 neptunesigv4.py -ho your-neptune-endpoint -p 8182 -a GET -q openCypher/status
```
[**ローダー**]
```
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. 以下に示しているのは、Python スクリプトを実行するための構文です。
```
python3.6 neptunesigv4.py -ho your-neptune-endpoint -p port -a GET|POST -q gremlin|sparql|sparqlupdate|loader|status -d "string0data"
```
SPARQL UPDATE では `POST` が必要です。
# Gremlin Python による IAM 認証を使用した Amazon Neptune データベースへの接続
## 概要:
このガイドでは、署名バージョン 4 認証と AWS SDK for Python (Boto3) を使用して、Gremlin Python ドライバーを使用して IAM 認証を有効にした Amazon Neptune データベースに接続する方法を示します。
## 基本的な接続を作成する
Gremlin Python ドライバーを使用して IAM 認証との基本的な接続を確立する方法のガイダンスとして、次のコード例を使用します。
```
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()
```
# Gremlin JavaScript による IAM 認証を使用した Amazon Neptune データベースへの接続
## 概要:
このガイドでは、署名バージョン 4 認証と AWS SDK for Javascript v3 を使用して、Gremlin JavaScript ドライバーを使用して IAM 認証を有効にし Amazon Neptune データベースに接続する方法を示します。
## 前提条件
+ IAM 認証が有効になっている Amazon Neptune クラスター。
+ ノード 13 以降 (Gremlin JavaScript および [AWS SDK for Javascript v3 ](https://docs.aws.amazon.com//AWSJavaScriptSDK/v3/latest/introduction/#release-cadence)の最小バージョンを参照)。
+ AWS 設定された認証情報 (環境変数、共有認証情報ファイル、または IAM ロール経由）。
## 基本的な接続を作成する
Gremlin JavaScript ドライバーを使用して IAM 認証との基本的な接続を確立する方法のガイダンスとして、次のコード例を使用します。
```
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();
```
# Gremlin Go による IAM 認証を使用した Amazon Neptune データベースへの接続
## 概要:
このガイドでは、Gremlin Go ドライバーを使用して IAM 認証を有効にし、署名バージョン 4 認証と AWS SDK for GO v2 を使用して Amazon Neptune データベースに接続する方法を示します。
## 前提条件
+ IAM 認証が有効になっている Amazon Neptune クラスター。
+ Go 1.22 以降 ([Gremlin Go ](https://pkg.go.dev/github.com/apache/tinkerpop/gremlin-go/v3/driver)および [AWS SDK for Go v2 ](https://pkg.go.dev/github.com/aws/aws-sdk-go-v2)でサポートされている最小バージョンを参照)。
+ AWS 設定された認証情報 (環境変数、共有認証情報ファイル、または IAM ロール経由)
## 基本的な接続を作成する
Gremlin Go ドライバーを使用して IAM 認証との基本的な接続を確立する方法のガイダンスとして、次のコード例を使用します。
```
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)
}
```
## Gremlin Go の動的認証情報の更新
Gremlin Go には 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)
}
```
# Gremlin .NET による IAM 認証を使用した Amazon Neptune データベースへの接続
## 概要:
このガイドでは、署名バージョン 4 認証と AWS SDK for .NET v3 を使用して、Gremlin .NET ドライバーを使用して IAM 認証を有効にして Amazon Neptune データベースに接続する方法を示します。
## 基本的な接続を作成する
Gremlin .NET と接続するには、カスタムライブラリ [https://github.com/aws/amazon-neptune-gremlin-dotnet-sigv4 ](https://github.com/aws/amazon-neptune-gremlin-dotnet-sigv4)の `SigV4RequestSigner` ソースファイルを使用します。プロジェクトのセットアップの例は [https://github.com/aws/amazon-neptune-gremlin-dotnet-sigv4/tree/main/example ](https://github.com/aws/amazon-neptune-gremlin-dotnet-sigv4/tree/main/example)にあり、以下の内容に反映されています。
プロジェクトのファイル:
```
Exe
netcoreapp8.0
```
プログラムの例:
```
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);
}
}
}
}
```