翻訳は機械翻訳により提供されています。提供された翻訳内容と英語版の間で齟齬、不一致または矛盾がある場合、英語版が優先します。
# Amazon Neptune データベースの保護
のクラウドセキュリティが最優先事項 AWS です。お客様は AWS 、セキュリティを最も重視する組織の要件を満たすように構築されたデータセンターとネットワークアーキテクチャを活用できます。
セキュリティは、 AWS お客様とお客様の間の責任共有です。[責任共有モデル](https://aws.amazon.com/compliance/shared-responsibility-model/)では、これをクラウドのセキュリティおよびクラウド内のセキュリティとして説明しています。
+ **クラウドのセキュリティ** – AWS は、 AWS クラウドで AWS サービスを実行するインフラストラクチャを保護する責任を担います。 は、お客様が安全に使用できるサービス AWS も提供します。[「AWS 」 コンプライアンスプログラム](https://aws.amazon.com/compliance/programs/)の一環として、サードパーティーの監査が定期的にセキュリティの有効性をテストおよび検証しています。Amazon Neptune に適用されるコンプライアンスプログラムについては、[コンプライアンスプログラムによるAWS 対象範囲内のサービス](https://aws.amazon.com/compliance/services-in-scope/)を参照してください。
+ **クラウド内のセキュリティ** – お客様の責任は、使用する AWS サービスによって決まります。また、ユーザーは、データの機密性、会社の要件、適用される法律や規制など、その他の要因についても責任を負います。
このドキュメントは、Neptune を使用する際に責任共有モデルを適用する方法を理解するのに役立ちます。以下のトピックでは、セキュリティおよびコンプライアンスの目的を達成するために Neptune を設定する方法を示します。また、Neptune リソースのモニタリングや保護に役立つ他の AWS サービスの使用方法についても説明します。
**Topics**
+ [Amazon Neptune オペレーティングシステムのアップグレード](security-os-upgrades.md)
+ [Amazon Neptune データベース内のデータの保護](data-protection.md)
+ [を使用した Amazon Neptune データベースの認証 AWS Identity and Access Management](iam-auth.md)
+ [Amazon Neptune で IAM データベース認証を有効にする](iam-auth-enable.md)
+ [AWS Identity and Access Management 認証を使用した Amazon Neptune データベースへの接続](iam-auth-connecting.md)
+ [IAM ポリシーを使用した Amazon Neptune データベースへのアクセスの管理](security-iam-access-manage.md)
+ [Amazon Neptune のサービスにリンクされたロールの使用](security-iam-service-linked-roles.md)
+ [一時認証情報を使用した Amazon Neptune への接続](iam-auth-temporary-credentials.md)
+ [Amazon Neptune での使用状況とパフォーマンスのログ記録およびモニタリング](security-monitoring.md)
+ [Amazon Neptune とインターフェイス VPC エンドポイント (AWS PrivateLink)](vpc-interface-endpoints.md)
+ [Amazon Neptune のコンプライアンスに関する考慮事項](neptune-compliance.md)
+ [回復力と耐障害性に優れた Amazon Neptune デプロイの構築](disaster-recovery-resiliency.md)
# Amazon Neptune オペレーティングシステムのアップグレード
Amazon Neptune は、定期的な OS アップグレードを通じて、データベースのパフォーマンス、セキュリティ、安定性を継続的に改善します。これらのアップグレードは、構造化された更新プロセスに従って、Neptune データベースと Neptune Analytics の両方に適用されます。Amazon Neptune は、少なくとも 1 か月に 1 回 OS アップグレードをリリースします。
ダウンタイムを必要としない Neptune データベース OS の更新は、メンテナンスウィンドウ中に自動的に適用されます。特定の OS 更新 (カーネルバージョンのアップグレードなど) では、インスタンスの再起動が必要です。これらの更新はオプションであり、適用する日付が設定されていません。ただし、これらの更新を適用しないと、インスタンスのメンテナンスウィンドウ中に最終的に必要になり、想定外のタイミングで自動的に適用される場合があります。
**Neptune Analytics** – Neptune Analytics OS のアップグレードはシームレスであり、顧客のアクションは必要ありません。これらの更新は、ダウンタイムが発生することなくバックグラウンドで自動的に適用されます。
セキュリティとコンプライアンスを維持するために、メンテナンスウィンドウ中に Amazon Neptune で利用可能になったすべての更新を定期的に適用することをお勧めします。すべてのオプションおよび必須の更新を最新の状態に保つことで、重要なセキュリティパッチを組み込み、さまざまなコンプライアンス義務との整合性を確保できます。古い OS バージョンでは、規制要件に準拠していない可能性があります。
## 再起動が必要な OS アップグレードのダウンタイムを最小限に抑える
再起動が必要な OS のアップグレードについては、クラスターの可用性を最大化するため、最初にクラスターのリーダーインスタンスを更新し、次にライターインスタンスを更新することをお勧めします。フェイルオーバーが発生するとダウンタイムが長引く可能性があるため、リーダーインスタンスとライターインスタンスを同時に更新することはお勧めしません。
## Neptune DB インスタンスへの OS アップグレードの適用
Neptune DB インスタンスでは、オペレーティングシステムの更新が必要になる場合があります。Amazon Neptune は、データベースパフォーマンスと顧客の全体的なセキュリティ体制改善のために、OS を新しいバージョンにアップグレードします。通常、アップデートには約 10 分かかります。オペレーティングシステムのアップデートでは、DB インスタンスの DB エンジンのバージョンまたは DB インスタンスクラスは変更されません。
新しいオプションの更新が利用可能になったときに通知を受けるには、セキュリティパッチイベントカテゴリの `RDS-EVENT-0230` をサブスクライブします。Amazon Neptune イベントへのサブスクライブの詳細については、「[Neptune イベント通知へのサブスクライブ](https://docs.aws.amazon.com//neptune/latest/userguide/events-subscribing.html)」を参照してください。
**重要**
Amazon Neptune DB インスタンスは、オペレーティングシステムのアップグレード中はオフラインになります。マルチインスタンスクラスターを使用することで、クラスターのダウンタイムを最小限に抑えることができます。マルチインスタンスクラスターがない場合は、セカンダリインスタンスの追加によりマルチインスタンスクラスターを一時的に構築し、メンテナンスが完了したら追加した読み取りインスタンス (複数可) を削除することができます (セカンダリインスタンス向けの通常の料金が適用されます)。
AWS マネジメントコンソール または CLI AWS を使用して、更新が利用可能かどうかを判断できます。
### の使用 AWS マネジメントコンソール
AWS マネジメントコンソールを使用して、利用可能な更新があるかどうかを確認するには:
1. AWS マネジメントコンソールにサインインし、[https://console.aws.amazon.com/neptune/home](https://console.aws.amazon.com/neptune/home) で Amazon Neptune コンソールを開きます。
1. ナビゲーションペインで **[クラスター]** を選択してから、インスタンスを選択します。
1. **[メンテナンス]** を選択します。
1. **[保留中のメンテナンス]** セクションで、オペレーティングシステムの更新を検索します。
![\[AWS マネジメントコンソール メンテナンスセクションと利用可能な OS 更新を示す画像。\]](http://docs.aws.amazon.com/ja_jp/neptune/latest/userguide/images/consoleForOSUpgrades.png)
オペレーティングシステムの更新を選択し、**[保留中のメンテナンス]** セクションの **[今すぐ適用]** または **[次のメンテナンスウィンドウで適用]** をクリックすることができます。メンテナンス値が **[次のウィンドウ]** である場合は、**[後でアップグレード]** を選択してメンテナンス項目を延期します。既にスタートしているメンテナンスアクションは延期できません。
または、ナビゲーションペインの **[クラスター]** をクリックしてクラスターのリストからインスタンスを選択し、**[アクション]** メニューから **[今すぐ適用]** または **[次のメンテナンスウィンドウで適用]** を選択することもできます。
### CLI AWS の使用
を使用して更新が使用可能かどうかを確認するには AWS CLI、 `describe-pending-maintenance-actions` コマンドを呼び出します。
```
aws neptune describe-pending-maintenance-actions
```
```
{
"ResourceIdentifier": "arn:aws:rds:us-east-1:123456789012:db:myneptune",
"PendingMaintenanceActionDetails": [
{
"Action": "system-update",
"Description": "New Operating System update is available"
}
]
}
```
オペレーティングシステムの更新を適用するには、`apply-pending-maintenance-action` コマンドを呼び出します。
```
aws neptune apply-pending-maintenance-action \
--apply-action system-update \
--resource-identifier (ARN of your DB instance) \
--opt-in-type immediate
```
# Amazon Neptune データベース内のデータの保護
責任 AWS [共有モデル](https://aws.amazon.com/compliance/shared-responsibility-model/)、Amazon Neptune でのデータ保護に適用されます。このモデルで説明されているように、 AWS はすべての を実行するグローバルインフラストラクチャを保護する責任があります AWS クラウド。ユーザーは、このインフラストラクチャでホストされるコンテンツに対する管理を維持する責任があります。また、使用する「 AWS のサービス 」のセキュリティ設定と管理タスクもユーザーの責任となります。データプライバシーの詳細については、[データプライバシーに関するよくある質問](https://aws.amazon.com/compliance/data-privacy-faq/)を参照してください。欧州でのデータ保護の詳細については、*AWS セキュリティブログ*に投稿された「[AWS 責任共有モデルおよび GDPR](https://aws.amazon.com/blogs/security/the-aws-shared-responsibility-model-and-gdpr/)」のブログ記事を参照してください。
データ保護の目的で、認証情報を保護し AWS アカウント 、 AWS IAM アイデンティティセンター または AWS Identity and Access Management (IAM) を使用して個々のユーザーを設定することをお勧めします。この方法により、それぞれのジョブを遂行するために必要な権限のみが各ユーザーに付与されます。また、次の方法でデータを保護することもお勧めします:
+ 各アカウントで多要素認証 (MFA) を使用します。
+ SSL/TLS を使用して AWS リソースと通信します。TLS 1.2 は必須ですが、TLS 1.3 を推奨します。
+ で API とユーザーアクティビティのログ記録を設定します AWS CloudTrail。CloudTrail 証跡を使用して AWS アクティビティをキャプチャする方法については、「 *AWS CloudTrail ユーザーガイド*」の[CloudTrail 証跡の使用](https://docs.aws.amazon.com/awscloudtrail/latest/userguide/cloudtrail-trails.html)」を参照してください。
+ AWS 暗号化ソリューションと、 内のすべてのデフォルトのセキュリティコントロールを使用します AWS のサービス。
+ Amazon Macie などの高度な管理されたセキュリティサービスを使用します。これらは、Amazon S3 に保存されている機密データの検出と保護を支援します。
+ コマンドラインインターフェイスまたは API AWS を介して にアクセスするときに FIPS 140-3 検証済み暗号化モジュールが必要な場合は、FIPS エンドポイントを使用します。利用可能な FIPS エンドポイントの詳細については、「[連邦情報処理規格 (FIPS) 140-3](https://aws.amazon.com/compliance/fips/)」を参照してください。
お客様の E メールアドレスなどの極秘または機密情報を、タグ、または **[名前]** フィールドなどの自由形式のテキストフィールドに含めないことを強くお勧めします。これは、コンソール、API、または SDK を使用して Neptune AWS CLIまたは他の AWS のサービス を操作する場合も同様です。 AWS SDKs タグ、または名前に使用される自由記述のテキストフィールドに入力したデータは、請求または診断ログに使用される場合があります。外部サーバーに URL を提供する場合、そのサーバーへのリクエストを検証できるように、認証情報を URL に含めないことを強くお勧めします。
**重要**
TLS 1.3 は Neptune エンジンバージョン 1.3.2.0 以降でのみサポートされています。
AWS 公開された API コールを使用して、ネットワーク経由で Neptune を管理します。クライアントは、[Neptune データベースへの接続の暗号化](security-ssl.md) に記載のように、強力な暗号スイートを使用して Transport Layer Security (TLS) 1.2 以降をサポートする必要があります。これらのモードは Java 7 以降など、ほとんどの最新システムでサポートされています。
以下のセクションでは、Neptune データが保護される仕組みについて説明します。
**Topics**
+ [Amazon VPC による Amazon Neptune データベースの保護](security-vpc.md)
+ [SSL/HTTPS を使用した Amazon Neptune データベースへの接続の暗号化](security-ssl.md)
+ [Amazon Neptune データベースに保管中のデータの暗号化](encrypt.md)
# Amazon VPC による Amazon Neptune データベースの保護
Amazon Neptune DB クラスターは、Amazon Virtual Private Cloud (Amazon VPC) に*のみ*作成でき、そのエンドポイントにはその VPC 内でアクセス可能であり、通常、その VPC で実行している Amazon Elastic Compute Cloud (Amazon EC2) インスタンスからです。または、パブリックエンドポイントを使用してアクセスすることもできます。パブリックエンドポイントの詳細については、「[Neptune パブリックエンドポイント](neptune-public-endpoints.md)」を参照してください。
[Amazon Neptune クラスターへの接続](get-started-connecting.md) で説明されているように、Neptune DB クラスターが配置されている VPC へのアクセスを制限することで、Neptune データを保護できます。
# SSL/HTTPS を使用した Amazon Neptune データベースへの接続の暗号化
Amazon Neptune では、インスタンスまたはクラスターエンドポイントへの HTTPS 経由の Secure Sockets Layer (SSL) 接続のみが許可されます。
Neptune では、以下の強力な暗号スイートを使用する、TLS バージョン 1.2 以降が必要です。
+ `TLS_ECDHE_ECDSA_WITH_AES_128_GCM_SHA256`
+ `TLS_ECDHE_ECDSA_WITH_AES_256_GCM_SHA384`
+ `TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256`
+ `TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384`
Neptune エンジンバージョン 1.3.2.0 以降において、Neptune は次の暗号スイートを使用して TLS バージョン 1.3 をサポートしています。
+ TLS\$1AES\$1128\$1GCM\$1SHA256
+ TLS\$1AES\$1256\$1GCM\$1SHA384
以前のエンジンバージョンで HTTP 接続が許可されている場合でも、新しい DB クラスターパラメータグループを使用する DB クラスターは、デフォルトで SSL を使用する必要があります。*データを保護するため、エンジンバージョン `1.0.4.0` 以上の Neptune エンドポイントは HTTPS リクエストのみをサポートします。*詳細については「[HTTP REST エンドポイントを使用して Neptune DB インスタンスに接続する](access-graph-sparql-http-rest.md)」を参照してください。
Neptune は Neptune DB インスタンスの SSL 証明書を自動的に提供します。証明書をリクエストする必要はありません。新しいインスタンスを作成するときに、証明書が提供されます。
Neptune は、各 AWS リージョンのアカウント内のインスタンスに 1 つのワイルドカード SSL 証明書を割り当てます。証明書では、クラスターエンドポイント、クラスターの読み取り専用エンドポイント、インスタンスエンドポイントのエントリが提供されます。
**証明書の詳細**
提供された証明書には以下のエントリが含まれます。
+ クラスターエンドポイント — `*.cluster-a1b2c3d4wxyz.region.neptune.amazonaws.com`
+ 読み取り専用エンドポイント — `*.cluster-ro-a1b2c3d4wxyz.region.neptune.amazonaws.com`
+ インスタンスエンドポイント — `*.a1b2c3d4wxyz.region.neptune.amazonaws.com`
ここにリストされているエントリのみがサポートされています。
**プロキシ接続**
証明書では前のセクションでリストされたホスト名のみがサポートされています。
ロードバランサーまたはプロキシサーバー (HAProxy など) を使用している場合は、SSL ターミネーションを使用して独自の SSL 証明書をプロキシサーバーに保存する必要があります。
提供された SSL 証明書はプロキシサーバーのホスト名と一致しないため、SSL パススルーは機能しません。
**ルート CA 証明書**
Neptune インスタンスの証明書は通常、オペレーティングシステムまたは SDK (Java SDK など) のローカル信頼ストアを使用して検証されます。
ルート証明書を手動で入力する必要がある場合は、[Amazon トラストサービスポリシーリポジトリ](https://www.amazontrust.com/repository/)から PEM 形式で [Amazon Root CA 証明書](https://www.amazontrust.com/repository/AmazonRootCA1.pem)をダウンロードしてください。
**詳細情報**
SSL を使用した Neptune エンドポイントへの接続の詳細については、[Gremlin コンソールをセットアップして Neptune DB インスタンスに接続する](access-graph-gremlin-console.md) および [HTTP REST エンドポイントを使用して Neptune DB インスタンスに接続する](access-graph-sparql-http-rest.md) を参照してください。
# Amazon Neptune データベースに保管中のデータの暗号化
Neptune の暗号化されたインスタンスは、基になるストレージへの不正アクセスからデータを保護することで、データ保護のレイヤーを追加します。Neptune の暗号化を使用すると、クラウドにデプロイされたアプリケーションのデータ保護を強化できます。また、保管時のデータの暗号化に関するコンプライアンス要件を満たす場合にも使用できます。
Neptune リソースの暗号化と復号に使用されるキーを管理するには、 [AWS Key Management Service (AWS KMS)](https://docs.aws.amazon.com/kms/latest/developerguide/). AWS KMS combines を使用して、安全で可用性の高いハードウェアとソフトウェアを使用し、クラウド向けにスケーリングされたキー管理システムを提供します。を使用すると AWS KMS、暗号化キーを作成し、これらのキーの使用方法を制御するポリシーを定義できます。 は AWS KMS をサポートしているため AWS CloudTrail、キーの使用状況を監査して、キーが適切に使用されていることを確認できます。 AWS KMS キーは、Neptune および Amazon Simple Storage Service (Amazon S3)、Amazon Elastic Block Store (Amazon EBS)、Amazon Redshift などのサポートされている AWS サービスと組み合わせて使用できます。がサポートするサービスのリストについては AWS KMS、 *AWS Key Management Service デベロッパーガイド*の[「 AWS のサービスの使用方法 AWS KMS](https://docs.aws.amazon.com/kms/latest/developerguide/services.html)」を参照してください。
すべてのログ、バックアップ、スナップショットは、Neptune の暗号化されたインスタンス用に暗号化されます。
## Neptune DB インスタンスの暗号化の有効化
新しい Neptune DB インスタンスの暗号化を有効にするには、 コンソールの **[Enable encryption]** (暗号化の有効化) で **[Yes]** (はい) を選択します。Neptune DB インスタンスの作成については、[Amazon Neptune クラスターの作成](get-started-create-cluster.md) を参照してください。
暗号化された Neptune DB インスタンスを作成するときに、暗号化 AWS KMS キーのキー識別子を指定することもできます。 AWS KMS キー識別子を指定しない場合、Neptune は新しい Neptune DB インスタンスにデフォルトの Amazon RDS 暗号化キー (`aws/rds`) を使用します。 は AWS 、アカウントの Neptune のデフォルトの暗号化キー AWS KMS を作成します。 AWS アカウントには、 AWS リージョンごとに異なるデフォルトの暗号化キーがあります。
暗号化された Neptune DB インスタンスを作成したら、そのインスタンスの暗号化キーを変更することはできません。したがって、暗号化された Neptune DB インスタンスを作成する前に、暗号化キーの要件を確認してください。
別のアカウントのキーの Amazon リソースネーム (ARN) を使用して、Neptune DB インスタンスを暗号化できます。新しい Neptune DB インスタンスの AWS KMS 暗号化に使用される暗号化キーを所有するアカウントと同じ AWS アカウントで Neptune DB インスタンスを作成する場合、渡す AWS KMS キー ID は AWS KMS キーの ARN ではなくキーエイリアスになります。
**重要**
Neptune が Neptune DB インスタンスの暗号化キーにアクセスできなくなった場合 (Neptune のキーへのアクセス権が失効した場合など)、暗号化された DB インスタンスは終了状態になり、バックアップからのみ復元できます。データベース内の暗号化されたデータの消失を防ぐために、暗号化された Neptune DB インスタンスのバックアップは常に有効にしておくことを強くお勧めします。
## 暗号化を有効にするときに必要なキー許可
暗号化された Neptune DB インスタンスを作成する IAM ユーザーまたはロールには、少なくとも KMS キーに対する次の権限が必要です。
+ `"kms:Encrypt"`
+ `"kms:Decrypt"`
+ `"kms:GenerateDataKey"`
+ `"kms:ReEncryptTo"`
+ `"kms:GenerateDataKeyWithoutPlaintext"`
+ `"kms:CreateGrant"`
+ `"kms:ReEncryptFrom"`
+ `"kms:DescribeKey"`
次に、必要なアクセス権限を含むキーポリシーの例を示します。
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Id": "key-consolepolicy-3",
"Statement": [
{
"Sid": "Allow use of the key for Neptune",
"Effect": "Allow",
"Principal": {
"AWS": "arn:aws:iam::123456789012:role/NeptuneFullAccess"
},
"Action": [
"kms:Encrypt",
"kms:Decrypt",
"kms:GenerateDataKey",
"kms:ReEncryptTo",
"kms:GenerateDataKeyWithoutPlaintext",
"kms:CreateGrant",
"kms:ReEncryptFrom",
"kms:DescribeKey"
],
"Resource": "*",
"Condition": {
"StringEquals": {
"kms:ViaService": "rds.us-east-1.amazonaws.com"
}
}
},
{
"Sid": "Deny use of the key for non Neptune",
"Effect": "Deny",
"Principal": {
"AWS": "arn:aws:iam::123456789012:role/NeptuneFullAccess"
},
"Action": [
"kms:*"
],
"Resource": "*",
"Condition": {
"StringNotEquals": {
"kms:ViaService": "rds.us-east-1.amazonaws.com"
}
}
}
]
}
```
------
+ 最初のステートメントは、RDS サービスプリンシパルにスコープダウンされた、このロールに必要なすべての AWS KMS APIs へのアクセスを提供します。
+ 2 番目のステートメントでは、このキーを他の AWS サービスで使用できないように強制することで、セキュリティを強化します。
以下を追加して `createGrant` 許可をさらに範囲指定することもできます。
```
"Condition": {
"Bool": {
"kms:GrantIsForAWSResource": true
}
}
```
## Neptune 暗号化の制約事項
Neptune クラスターの暗号化には、以下の制約事項があります。
+ 暗号化されていない DB クラスターを暗号化された DB クラスターに変換することはできません。
ただし、暗号化されていない DB クラスタースナップショットを暗号化された DB クラスターに復元することができます。そのためには、暗号化されていない DB クラスタースナップショットから復元する場合は、KMS 暗号化キーを指定します。
+ 暗号化されていない DB インスタンスを暗号化された DB クラスターに変換することはできません。DB インスタンスの暗号化は、DB インスタンスの作成時にのみ有効にすることができます。
+ 暗号化された DB インスタンスを変更して暗号化を無効にすることはできません。
+ 暗号化されていない DB インスタンスのリードレプリカを暗号化することや、暗号化された DB インスタンスのリードレプリカを暗号化しないことは設定できません。
+ 暗号化されたリードレプリカは、ソース DB インスタンスと同じキーで暗号化する必要があります。
# を使用した Amazon Neptune データベースの認証 AWS Identity and Access Management
AWS Identity and Access Management (IAM) は、管理者が AWS リソースへのアクセスを安全に制御 AWS のサービス するのに役立つ です。IAM 管理者は、誰を*認証* (サインイン) し、誰に Neptune リソースの使用を*許可する* (アクセス許可を持たせる) かを制御します。IAM は、追加料金なしで使用できる AWS のサービス です。
AWS Identity and Access Management (IAM) を使用して、Neptune DB インスタンスまたは DB クラスターを認証できます。IAM データベース認証が有効になっている場合、各リクエストは AWS 署名バージョン 4 を使用して署名する必要があります。
AWS 署名バージョン 4 は AWS 、リクエストに認証情報を追加します。セキュリティ上の理由から、UAM 認証が有効である Neptune DB クラスターへのすべてのリクエストはアクセスキーを使用して署名する必要があります。このキーは、アクセスキー ID とシークレットアクセスキーで構成されます。この認証は、IAM ポリシーを使用して外部で管理されます。
Neptune は接続時、および WebSocket 接続に認証し、アクセス権限を定期的に検証して、ユーザーにアクセス権がまだあることを確認します。
**注記**
IAM ユーザーに関連付けられている認証情報の取り消し、削除、更新によって確立済みのオープン接続は終了されないため、推奨されません。
データベースインスタンスあたりの同時 WebSocket 接続数、および接続を開いたままにできる時間には制限があります。詳細については、「[WebSocket の制限](limits.md#limits-websockets)」を参照してください。
## IAM の使用はロールによって異なる
AWS Identity and Access Management (IAM) の使用方法は、Neptune で行う作業によって異なります。
**サービスユーザー** – ジョブを実行するために Neptune サービスを使用する場合、Neptune データプレーンの使用に必要な認証情報とアクセス許可が管理者から与えられます。作業を実行するために、より多くのアクセスが必要になるにつれて、アクセスの管理方法を理解しておくと、管理者に適切なアクセス許可をリクエストするうえで役立ちます。
**サービス管理者** — 社内の Neptune リソースを担当している場合は、おそらく [Neptune 管理 API](api.md) に対応する Neptune 管理アクションにアクセスできます。また、サービスユーザーが仕事をするために必要な Neptune データアクセスアクションとリソースを決定するのもあなたの仕事かもしれません。その場合、IAM 管理者は IAM ポリシーを適用して、サービスユーザーのアクセス許可を変更できます。
**IAM 管理者** — IAM 管理者は、IAM ポリシーを作成して、 Neptune の管理とデータアクセスの両方を管理する必要があります。使用できる Neptune アイデンティティベースのポリシーの例を表示するには、「[Neptune へのアクセスを制御するためのさまざまな種類の IAM ポリシーの使用](security-iam-access-manage.md#iam-auth-policy)」 を参照してください。
## アイデンティティを使用した認証
認証は、ID 認証情報 AWS を使用して にサインインする方法です。、IAM ユーザー AWS アカウントのルートユーザー、または IAM ロールを引き受けることで認証される必要があります。
AWS IAM アイデンティティセンター (IAM Identity Center)、シングルサインオン認証、Google/Facebook 認証情報などの ID ソースからの認証情報を使用して、フェデレーティッド ID としてサインインできます。サインインの詳細については、「*AWS サインイン ユーザーガイド*」の「[AWS アカウントにサインインする方法](https://docs.aws.amazon.com/signin/latest/userguide/how-to-sign-in.html)」を参照してください。
プログラムによるアクセスの場合、 は SDK と CLI AWS を提供してリクエストを暗号化して署名します。詳細については、「*IAM ユーザーガイド*」の「[API リクエストに対するAWS 署名バージョン 4](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_sigv.html)」を参照してください。
### AWS アカウント ルートユーザー
を作成するときは AWS アカウント、すべての AWS のサービス および リソースへの完全なアクセス権を持つ AWS アカウント *ルートユーザー*と呼ばれる 1 つのサインインアイデンティティから始めます。日常的なタスクには、ルートユーザーを使用しないことを強くお勧めします。ルートユーザー認証情報を必要とするタスクについては、「*IAM ユーザーガイド*」の「[ルートユーザー認証情報が必要なタスク](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_root-user.html#root-user-tasks)」を参照してください。
### IAM ユーザーとグループ
*[IAM ユーザー](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_users.html)*は、特定の個人やアプリケーションに対する特定のアクセス許可を持つアイデンティティです。長期認証情報を持つ IAM ユーザーの代わりに一時的な認証情報を使用することをお勧めします。詳細については、*IAM ユーザーガイド*の[「ID プロバイダーとのフェデレーションを使用して にアクセスすることを人間 AWS のユーザーに要求する](https://docs.aws.amazon.com/IAM/latest/UserGuide/best-practices.html#bp-users-federation-idp)」を参照してください。
[https://docs.aws.amazon.com/IAM/latest/UserGuide/id_groups.html](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_groups.html)は、IAM ユーザーの集合を指定し、大量のユーザーに対するアクセス許可の管理を容易にします。詳細については、「*IAM ユーザーガイド*」の「[IAM ユーザーに関するユースケース](https://docs.aws.amazon.com/IAM/latest/UserGuide/gs-identities-iam-users.html)」を参照してください。
### IAM ロール
*[IAM ロール](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles.html)*は、特定のアクセス許可を持つアイデンティであり、一時的な認証情報を提供します。ユーザー[から IAM ロール (コンソール) に切り替えるか、 または API オペレーションを呼び出すことで、ロール](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_use_switch-role-console.html)を引き受けることができます。 AWS CLI AWS 詳細については、「*IAM ユーザーガイド*」の「[ロールを引き受けるための各種方法](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_manage-assume.html)」を参照してください。
IAM ロールは、フェデレーションユーザーアクセス、一時的な IAM ユーザーのアクセス許可、クロスアカウントアクセス、クロスサービスアクセス、および Amazon EC2 で実行するアプリケーションに役立ちます。詳細については、*IAM ユーザーガイド* の [IAM でのクロスアカウントリソースアクセス](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies-cross-account-resource-access.html) を参照してください。
# Amazon Neptune で IAM データベース認証を有効にする
デフォルトでは、Amazon Neptune DB クラスターの作成時、IAM データベース認証は無効になっています。 AWS マネジメントコンソールを使用して、IAM データベース認証を有効にする (またはもう一度無効にする) ことができます
コンソールを使用して IAM 認証で新しい Neptune DB クラスターを作成するには、[を使用した Neptune DB クラスターの起動 AWS マネジメントコンソール](manage-console-launch-console.md) にある Neptune DB DB クラスターを作成するための手順に従う必要があります。
作成プロセスの 2 番目のページで、[**Enable IAM DB Authentication**] (IAM DB 認証を有効にする) に [**Yes**] (はい) を選択します。
**既存の DB インスタンスまたはクラスターに対して IAM 認証を有効または無効にするには**
1. AWS マネジメントコンソールにサインインし、[https://console.aws.amazon.com/neptune/home](https://console.aws.amazon.com/neptune/home) で Amazon Neptune コンソールを開きます。
1. ナビゲーションペインで **[Clusters]** (クラスター) を選択してください。
1. 変更する Neptune DB クラスターを選択し、**[Cluster actions]** (クラスタークラスターアクション) を選択します。その後、[**Modify Cluster**] を選択します。
1. **[Database options]** セクションの **[IAM DB Authentication]** で、**[Enable IAM DB authorization]** または **[No]** (無効にする場合) を選択します。[**Continue**] を選択します。
1. 変更をすぐに反映させるには、[**Apply immediately**] を選択します。
1. **[クラスターを変更]** を選択します。
# 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);
}
}
}
}
```
# IAM ポリシーを使用した Amazon Neptune データベースへのアクセスの管理
[IAM ポリシーは](https://docs.aws.amazon.com/kms/latest/developerguide/iam-policies.html)、アクションとリソースを使用するアクセス許可を定義する JSON オブジェクトです。
でアクセスを制御する AWS には、ポリシーを作成し、ID AWS またはリソースにアタッチします。ポリシーは、アイデンティティまたはリソースに関連付けられたときにアクセス許可を定義します。 は、プリンシパルがリクエストを行うときにこれらのポリシー AWS を評価します。ほとんどのポリシーは JSON ドキュメント AWS として に保存されます。JSON ポリシードキュメントの詳細については、「*IAM ユーザーガイド*」の「[JSON ポリシー概要](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies.html#access_policies-json)」を参照してください。
管理者は、ポリシーを使用して、どの**プリンシパル**がどの**リソース**に対して、どのような**条件**で**アクション**を実行できるかを定義することで、誰が何にアクセスできるかを指定します。
デフォルトでは、ユーザーやロールにアクセス許可はありません。IAM 管理者は IAM ポリシーを作成してロールに追加し、このロールをユーザーが引き受けられるようにします。IAM ポリシーは、オペレーションの実行方法を問わず、アクセス許可を定義します。
## アイデンティティベースのポリシー
アイデンティティベースのポリシーは、アイデンティティ (ユーザー、グループ、またはロール) にアタッチできる JSON アクセス許可ポリシードキュメントです。これらのポリシーは、アイデンティティがどのリソースに対してどのような条件下でどのようなアクションを実行できるかを制御します。アイデンティティベースポリシーの作成方法については、*IAM ユーザーガイド* の [カスタマー管理ポリシーでカスタム IAM アクセス許可を定義する](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_create.html) を参照してください。
アイデンティティベースのポリシーは、*インラインポリシー* (単一の ID に直接埋め込む) または*管理ポリシー* (複数の ID にアタッチされたスタンドアロンポリシー) にすることができます。管理ポリシーとインラインポリシーのいずれかを選択する方法については、「*IAM ユーザーガイド*」の「[管理ポリシーとインラインポリシーのいずれかを選択する](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies-choosing-managed-or-inline.html)」を参照してください。
## AWS 組織でのサービスコントロールポリシー (SCP) の使用
サービスコントロールポリシー (SCPs) は、 の組織または組織単位 (OU) の最大アクセス許可を指定する JSON ポリシー[AWS Organizations](https://aws.amazon.com/organizations/)です。 AWS Organizations は、ビジネスが所有する複数の AWS アカウントをグループ化して一元管理するためのサービスです。組織内のすべての機能を有効にすると、サービスコントロールポリシー (SCP) を一部またはすべてのアカウントに適用できます。SCP は、各アカウントのルートユーザーを含む、メンバー AWS アカウントのエンティティのアクセス許可を制限します。Organizations と SCPs[SCPs](https://docs.aws.amazon.com/organizations/latest/userguide/orgs_manage_policies_about-scps.html)」を参照してください。 AWS Organizations
Amazon Neptune を AWS 組織内の AWS アカウントにデプロイするお客様はSCPs を活用して、Neptune を使用できるアカウントを制御できます。メンバーアカウント内の Neptune へのアクセスを確保するには、次の点に注意してください。
+ Neptune データベースオペレーションの `rds:*` および `neptune-db:*` へのアクセスを許可します。Neptune データベースに対して Amazon RDS のアクセス許可が必要な理由の詳細については、「[Neptune データベースを使用するために Amazon RDS のアクセス許可とリソースが必要な理由](https://aws.amazon.com/neptune/faqs/)」を参照してください。
+ Neptune Analytics オペレーションの `neptune-graph:*` へのアクセスを許可します。
## Amazon Neptune コンソールを使用するために必要なアクセス許可
Amazon Neptune コンソールを使用するユーザーには、最小限のアクセス権限のセットが必要です。これらのアクセス許可により、ユーザーは AWS アカウントの Neptune リソースを記述し、Amazon EC2 セキュリティやネットワーク情報など、その他の関連情報を提供できます。
これらの最小限必要なアクセス許可よりも制限された IAM ポリシーを作成している場合、その IAM ポリシーを使用するユーザーに対してコンソールは意図したとおりには機能しません。それらのユーザーが Neptune コンソールを引き続き使用するためには、`NeptuneReadOnlyAccess` で説明しているように、[AWS マネージドポリシーを使用した Amazon Neptune データベースへのアクセス](security-iam-access-managed-policies.md) 管理ポリシーをユーザーにもアタッチします。
AWS CLI または Amazon Neptune API のみを呼び出すユーザーには、最小限のコンソールアクセス許可を付与する必要はありません。
## IAM ポリシーを IAM ユーザーにアタッチする
管理ポリシーまたはカスタムポリシーを適用するには、IAM ユーザーにアタッチします。このトピックに関するチュートリアルについては、*IAM ユーザーガイド*の[はじめてのカスタマー管理ポリシーの作成とアタッチ](https://docs.aws.amazon.com/IAM/latest/UserGuide/tutorial_managed-policies.html)を参照してください。
チュートリアルを進める際に、このセクションに記載されているいずれかのポリシー例をスタート点として使用し、ニーズに合わせて調整することができます。チュートリアルを完了すると、`neptune-db:*` アクションの使用を許可するポリシーが IAM ユーザーにアタッチされます。
**重要**
IAM ポリシーへの変更は、指定された Neptune リソースへの適用に最大で 10 分かかります。
Neptune DB クラスターに適用された IAM ポリシーは、そのクラスター内のすべてのインスタンスに適用されます。
## Neptune へのアクセスを制御するためのさまざまな種類の IAM ポリシーの使用
Neptune の管理アクションまたは Neptune DB クラスター内のデータへのアクセスを提供するには、IAM ユーザーまたはロールにポリシーをアタッチします。IAM ポリシーをユーザーにアタッチする方法については、「[IAM ポリシーを IAM ユーザーにアタッチする](#iam-auth-policy-attaching)」を参照してください。ロールにポリシーをアタッチする方法については、[IAM ポリシーの追加と削除](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_manage-attach-detach.html)の*IAM ユーザーガイド*を参照してください。
Neptune への一般的なアクセスには、Neptune の[管理ポリシー](security-iam-access-managed-policies.md)のいずれかを使用できます。アクセスをさらに制限したい場合は、Neptune がサポートする[管理アクション](neptune-iam-admin-actions.md)と[リソース](iam-admin-resources.md)を使用して独自のカスタムポリシーを作成できます。
カスタム IAM ポリシーでは、Neptune DB クラスターへのさまざまなアクセスモードを制御する 2 種類のポリシーステートメントを使用できます。
+ [管理ポリシーステートメント](iam-admin-policies.md) — 管理ポリシーステートメントは、DB クラスターとそのインスタンスの作成、設定、管理に使用する [Neptune 管理 API](api.md) へのアクセスを提供します。
Neptune は Amazon RDS と機能を共有しているため、Neptune ポリシーの管理アクション、リソース、および条件キーは設計により `rds:` プレフィックスを使用します。
+ [データアクセスポリシーステートメント](iam-data-access-policies.md) — データアクセスポリシーステートメントは、[データアクセスアクション](iam-dp-actions.md)、[リソース](iam-data-resources.md)、および[条件キー](iam-data-condition-keys.md#iam-neptune-condition-keys)を使用して、DB クラスターに含まれるデータへのアクセスを制御します。
Neptune データアクセスアクション、リソース、および条件キーは、`neptune-db:` プレフィックスを使用します。
## Amazon Neptune での IAM 条件コンテキストキーの使用
Neptune へのアクセスを制御する IAM ポリシーステートメントで条件を指定できます。ポリシーステートメントは、条件が true の場合にのみ有効です。
例えば、特定の日付の後にのみ適用されるポリシーステートメントや、リクエストに特定の値が存在する場合のみアクセスが許可されるポリシーステートメントが必要になる場合があります。
条件を表すには、「等しい」や「より小さい」などの [IAM 条件ポリシー演算子](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_elements_condition_operators.html) とともに、ポリシーステートメントの [https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_elements_condition.html](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_elements_condition.html) 要素であらかじめ定義された条件キーを使用します。
1 つのステートメントに複数の `Condition` 要素を指定する場合、または 1 つの `Condition` 要素に複数のキーを指定する場合、 AWS では `AND` 論理演算子を使用してそれらを評価します。1 つの条件キーに複数の値を指定すると、 は論理`OR`オペレーションを使用して条件 AWS を評価します。ステートメントの権限が付与される前にすべての条件が満たされる必要があります。
条件を指定する際にプレースホルダー変数も使用できます。例えば IAM ユーザーに、IAM ユーザー名がタグ付けされている場合のみリソースにアクセスできる権限を付与することができます。詳細については、*「IAM ユーザーガイド」*の[「IAM Policy Elements: Variables and Tags」](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_variables.html)(IAM ポリシーの要素: 変数およびタグ) を参照してください。
条件キーのデータ型によって、リクエスト内の値とポリシーステートメント内の値の比較に使用できる条件演算子が決まります。そのデータ型と互換性のない条件演算子を使用した場合、条件は一致しないため、ポリシーステートメントは適用されません。
Neptune は、管理ポリシーステートメントについて、データアクセスポリシーステートメントとは異なる条件キーのセットをサポートしています。
+ [管理ポリシーステートメントの条件キー](iam-admin-condition-keys.md)
+ [データアクセスポリシーステートメントの条件キー](iam-data-condition-keys.md#iam-neptune-condition-keys)
## Amazon Neptune での IAM ポリシーとアクセスコントロール機能のサポート
次の表は、Neptune が管理ポリシーステートメントとデータアクセスポリシーステートメントについてサポートする IAM 機能を示しています。
**Neptune で使用できる IAM 機能**
| IAM 機能 | 管理 | データアクセス |
| --- | --- | --- |
| [アイデンティティベースのポリシー](#security_iam_access-manage-id-based-policies) | はい | はい |
| [リソースベースのポリシー](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_identity-vs-resource.html) | いいえ | いいえ |
| [ポリシーアクション](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_elements_action.html) | はい | はい |
| [ポリシーリソース](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_elements_resource.html) | はい | はい |
| [グローバル条件キー](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_condition-keys.html) | はい | (サブセット) |
| [タグベースの条件キー](iam-admin-condition-keys.md#iam-rds-tag-based-condition-keys) | はい | なし |
| [アクセスコントロールリスト (ACL) ](https://docs.aws.amazon.com/AmazonS3/latest/userguide/acls.html) | いいえ | いいえ |
| [サービスコントロールポリシー (SCP)](#security_iam_access-manage-scp) | はい | はい |
| [サービスリンクロール](security-iam-service-linked-roles.md) | はい | なし |
## IAM ポリシーの制限
IAM ポリシーへの変更は、指定された Neptune リソースへの適用に最大で 10 分かかります。
Neptune DB クラスターに適用された IAM ポリシーは、そのクラスター内のすべてのインスタンスに適用されます。
Neptune は現在、データプレーンレベルでのクロスアカウントアクセスコントロールをサポートしていません。クロスアカウントアクセスコントロールは、一括ロード時とロールチェーンの使用時にのみサポートされます。詳細については、「[一括ロードのチュートリアル](https://docs.aws.amazon.com//neptune/latest/userguide/bulk-load-tutorial-chain-roles.html#bulk-load-tutorial-chain-cross-account)」を参照してください。
# AWS マネージドポリシーを使用した Amazon Neptune データベースへのアクセス
AWS は、 によって作成および管理されるスタンドアロン IAM ポリシーを提供することで、多くの一般的なユースケースに対処します AWS。マネージドポリシーは、一般的ユースケースに必要な許可を付与することで、どの許可が必要なのかをユーザーが調査する必要をなくすることができます。詳細については、「*IAM ユーザーガイド*」の「[AWS マネージドポリシー](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_managed-vs-inline.html#aws-managed-policies)」を参照してください。
アカウントのユーザーにアタッチできる以下の AWS 管理ポリシーは、Amazon Neptune 管理 APIsを使用するためのものです。
+ **[NeptuneReadOnlyAccess](read-only-access-iam-managed-policy.md)** — ルート AWS アカウントの管理目的とデータアクセス目的の両方で、すべての Neptune リソースへの読み取り専用アクセスを許可します。
+ **[NeptuneFullAccess](full-access-iam-managed-policy.md)** — ルート AWS アカウントの管理目的とデータアクセス目的の両方で、すべての Neptune リソースへのフルアクセスを許可します。これは、 AWS CLI または SDK からの完全な Neptune アクセスが必要な場合に推奨されますが、 AWS マネジメントコンソール アクセスには推奨されません。
+ **[NeptuneConsoleFullAccess](console-full-access-iam-managed-policy.md)** — ルート AWS アカウントのフルアクセスを、すべての Neptune 管理アクションとリソースに許可しますが、データアクセスアクションやリソースには許可しません。これには、IAM と Amazon EC2 (VPC) の制限されたアクセス許可を含め、コンソールからの Neptune アクセスを簡素化する追加のアクセス許可も含まれます。
+ **[NeptuneGraphReadOnlyAccess](graph-read-only-access-iam-managed-policy.md)** — Amazon Neptune Analytics のすべてのリソースへの読み取り専用アクセスと、依存サービスの読み取り専用アクセス許可を付与します。
+ **[AWSServiceRoleForNeptuneGraphPolicy](aws-service-role-for-neptune-graph-policy.md)** — Neptune Analytics グラフで CloudWatch の運用と使用状況のメトリクスとログを公開できるようにします。
Neptune は特定の管理機能のために Amazon RDS とオペレーション技術を共有するため、Neptune IAM のロールおよびポリシーで Amazon RDS リソースへのアクセスを許可します。これには管理 API アクセス許可が含まれるため、Neptune 管理アクションには `rds:` プレフィックスが付いています。
## Neptune AWS 管理ポリシーの更新
次の表は、Neptune がこれらの変更の追跡を開始した時点以降の Neptune 管理ポリシーの更新状況を示しています。
| ポリシー | 説明 | 日付 |
| --- | --- | --- |
| AWS Amazon Neptune の マネージドポリシー - 既存のポリシーの更新 | `NeptuneReadOnlyAcess` および`NeptuneFullAccess` のマネージドポリシーには、`Sid` (ステートメント ID) がポリシーステートメントの識別子として配置されるようになりました。 | 2024-01-22 |
| [NeptuneGraphReadOnlyAccess](read-only-access-iam-managed-policy.md) (リリース済み) | Neptune Analytics のグラフとリソースへの読み取り専用アクセスを提供するためにリリースされました。 | 2023-11-29 |
| [AWSServiceRoleForNeptuneGraphPolicy](aws-service-role-for-neptune-graph-policy.md) (リリース済み) | Neptune Analytics のグラフから CloudWatch にアクセスして、運用および使用状況のメトリクスとログを公開できるようにするためにリリースされました。「[Neptune Analytics でのサービスリンクロール (SLR) の使用](https://docs.aws.amazon.com/neptune-analytics/latest/userguide/nan-service-linked-roles.html)」を参照してください。 | 2023-11-29 |
| [NeptuneConsoleFullAccess](console-full-access-iam-managed-policy.md) (追加されたアクセス許可) | Neptune Analytics グラフを操作するために必要なすべてのアクセス権を付与するアクセス許可を追加しました。 | 2023 年 11 月 29 日 |
| [NeptuneFullAccess](full-access-iam-managed-policy.md) (追加されたアクセス許可) | データアクセス用のアクセス許可と新しいグローバルデータベース API 用のアクセス許可を追加しました。 | 2022-07-28 |
| [NeptuneConsoleFullAccess](console-full-access-iam-managed-policy.md) (追加されたアクセス許可) | 新しいグローバルデータベース API のアクセス許可を追加しました。 | 2022-07-21 |
| Neptune は変更の追跡を開始しました | Neptune は、 AWS 管理ポリシーの変更の追跡を開始しました。 | 2022-07-21 |
# AWS マネージドポリシーを使用した Amazon Neptune データベース`NeptuneReadOnlyAccess`への の付与
下記の [NeptuneReadOnlyAccess](https://console.aws.amazon.com/iam/home#policies/NeptuneReadOnlyAccess) 管理ポリシーは、管理目的とデータアクセス目的の両方で、すべての Neptune アクションおよびリソースへの読み取り専用アクセスを付与します。
**注記**
このポリシーは 2022 年 7 月 21 日に更新され、読み取り専用のデータアクセスアクセス許可と読み取り専用の管理アクセス許可、およびグローバルデータベースアクションのアクセス許可が含まれるようになりました。
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Sid": "AllowReadOnlyPermissionsForRDS",
"Effect": "Allow",
"Action": [
"rds:DescribeAccountAttributes",
"rds:DescribeCertificates",
"rds:DescribeDBClusterParameterGroups",
"rds:DescribeDBClusterParameters",
"rds:DescribeDBClusterSnapshotAttributes",
"rds:DescribeDBClusterSnapshots",
"rds:DescribeDBClusters",
"rds:DescribeDBEngineVersions",
"rds:DescribeDBInstances",
"rds:DescribeDBLogFiles",
"rds:DescribeDBParameterGroups",
"rds:DescribeDBParameters",
"rds:DescribeDBSubnetGroups",
"rds:DescribeEventCategories",
"rds:DescribeEventSubscriptions",
"rds:DescribeEvents",
"rds:DescribeGlobalClusters",
"rds:DescribeOrderableDBInstanceOptions",
"rds:DescribePendingMaintenanceActions",
"rds:DownloadDBLogFilePortion",
"rds:ListTagsForResource"
],
"Resource": "*"
},
{
"Sid": "AllowReadOnlyPermissionsForCloudwatch",
"Effect": "Allow",
"Action": [
"cloudwatch:GetMetricStatistics",
"cloudwatch:ListMetrics"
],
"Resource": "*"
},
{
"Sid": "AllowReadOnlyPermissionsForEC2",
"Effect": "Allow",
"Action": [
"ec2:DescribeAccountAttributes",
"ec2:DescribeAvailabilityZones",
"ec2:DescribeInternetGateways",
"ec2:DescribeSecurityGroups",
"ec2:DescribeSubnets",
"ec2:DescribeVpcAttribute",
"ec2:DescribeVpcs"
],
"Resource": "*"
},
{
"Sid": "AllowReadOnlyPermissionsForKMS",
"Effect": "Allow",
"Action": [
"kms:ListKeys",
"kms:ListRetirableGrants",
"kms:ListAliases",
"kms:ListKeyPolicies"
],
"Resource": "*"
},
{
"Sid": "AllowReadOnlyPermissionsForLogs",
"Effect": "Allow",
"Action": [
"logs:DescribeLogStreams",
"logs:GetLogEvents"
],
"Resource": [
"arn:aws:logs:*:*:log-group:/aws/rds/*:log-stream:*",
"arn:aws:logs:*:*:log-group:/aws/neptune/*:log-stream:*"
]
},
{
"Sid": "AllowReadOnlyPermissionsForNeptuneDB",
"Effect": "Allow",
"Action": [
"neptune-db:Read*",
"neptune-db:Get*",
"neptune-db:List*"
],
"Resource": [
"*"
]
}
]
}
```
------
# AWS マネージドポリシーを使用した Amazon Neptune データベース`NeptuneFullAccess`への の付与
下記の [NeptuneFullAccess](https://console.aws.amazon.com/iam/home#policies/NeptuneFullAccess) 管理ポリシーは、管理目的とデータアクセス目的の両方で、すべての Neptune アクションおよびリソースへのフルアクセスを付与します。 AWS CLI または SDK からのフルアクセスが必要な場合は推奨されますが、 からのフルアクセスは推奨されません AWS マネジメントコンソール。
**注記**
このポリシーは 2022 年 7 月 21 日に更新され、フルデータアクセスアクセス許可とフル管理アクセス許可、およびグローバルデータベースアクションのアクセス許可が含まれるようになりました。
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Sid": "AllowNeptuneCreate",
"Effect": "Allow",
"Action": [
"rds:CreateDBCluster",
"rds:CreateDBInstance"
],
"Resource": [
"arn:aws:rds:*:*:*"
],
"Condition": {
"StringEquals": {
"rds:DatabaseEngine": [
"graphdb",
"neptune"
]
}
}
},
{
"Sid": "AllowManagementPermissionsForRDS",
"Effect": "Allow",
"Action": [
"rds:AddRoleToDBCluster",
"rds:AddSourceIdentifierToSubscription",
"rds:AddTagsToResource",
"rds:ApplyPendingMaintenanceAction",
"rds:CopyDBClusterParameterGroup",
"rds:CopyDBClusterSnapshot",
"rds:CopyDBParameterGroup",
"rds:CreateDBClusterEndpoint",
"rds:CreateDBClusterParameterGroup",
"rds:CreateDBClusterSnapshot",
"rds:CreateDBParameterGroup",
"rds:CreateDBSubnetGroup",
"rds:CreateEventSubscription",
"rds:CreateGlobalCluster",
"rds:DeleteDBCluster",
"rds:DeleteDBClusterEndpoint",
"rds:DeleteDBClusterParameterGroup",
"rds:DeleteDBClusterSnapshot",
"rds:DeleteDBInstance",
"rds:DeleteDBParameterGroup",
"rds:DeleteDBSubnetGroup",
"rds:DeleteEventSubscription",
"rds:DeleteGlobalCluster",
"rds:DescribeDBClusterEndpoints",
"rds:DescribeAccountAttributes",
"rds:DescribeCertificates",
"rds:DescribeDBClusterParameterGroups",
"rds:DescribeDBClusterParameters",
"rds:DescribeDBClusterSnapshotAttributes",
"rds:DescribeDBClusterSnapshots",
"rds:DescribeDBClusters",
"rds:DescribeDBEngineVersions",
"rds:DescribeDBInstances",
"rds:DescribeDBLogFiles",
"rds:DescribeDBParameterGroups",
"rds:DescribeDBParameters",
"rds:DescribeDBSecurityGroups",
"rds:DescribeDBSubnetGroups",
"rds:DescribeEngineDefaultClusterParameters",
"rds:DescribeEngineDefaultParameters",
"rds:DescribeEventCategories",
"rds:DescribeEventSubscriptions",
"rds:DescribeEvents",
"rds:DescribeGlobalClusters",
"rds:DescribeOptionGroups",
"rds:DescribeOrderableDBInstanceOptions",
"rds:DescribePendingMaintenanceActions",
"rds:DescribeValidDBInstanceModifications",
"rds:DownloadDBLogFilePortion",
"rds:FailoverDBCluster",
"rds:FailoverGlobalCluster",
"rds:ListTagsForResource",
"rds:ModifyDBCluster",
"rds:ModifyDBClusterEndpoint",
"rds:ModifyDBClusterParameterGroup",
"rds:ModifyDBClusterSnapshotAttribute",
"rds:ModifyDBInstance",
"rds:ModifyDBParameterGroup",
"rds:ModifyDBSubnetGroup",
"rds:ModifyEventSubscription",
"rds:ModifyGlobalCluster",
"rds:PromoteReadReplicaDBCluster",
"rds:RebootDBInstance",
"rds:RemoveFromGlobalCluster",
"rds:RemoveRoleFromDBCluster",
"rds:RemoveSourceIdentifierFromSubscription",
"rds:RemoveTagsFromResource",
"rds:ResetDBClusterParameterGroup",
"rds:ResetDBParameterGroup",
"rds:RestoreDBClusterFromSnapshot",
"rds:RestoreDBClusterToPointInTime",
"rds:StartDBCluster",
"rds:StopDBCluster"
],
"Resource": [
"*"
]
},
{
"Sid": "AllowOtherDepedentPermissions",
"Effect": "Allow",
"Action": [
"cloudwatch:GetMetricStatistics",
"cloudwatch:ListMetrics",
"ec2:DescribeAccountAttributes",
"ec2:DescribeAvailabilityZones",
"ec2:DescribeSecurityGroups",
"ec2:DescribeSubnets",
"ec2:DescribeVpcAttribute",
"ec2:DescribeVpcs",
"kms:ListAliases",
"kms:ListKeyPolicies",
"kms:ListKeys",
"kms:ListRetirableGrants",
"logs:DescribeLogStreams",
"logs:GetLogEvents",
"sns:ListSubscriptions",
"sns:ListTopics",
"sns:Publish"
],
"Resource": [
"*"
]
},
{
"Sid": "AllowPassRoleForNeptune",
"Effect": "Allow",
"Action": "iam:PassRole",
"Resource": "*",
"Condition": {
"StringEquals": {
"iam:passedToService": "rds.amazonaws.com"
}
}
},
{
"Sid": "AllowCreateSLRForNeptune",
"Effect": "Allow",
"Action": "iam:CreateServiceLinkedRole",
"Resource": "arn:aws:iam::*:role/aws-service-role/rds.amazonaws.com/AWSServiceRoleForRDS",
"Condition": {
"StringLike": {
"iam:AWSServiceName": "rds.amazonaws.com"
}
}
},
{
"Sid": "AllowDataAccessForNeptune",
"Effect": "Allow",
"Action": [
"neptune-db:*"
],
"Resource": [
"*"
]
}
]
}
```
------
# AWS 管理ポリシー`NeptuneConsoleFullAccess`を使用した の付与
下記の [NeptuneConsoleFullAccess](https://console.aws.amazon.com/iam/home#policies/NeptuneConsoleFullAccess) 管理ポリシーは、管理目的では、すべての Neptune アクションおよびリソースへのフルアクセスを付与しますが、データアクセス目的では付与しません。これには、IAM と Amazon EC2 (VPC) の制限されたアクセス許可を含め、コンソールからの Neptune アクセスを簡素化する追加のアクセス許可も含まれます。
**注記**
このポリシーは 2023 年 11 月 29 日に更新され、Neptune Analytics グラフを操作するために必要なアクセス許可が含まれるようになりました。
このポリシーは 2022 年 7 月 21 日に更新され、グローバルデータベースアクションのアクセス許可が含まれるようになりました。
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Sid": "AllowNeptuneCreate",
"Effect": "Allow",
"Action": [
"rds:CreateDBCluster",
"rds:CreateDBInstance"
],
"Resource": [
"arn:aws:rds:*:*:*"
],
"Condition": {
"StringEquals": {
"rds:DatabaseEngine": [
"graphdb",
"neptune"
]
}
}
},
{
"Sid": "AllowManagementPermissionsForRDS",
"Action": [
"rds:AddRoleToDBCluster",
"rds:AddSourceIdentifierToSubscription",
"rds:AddTagsToResource",
"rds:ApplyPendingMaintenanceAction",
"rds:CopyDBClusterParameterGroup",
"rds:CopyDBClusterSnapshot",
"rds:CopyDBParameterGroup",
"rds:CreateDBClusterParameterGroup",
"rds:CreateDBClusterSnapshot",
"rds:CreateDBParameterGroup",
"rds:CreateDBSubnetGroup",
"rds:CreateEventSubscription",
"rds:DeleteDBCluster",
"rds:DeleteDBClusterParameterGroup",
"rds:DeleteDBClusterSnapshot",
"rds:DeleteDBInstance",
"rds:DeleteDBParameterGroup",
"rds:DeleteDBSubnetGroup",
"rds:DeleteEventSubscription",
"rds:DescribeAccountAttributes",
"rds:DescribeCertificates",
"rds:DescribeDBClusterParameterGroups",
"rds:DescribeDBClusterParameters",
"rds:DescribeDBClusterSnapshotAttributes",
"rds:DescribeDBClusterSnapshots",
"rds:DescribeDBClusters",
"rds:DescribeDBEngineVersions",
"rds:DescribeDBInstances",
"rds:DescribeDBLogFiles",
"rds:DescribeDBParameterGroups",
"rds:DescribeDBParameters",
"rds:DescribeDBSecurityGroups",
"rds:DescribeDBSubnetGroups",
"rds:DescribeEngineDefaultClusterParameters",
"rds:DescribeEngineDefaultParameters",
"rds:DescribeEventCategories",
"rds:DescribeEventSubscriptions",
"rds:DescribeEvents",
"rds:DescribeOptionGroups",
"rds:DescribeOrderableDBInstanceOptions",
"rds:DescribePendingMaintenanceActions",
"rds:DescribeValidDBInstanceModifications",
"rds:DownloadDBLogFilePortion",
"rds:FailoverDBCluster",
"rds:ListTagsForResource",
"rds:ModifyDBCluster",
"rds:ModifyDBClusterParameterGroup",
"rds:ModifyDBClusterSnapshotAttribute",
"rds:ModifyDBInstance",
"rds:ModifyDBParameterGroup",
"rds:ModifyDBSubnetGroup",
"rds:ModifyEventSubscription",
"rds:PromoteReadReplicaDBCluster",
"rds:RebootDBInstance",
"rds:RemoveRoleFromDBCluster",
"rds:RemoveSourceIdentifierFromSubscription",
"rds:RemoveTagsFromResource",
"rds:ResetDBClusterParameterGroup",
"rds:ResetDBParameterGroup",
"rds:RestoreDBClusterFromSnapshot",
"rds:RestoreDBClusterToPointInTime"
],
"Effect": "Allow",
"Resource": [
"*"
]
},
{
"Sid": "AllowOtherDepedentPermissions",
"Action": [
"cloudwatch:GetMetricStatistics",
"cloudwatch:ListMetrics",
"ec2:AllocateAddress",
"ec2:AssignIpv6Addresses",
"ec2:AssignPrivateIpAddresses",
"ec2:AssociateAddress",
"ec2:AssociateRouteTable",
"ec2:AssociateSubnetCidrBlock",
"ec2:AssociateVpcCidrBlock",
"ec2:AttachInternetGateway",
"ec2:AttachNetworkInterface",
"ec2:CreateCustomerGateway",
"ec2:CreateDefaultSubnet",
"ec2:CreateDefaultVpc",
"ec2:CreateInternetGateway",
"ec2:CreateNatGateway",
"ec2:CreateNetworkInterface",
"ec2:CreateRoute",
"ec2:CreateRouteTable",
"ec2:CreateSecurityGroup",
"ec2:CreateSubnet",
"ec2:CreateVpc",
"ec2:CreateVpcEndpoint",
"ec2:CreateVpcEndpoint",
"ec2:DescribeAccountAttributes",
"ec2:DescribeAccountAttributes",
"ec2:DescribeAddresses",
"ec2:DescribeAvailabilityZones",
"ec2:DescribeAvailabilityZones",
"ec2:DescribeCustomerGateways",
"ec2:DescribeInstances",
"ec2:DescribeNatGateways",
"ec2:DescribeNetworkInterfaces",
"ec2:DescribePrefixLists",
"ec2:DescribeRouteTables",
"ec2:DescribeSecurityGroupReferences",
"ec2:DescribeSecurityGroups",
"ec2:DescribeSecurityGroups",
"ec2:DescribeSubnets",
"ec2:DescribeSubnets",
"ec2:DescribeVpcAttribute",
"ec2:DescribeVpcAttribute",
"ec2:DescribeVpcEndpoints",
"ec2:DescribeVpcs",
"ec2:DescribeVpcs",
"ec2:ModifyNetworkInterfaceAttribute",
"ec2:ModifySubnetAttribute",
"ec2:ModifyVpcAttribute",
"ec2:ModifyVpcEndpoint",
"iam:ListRoles",
"kms:ListAliases",
"kms:ListKeyPolicies",
"kms:ListKeys",
"kms:ListRetirableGrants",
"logs:DescribeLogStreams",
"logs:GetLogEvents",
"sns:ListSubscriptions",
"sns:ListTopics",
"sns:Publish"
],
"Effect": "Allow",
"Resource": [
"*"
]
},
{
"Sid": "AllowPassRoleForNeptune",
"Action": "iam:PassRole",
"Effect": "Allow",
"Resource": "*",
"Condition": {
"StringEquals": {
"iam:passedToService": "rds.amazonaws.com"
}
}
},
{
"Sid": "AllowCreateSLRForNeptune",
"Action": "iam:CreateServiceLinkedRole",
"Effect": "Allow",
"Resource": "arn:aws:iam::*:role/aws-service-role/rds.amazonaws.com/AWSServiceRoleForRDS",
"Condition": {
"StringLike": {
"iam:AWSServiceName": "rds.amazonaws.com"
}
}
},
{
"Sid": "AllowManagementPermissionsForNeptuneAnalytics",
"Effect": "Allow",
"Action": [
"neptune-graph:CreateGraph",
"neptune-graph:DeleteGraph",
"neptune-graph:GetGraph",
"neptune-graph:ListGraphs",
"neptune-graph:UpdateGraph",
"neptune-graph:ResetGraph",
"neptune-graph:CreateGraphSnapshot",
"neptune-graph:DeleteGraphSnapshot",
"neptune-graph:GetGraphSnapshot",
"neptune-graph:ListGraphSnapshots",
"neptune-graph:RestoreGraphFromSnapshot",
"neptune-graph:CreatePrivateGraphEndpoint",
"neptune-graph:GetPrivateGraphEndpoint",
"neptune-graph:ListPrivateGraphEndpoints",
"neptune-graph:DeletePrivateGraphEndpoint",
"neptune-graph:CreateGraphUsingImportTask",
"neptune-graph:GetImportTask",
"neptune-graph:ListImportTasks",
"neptune-graph:CancelImportTask"
],
"Resource": [
"arn:aws:neptune-graph:*:*:*"
]
},
{
"Sid": "AllowPassRoleForNeptuneAnalytics",
"Effect": "Allow",
"Action": "iam:PassRole",
"Resource": "*",
"Condition": {
"StringEquals": {
"iam:passedToService": "neptune-graph.amazonaws.com"
}
}
},
{
"Sid": "AllowCreateSLRForNeptuneAnalytics",
"Effect": "Allow",
"Action": "iam:CreateServiceLinkedRole",
"Resource": "arn:aws:iam::*:role/aws-service-role/neptune-graph.amazonaws.com/AWSServiceRoleForNeptuneGraph",
"Condition": {
"StringLike": {
"iam:AWSServiceName": "neptune-graph.amazonaws.com"
}
}
}
]
}
```
------
# AWS 管理ポリシー`NeptuneGraphReadOnlyAccess`を使用した の付与
次の [NeptuneGraphReadOnlyAccess](https://console.aws.amazon.com/iam/home#policies/NeptuneGraphReadOnlyAccess) マネージドポリシーは、Amazon Neptune Analytics のすべてのリソースへの読み取り専用アクセスと、依存サービスの読み取り専用アクセス許可を付与します。
このポリシーには以下を実行するための許可が含まれます。
+ **Amazon EC2 の場合** — VPC、サブネット、セキュリティグループ、アベイラビリティーゾーンに関する情報を取得します。
+ **対象 AWS KMS** — KMS キーとエイリアスに関する情報を取得します。
+ **CloudWatch の場合** — CloudWatch メトリクスに関する情報を取得します。
+ **CloudWatch Logs の場合** — CloudWatch のログストリームとイベントに関する情報を取得します。
**注記**
このポリシーは 2023 年 11 月 29 日にリリースされました。
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Sid": "AllowReadOnlyPermissionsForNeptuneGraph",
"Effect": "Allow",
"Action": [
"neptune-graph:Get*",
"neptune-graph:List*",
"neptune-graph:Read*"
],
"Resource": "*"
},
{
"Sid": "AllowReadOnlyPermissionsForEC2",
"Effect": "Allow",
"Action": [
"ec2:DescribeVpcEndpoints",
"ec2:DescribeVpcAttribute",
"ec2:DescribeSecurityGroups",
"ec2:DescribeSubnets",
"ec2:DescribeVpcs",
"ec2:DescribeAvailabilityZones"
],
"Resource": "*"
},
{
"Sid": "AllowReadOnlyPermissionsForKMS",
"Effect": "Allow",
"Action": [
"kms:ListKeys",
"kms:ListAliases"
],
"Resource": "*"
},
{
"Sid": "AllowReadOnlyPermissionsForCloudwatch",
"Effect": "Allow",
"Action": [
"cloudwatch:GetMetricData",
"cloudwatch:ListMetrics",
"cloudwatch:GetMetricStatistics"
],
"Resource": "*"
},
{
"Sid": "AllowReadOnlyPermissionsForLogs",
"Effect": "Allow",
"Action": [
"logs:DescribeLogStreams",
"logs:GetLogEvents"
],
"Resource": [
"arn:aws:logs:*:*:log-group:/aws/neptune/*:log-stream:*"
]
}
]
}
```
------
# `AWSServiceRoleForNeptuneGraphPolicy` を使用することによる Neptune グラフへのアクセス権の付与
次の [AWSServiceRoleForNeptuneGraphPolicy](https://console.aws.amazon.com/iam/home#policies/AWSServiceRoleForNeptuneGraphPolicy) マネージドポリシーは、CloudWatch にアクセスして運用および使用状況のメトリクスとログを公開することをグラフに許可します。「[nan-service-linked-roles](https://docs.aws.amazon.com/neptune-analytics/latest/userguide/nan-service-linked-roles.html)」を参照してください。
**注記**
このポリシーは 2023 年 11 月 29 日にリリースされました。
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Sid": "GraphMetrics",
"Effect": "Allow",
"Action": [
"cloudwatch:PutMetricData"
],
"Resource": "*",
"Condition": {
"StringEquals": {
"cloudwatch:namespace": [
"AWS/Neptune",
"AWS/Usage"
]
}
}
},
{
"Sid": "GraphLogGroup",
"Effect": "Allow",
"Action": [
"logs:CreateLogGroup"
],
"Resource": [
"arn:aws:logs:*:*:log-group:/aws/neptune/*"
],
"Condition": {
"StringEquals": {
"aws:ResourceAccount": "${aws:PrincipalAccount}"
}
}
},
{
"Sid": "GraphLogEvents",
"Effect": "Allow",
"Action": [
"logs:CreateLogStream",
"logs:PutLogEvents",
"logs:DescribeLogStreams"
],
"Resource": [
"arn:aws:logs:*:*:log-group:/aws/neptune/*:log-stream:*"
],
"Condition": {
"StringEquals": {
"aws:ResourceAccount": "${aws:PrincipalAccount}"
}
}
}
]
}
```
------
# IAM 条件コンテキストキーを使用することによる Amazon Neptune リソースへのアクセス権のカスタマイズ
Neptune 管理アクションおよびリソースへのアクセスを制御する条件を IAM ポリシーで指定できます。ポリシーステートメントは、条件が true の場合にのみ有効です。
例えば、特定の日付の後にのみ適用されるポリシーステートメントや、API リクエストに特定の値が存在する場合のみアクセスが許可されるポリシーステートメントが必要になる場合があります。
条件を表すには、「等しい」や「より小さい」などの [IAM 条件ポリシー演算子](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_elements_condition_operators.html) とともに、ポリシーステートメントの [https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_elements_condition.html](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_elements_condition.html) 要素であらかじめ定義された条件キーを使用します。
1 つのステートメントに複数の `Condition` 要素を指定する場合、または 1 つの `Condition` 要素に複数のキーを指定する場合、 AWS では `AND` 論理演算子を使用してそれらを評価します。1 つの条件キーに複数の値を指定すると、 は論理`OR`オペレーションを使用して条件 AWS を評価します。ステートメントの権限が付与される前にすべての条件が満たされる必要があります。
条件を指定する際にプレースホルダー変数も使用できます。例えば IAM ユーザーに、IAM ユーザー名がタグ付けされている場合のみリソースにアクセスできる権限を付与することができます。詳細については、*「IAM ユーザーガイド」*の[「IAM Policy Elements: Variables and Tags」](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_variables.html)(IAM ポリシーの要素: 変数およびタグ) を参照してください。
条件キーのデータ型によって、リクエスト内の値とポリシーステートメント内の値の比較に使用できる条件演算子が決まります。そのデータ型と互換性のない条件演算子を使用した場合、条件は一致しないため、ポリシーステートメントは適用されません。
**Neptune 管理ポリシーステートメントの IAM 条件キー**
+ [グローバル条件キー](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_condition-keys.html) – Neptune 管理ポリシーステートメントでは、ほとんどの AWS グローバル条件キーを使用できます。
+ [サービス固有の条件キー](iam-admin-condition-keys.md) – 特定の AWS サービス用に定義されたキーです。Neptune が管理ポリシーステートメントでサポートしているものは、[Amazon Neptune を管理するための IAM 条件キー](iam-admin-condition-keys.md) に記載されています。
**データアクセスポリシーステートメントの IAM 条件キー**
+ [グローバル条件キー](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_condition-keys.html) — Neptune がデータアクセスポリシーステートメントでサポートするこれらのキーのサブセットは、[AWS データアクセスポリシーステートメントで Neptune がサポートするグローバル条件コンテキストキー](iam-data-condition-keys.md#iam-data-global-condition-keys) に記載されています。
+ Neptune がデータアクセスポリシーステートメント用に定義するサービス固有の条件キーは、[条件キー](iam-data-condition-keys.md) に記載されています。
# Amazon Neptune を管理するためのカスタム IAM ポリシーステートメントの作成
管理ポリシーステートメントを使用すると、IAM ユーザーが Neptune データベースを管理するために実行できる操作を制御できます。
Neptune 管理ポリシーステートメントは、Neptune がサポートする 1 つ以上の[管理アクション](neptune-iam-admin-actions.md)と[管理リソース](iam-admin-resources.md)へのアクセスを付与します。[条件キー](iam-admin-condition-keys.md) を使用して、管理アクセス許可をより具体的にすることもできます。
**注記**
Neptune は Amazon RDS と機能を共有しているため、管理ポリシーステートメントの管理アクション、リソース、およびサービス固有の条件キーは、設計により `rds:` プレフィックスを使用します。
**Topics**
+ [Amazon Neptune を管理するための IAM アクション](neptune-iam-admin-actions.md)
+ [Amazon Neptune を管理するための IAM リソースタイプ](iam-admin-resources.md)
+ [Amazon Neptune を管理するための IAM 条件キー](iam-admin-condition-keys.md)
+ [Amazon Neptune の IAM 管理ポリシーステートメントの作成](iam-admin-policy-examples.md)
# Amazon Neptune を管理するための IAM アクション
IAM ポリシーステートメントの `Action` 要素で以下に示す管理アクションを使用して、[Neptune 管理 API](api.md) へのアクセスを制御できます。ポリシーでアクションを使用する場合は、通常、同じ名前の API オペレーションまたは CLI コマンドへのアクセスを許可または拒否します。ただし、場合によっては、1 つのアクションによって複数のオペレーションへのアクセスが制御されます。あるいは、いくつかのオペレーションはいくつかの異なるアクションを必要とします。
以下のリストの `Resource type` フィールドは、各アクションがリソースレベルのアクセス許可をサポートしているかどうかを示します。このフィールドに値がない場合は、ポリシーステートメントの `Resource` 要素ですべてのリソース (「\$1」) を指定する必要があります。列にリソースタイプが含まれる場合、そのアクションを含むステートメントでそのタイプの ARN を指定できます。Neptune 管理リソースタイプは、[このページ](iam-admin-resources.md)に記載されています。
必須リソースは、下記のリストでアスタリスク (\$1) で示されています。このアクションを使用してステートメントでリソースレベルのアクセス許可 ARN を指定する場合、このタイプである必要があります。一部のアクションでは、複数のリソースタイプがサポートされています。リソースタイプがオプション (つまり、アスタリスクが付いていない) であれば、含める必要はありません。
ここにリストされているフィールドの詳細については、「[IAM ユーザーガイド](https://docs.aws.amazon.com/IAM/latest/UserGuide/)」の「[アクションテーブル](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_actions-resources-contextkeys.html#actions_table)」を参照してください。
## rds:AddRoleToDBCluster
`AddRoleToDBCluster` IAM ロールを Neptune DB クラスターに関連付けるには
*アクセスレベル:* `Write`。
*依存アクション* `iam:PassRole`。
*リソースタイプ:* [クラスター](iam-admin-resources.md#neptune-cluster-resource) (必須)。
## rds:AddSourceIdentifierToSubscription
`AddSourceIdentifierToSubscription` 既存の Neptune イベント通知サブスクリプションにソース識別子を追加します。
*アクセスレベル:* `Write`。
*リソースタイプ:* [es](iam-admin-resources.md#neptune-es-resource) (必須)。
## rds:AddTagsToResource
`AddTagsToResource` IAM ロールを Neptune DB クラスターに関連付けるには
*アクセスレベル:* `Write`。
*リソースタイプ:*
+ [db](iam-admin-resources.md#neptune-db-resource)
+ [es](iam-admin-resources.md#neptune-es-resource)
+ [pg](iam-admin-resources.md#neptune-pg-resource)
+ [cluster-snapshot](iam-admin-resources.md#neptune-cluster-snapshot-resource)
+ [subgrp](iam-admin-resources.md#neptune-subgrp-resource)
*条件キー:*
+ [aws:RequestTag/*tag-key*](iam-admin-condition-keys.md#admin-aws_RequestTag)
+ [aws:TagKeys](iam-admin-condition-keys.md#admin-aws_TagKeys)
## rds:ApplyPendingMaintenanceAction
`ApplyPendingMaintenanceAction` 保留中のメンテナンスアクションをリソースに適用します。
*アクセスレベル:* `Write`。
*リソースタイプ:* [db](iam-admin-resources.md#neptune-db-resource) (必須)。
## rds:CopyDBClusterParameterGroup
`CopyDBClusterParameterGroup` 指定された DB クラスターパラメータグループをコピーします。
*アクセスレベル:* `Write`。
*リソースタイプ:* [cluster-pg](iam-admin-resources.md#neptune-cluster-pg-resource) (必須)。
## rds:CopyDBClusterSnapshot
`CopyDBClusterSnapshot` DB クラスターのスナップショットをコピーします。
*アクセスレベル:* `Write`。
*リソースタイプ:* [クラスタースナップショット](iam-admin-resources.md#neptune-cluster-snapshot-resource) (必須)。
## rds:CopyDBParameterGroup
`CopyDBParameterGroup` 指定された DB パラメータグループをコピーします。
*アクセスレベル:* `Write`。
*リソースタイプ:* [pg](iam-admin-resources.md#neptune-pg-resource) (必須)。
## rds:CreateDBCluster
`CreateDBCluster` 新しい Amazon Neptune DB クラスターを作成します。
*アクセスレベル:* `Tagging`。
*依存アクション* `iam:PassRole`。
*リソースタイプ:*
+ [クラスター](iam-admin-resources.md#neptune-cluster-resource) (必須)。
+ [cluster-pg](iam-admin-resources.md#neptune-cluster-pg-resource) (必須)。
+ [subgrp](iam-admin-resources.md#neptune-subgrp-resource) (必須)。
*条件キー:*
+ [aws:RequestTag/*tag-key*](iam-admin-condition-keys.md#admin-aws_RequestTag)
+ [aws:TagKeys](iam-admin-condition-keys.md#admin-aws_TagKeys)
+ [neptune-rds\$1DatabaseEngine](iam-admin-condition-keys.md#admin-rds_DatabaseEngine)
## rds:CreateDBClusterParameterGroup
`CreateDBClusterParameterGroup`新しい DB クラスターのパラメータグループを作成します。
*アクセスレベル:* `Tagging`。
*リソースタイプ:* [cluster-pg](iam-admin-resources.md#neptune-cluster-pg-resource) (必須)。
*条件キー:*
+ [aws:RequestTag/*tag-key*](iam-admin-condition-keys.md#admin-aws_RequestTag)
+ [aws:TagKeys](iam-admin-condition-keys.md#admin-aws_TagKeys)
## rds:CreateDBClusterSnapshot
`CreateDBClusterSnapshot`DB クラスターのスナップショットを作成します。
*アクセスレベル:* `Tagging`。
*リソースタイプ:*
+ [クラスター](iam-admin-resources.md#neptune-cluster-resource) (必須)。
+ [クラスタースナップショット](iam-admin-resources.md#neptune-cluster-snapshot-resource) (必須)。
*条件キー:*
+ [aws:RequestTag/*tag-key*](iam-admin-condition-keys.md#admin-aws_RequestTag)
+ [aws:TagKeys](iam-admin-condition-keys.md#admin-aws_TagKeys)
## rds:CreateDBInstance
`CreateDBInstance`新しい DB インスタンスを作成します。
*アクセスレベル:* `Tagging`。
*依存アクション* `iam:PassRole`。
*リソースタイプ:*
+ [db](iam-admin-resources.md#neptune-db-resource) (必須)。
+ [pg](iam-admin-resources.md#neptune-pg-resource) (必須)。
+ [subgrp](iam-admin-resources.md#neptune-subgrp-resource) (必須)。
*条件キー:*
+ [aws:RequestTag/*tag-key*](iam-admin-condition-keys.md#admin-aws_RequestTag)
+ [aws:TagKeys](iam-admin-condition-keys.md#admin-aws_TagKeys)
## rds:CreateDBParameterGroup
`CreateDBParameterGroup` は 新しい DB パラメータグループを作成します。
*アクセスレベル:* `Tagging`。
*リソースタイプ:* [pg](iam-admin-resources.md#neptune-pg-resource) (必須)。
*条件キー:*
+ [aws:RequestTag/*tag-key*](iam-admin-condition-keys.md#admin-aws_RequestTag)
+ [aws:TagKeys](iam-admin-condition-keys.md#admin-aws_TagKeys)
## rds:CreateDBSubnetGroup
`CreateDBSubnetGroup`新しい DB サブネットグループを作成します。
*アクセスレベル:* `Tagging`。
*リソースタイプ:* [subgrp](iam-admin-resources.md#neptune-subgrp-resource) (必須)。
*条件キー:*
+ [aws:RequestTag/*tag-key*](iam-admin-condition-keys.md#admin-aws_RequestTag)
+ [aws:TagKeys](iam-admin-condition-keys.md#admin-aws_TagKeys)
## rds:CreateEventSubscription
`CreateEventSubscription` RDS イベント通知サブスクリプションを作成します。
*アクセスレベル:* `Tagging`。
*リソースタイプ:* [es](iam-admin-resources.md#neptune-es-resource) (必須)。
*条件キー:*
+ [aws:RequestTag/*tag-key*](iam-admin-condition-keys.md#admin-aws_RequestTag)
+ [aws:TagKeys](iam-admin-condition-keys.md#admin-aws_TagKeys)
## rds:DeleteDBCluster
`DeleteDBCluster` 既存の Neptune DB クラスターを削除します。
*アクセスレベル:* `Write`。
*リソースタイプ:*
+ [クラスター](iam-admin-resources.md#neptune-cluster-resource) (必須)。
+ [クラスタースナップショット](iam-admin-resources.md#neptune-cluster-snapshot-resource) (必須)。
## rds:DeleteDBClusterParameterGroup
`DeleteDBClusterParameterGroup` 指定された DB クラスターパラメータグループを削除します。
*アクセスレベル:* `Write`。
*リソースタイプ:* [cluster-pg](iam-admin-resources.md#neptune-cluster-pg-resource) (必須)。
## rds:DeleteDBClusterSnapshot
`DeleteDBClusterSnapshot` DB クラスタースナップショットを削除します。
*アクセスレベル:* `Write`。
*リソースタイプ:* [クラスタースナップショット](iam-admin-resources.md#neptune-cluster-snapshot-resource) (必須)。
## rds:DeleteDBInstance
`DeleteDBInstance` 指定された DB インスタンスを削除します。
*アクセスレベル:* `Write`。
*リソースタイプ:* [db](iam-admin-resources.md#neptune-db-resource) (必須)。
## rds:DeleteDBParameterGroup
`DeleteDBParameterGroup` 指定された DBParameterGroup を削除します。
*アクセスレベル:* `Write`。
*リソースタイプ:* [pg](iam-admin-resources.md#neptune-pg-resource) (必須)。
## rds:DeleteDBSubnetGroup
`DeleteDBSubnetGroup` DB サブネットグループを削除します。
*アクセスレベル:* `Write`。
*リソースタイプ:* [subgrp](iam-admin-resources.md#neptune-subgrp-resource) (必須)。
## rds:DeleteEventSubscription
`DeleteEventSubscription` イベント通知サブスクリプションを削除します。
*アクセスレベル:* `Write`。
*リソースタイプ:* [es](iam-admin-resources.md#neptune-es-resource) (必須)。
## rds:DescribeDBClusterParameterGroups
`DescribeDBClusterParameterGroups` DBClusterParameterGroup の説明のリストを返します。
*アクセスレベル:* `List`。
*リソースタイプ:* [cluster-pg](iam-admin-resources.md#neptune-cluster-pg-resource) (必須)。
## rds:DescribeDBClusterParameters
`DescribeDBClusterParameters` 特定の DB クラスターパラメータグループの詳細なパラメータリストを返します。
*アクセスレベル:* `List`。
*リソースタイプ:* [cluster-pg](iam-admin-resources.md#neptune-cluster-pg-resource) (必須)。
## rds:DescribeDBClusterSnapshotAttributes
`DescribeDBClusterSnapshotAttributes` 手動の DB クラスタースナップショットの DB クラスタースナップショットの属性名と値のリストを返します。
*アクセスレベル:* `List`。
*リソースタイプ:* [クラスタースナップショット](iam-admin-resources.md#neptune-cluster-snapshot-resource) (必須)。
## rds:DescribeDBClusterSnapshots
`DescribeDBClusterSnapshots` DB クラスタースナップショットに関する情報を返します。
*アクセスレベル:* `Read`。
## rds:DescribeDBClusters
`DescribeDBClusters` プロビジョニングされた Neptune DB クラスターに関する情報を返します。
*アクセスレベル:* `List`。
*リソースタイプ:* [クラスター](iam-admin-resources.md#neptune-cluster-resource) (必須)。
## rds:DescribeDBEngineVersions
`DescribeDBEngineVersions` 利用可能な DB エンジンのリストを返します。
*アクセスレベル:* `List`。
*リソースタイプ:* [pg](iam-admin-resources.md#neptune-pg-resource) (必須)。
## rds:DescribeDBInstances
`DescribeDBInstances` すべての DB インスタンスに関する情報を返します。
*アクセスレベル:* `List`。
*リソースタイプ:* [es](iam-admin-resources.md#neptune-es-resource) (必須)。
## rds:DescribeDBParameterGroups
`DescribeDBParameterGroups` DBParameterGroup の説明のリストを返します。
*アクセスレベル:* `List`。
*リソースタイプ:* [pg](iam-admin-resources.md#neptune-pg-resource) (必須)。
## rds:DescribeDBParameters
`DescribeDBParameters` 特定の DB パラメータグループの詳細なパラメータリストを返します。
*アクセスレベル:* `List`。
*リソースタイプ:* [pg](iam-admin-resources.md#neptune-pg-resource) (必須)。
## rds:DescribeDBSubnetGroups
`DescribeDBSubnetGroups` DBSubnetGroup の説明のリストを返します。
*アクセスレベル:* `List`。
*リソースタイプ:* [subgrp](iam-admin-resources.md#neptune-subgrp-resource) (必須)。
## rds:DescribeEventCategories
`DescribeEventCategories` すべてのイベントソースタイプか、指定されている場合は、指定されたソースタイプのイベントカテゴリのリストを返します。
*アクセスレベル:* `List`。
## rds:DescribeEventSubscriptions
`DescribeEventSubscriptions`顧客アカウントのサブスクリプションの説明をすべて表示します。
*アクセスレベル:* `List`。
*リソースタイプ:* [es](iam-admin-resources.md#neptune-es-resource) (必須)。
## rds:DescribeEvents
`DescribeEvents` DB インスタンス、DB セキュリティグループ、DB スナップショット、DB パラメータグループに関連する過去 14 日間のイベントを返します。
*アクセスレベル:* `List`。
*リソースタイプ:* [es](iam-admin-resources.md#neptune-es-resource) (必須)。
## rds:DescribeOrderableDBInstanceOptions
`DescribeOrderableDBInstanceOptions` 指定されたエンジンの注文可能な DB インスタンスオプションのリストを返します。
*アクセスレベル:* `List`。
## rds:DescribePendingMaintenanceActions
`DescribePendingMaintenanceActions` 少なくとも 1 つの保留中のメンテナンスアクションを含むリソース (例: DB インスタンス) のリストを返します。
*アクセスレベル:* `List`。
*リソースタイプ:* [db](iam-admin-resources.md#neptune-db-resource) (必須)。
## rds:DescribeValidDBInstanceModifications
`DescribeValidDBInstanceModifications` DB インスタンスに加えることができる変更を一覧表示します。
*アクセスレベル:* `List`。
*リソースタイプ:* [db](iam-admin-resources.md#neptune-db-resource) (必須)。
## rds:FailoverDBCluster
`FailoverDBCluster` DB クラスターのフェイルオーバーを強制実行します。
*アクセスレベル:* `Write`。
*リソースタイプ:* [クラスター](iam-admin-resources.md#neptune-cluster-resource) (必須)。
## rds:ListTagsForResource
`ListTagsForResource` Amazon Neptune リソースのすべてのタグを一覧表示します。
*アクセスレベル:* `Read`。
*リソースタイプ:*
+ [cluster-snapshot](iam-admin-resources.md#neptune-cluster-snapshot-resource)
+ [db](iam-admin-resources.md#neptune-db-resource)
+ [es](iam-admin-resources.md#neptune-es-resource)
+ [pg](iam-admin-resources.md#neptune-pg-resource)
+ [subgrp](iam-admin-resources.md#neptune-subgrp-resource)
## rds:ModifyDBCluster
`ModifyDBCluster`
Neptune DB クラスターの設定を変更します。
*アクセスレベル:* `Write`。
*依存アクション* `iam:PassRole`。
*リソースタイプ:*
+ [クラスター](iam-admin-resources.md#neptune-cluster-resource) (必須)。
+ [cluster-pg](iam-admin-resources.md#neptune-cluster-pg-resource) (必須)。
## rds:ModifyDBClusterParameterGroup
`ModifyDBClusterParameterGroup` DB クラスターパラメータグループのパラメータを変更します。
*アクセスレベル:* `Write`。
*リソースタイプ:* [cluster-pg](iam-admin-resources.md#neptune-cluster-pg-resource) (必須)。
## rds:ModifyDBClusterSnapshotAttribute
`ModifyDBClusterSnapshotAttribute` 属性および値を、手動 DB クラスタースナップショットに追加するか、ここから属性および値を削除します。
*アクセスレベル:* `Write`。
*リソースタイプ:* [クラスタースナップショット](iam-admin-resources.md#neptune-cluster-snapshot-resource) (必須)。
## rds:ModifyDBInstance
`ModifyDBInstance` DB インスタンスの設定を変更します。
*アクセスレベル:* `Write`。
*依存アクション* `iam:PassRole`。
*リソースタイプ:*
+ [db](iam-admin-resources.md#neptune-db-resource) (必須)。
+ [pg](iam-admin-resources.md#neptune-pg-resource) (必須)。
## rds:ModifyDBParameterGroup
`ModifyDBParameterGroup` DB パラメータグループのパラメータを変更します。
*アクセスレベル:* `Write`。
*リソースタイプ:* [pg](iam-admin-resources.md#neptune-pg-resource) (必須)。
## rds:ModifyDBSubnetGroup
`ModifyDBSubnetGroup` 既存の DB サブネットグループを変更します。
*アクセスレベル:* `Write`。
*リソースタイプ:* [subgrp](iam-admin-resources.md#neptune-subgrp-resource) (必須)。
## rds:ModifyEventSubscription
`ModifyEventSubscription` 既存の RDS イベント通知サブスクリプションを変更します。
*アクセスレベル:* `Write`。
*リソースタイプ:* [es](iam-admin-resources.md#neptune-es-resource) (必須)。
## RDS:RebootDBInstance
`RebootDBInstance` インスタンスを再起動すると、データベースエンジンサービスが再起動されます。
*アクセスレベル:* `Write`。
*リソースタイプ:* [db](iam-admin-resources.md#neptune-db-resource) (必須)。
## rds:RemoveRoleFromDBCluster
`RemoveRoleFromDBCluster` は、Amazon Neptune DB クラスターから AWS Identity and Access Management (IAM) ロールの関連付けを解除します。
*アクセスレベル:* `Write`。
*依存アクション* `iam:PassRole`。
*リソースタイプ:* [クラスター](iam-admin-resources.md#neptune-cluster-resource) (必須)。
## rds:RemoveSourceIdentifierFromSubscription
`RemoveSourceIdentifierFromSubscription` 既存のイベント通知サブスクリプションからソース識別子を削除します。
*アクセスレベル:* `Write`。
*リソースタイプ:* [es](iam-admin-resources.md#neptune-es-resource) (必須)。
## rds:RemoveTagsFromResource
`RemoveTagsFromResource` Neptune リソースからメタデータタグを削除します。
*アクセスレベル:* `Tagging`。
*リソースタイプ:*
+ [cluster-snapshot](iam-admin-resources.md#neptune-cluster-snapshot-resource)
+ [db](iam-admin-resources.md#neptune-db-resource)
+ [es](iam-admin-resources.md#neptune-es-resource)
+ [pg](iam-admin-resources.md#neptune-pg-resource)
+ [subgrp](iam-admin-resources.md#neptune-subgrp-resource)
*条件キー:*
+ [aws:RequestTag/*tag-key*](iam-admin-condition-keys.md#admin-aws_RequestTag)
+ [aws:TagKeys](iam-admin-condition-keys.md#admin-aws_TagKeys)
## rds:ResetDBClusterParameterGroup
`ResetDBClusterParameterGroup` DB クラスターパラメータグループのパラメータをデフォルト値に変更します。
*アクセスレベル:* `Write`。
*リソースタイプ:* [cluster-pg](iam-admin-resources.md#neptune-cluster-pg-resource) (必須)。
## rds:ResetDBParameterGroup
`ResetDBParameterGroup` はDB パラメータグループのパラメータをエンジン/システムのデフォルト値に変更します。
*アクセスレベル:* `Write`。
*リソースタイプ:* [pg](iam-admin-resources.md#neptune-pg-resource) (必須)。
## rds:RestoreDBClusterFromSnapshot
`RestoreDBClusterFromSnapshot` DB クラスタースナップショットから新しい DB クラスターを作成します。
*アクセスレベル:* `Write`。
*依存アクション* `iam:PassRole`。
*リソースタイプ:*
+ [クラスター](iam-admin-resources.md#neptune-cluster-resource) (必須)。
+ [クラスタースナップショット](iam-admin-resources.md#neptune-cluster-snapshot-resource) (必須)。
*条件キー:*
+ [aws:RequestTag/*tag-key*](iam-admin-condition-keys.md#admin-aws_RequestTag)
+ [aws:TagKeys](iam-admin-condition-keys.md#admin-aws_TagKeys)
## rds:RestoreDBClusterToPointInTime
`RestoreDBClusterToPointInTime` DB クラスターを任意の時点に復元します。
*アクセスレベル:* `Write`。
*依存アクション* `iam:PassRole`。
*リソースタイプ:*
+ [クラスター](iam-admin-resources.md#neptune-cluster-resource) (必須)。
+ [subgrp](iam-admin-resources.md#neptune-subgrp-resource) (必須)。
*条件キー:*
+ [aws:RequestTag/*tag-key*](iam-admin-condition-keys.md#admin-aws_RequestTag)
+ [aws:TagKeys](iam-admin-condition-keys.md#admin-aws_TagKeys)
## rds:StartDBCluster
`StartDBCluster`指定された DB クラスターを起動します。
*アクセスレベル:* `Write`。
*リソースタイプ:* [クラスター](iam-admin-resources.md#neptune-cluster-resource) (必須)。
## rds:StopDBCluster
`StopDBCluster`指定された DB クラスターを停止します。
*アクセスレベル:* `Write`。
*リソースタイプ:* [クラスター](iam-admin-resources.md#neptune-cluster-resource) (必須)。
# Amazon Neptune を管理するための IAM リソースタイプ
Neptune は、次の表のリソースタイプをサポートしており、IAM 管理ポリシーステートメントの `Resource` 要素で使うことができます。`Resource` 要素の詳細については、「[IAM JSON ポリシーの要素: リソース](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_elements_resource.html)」を参照してください。
[Neptune 管理アクションのリスト](neptune-iam-admin-actions.md)は、各アクションで指定できるリソースタイプを示しています。リソースタイプは、次の表最後の列で指定されているように、ポリシーに含めることができる条件キーを決定します。
下の表の `ARN` 列は、このタイプのリソースの参照に使用する必要がある Amazon リソースネーム (ARN) の形式を指定しています。` $ ` で始まる部分は、お客様の状況で実際の値に置き換える必要があります。例えば、ARN に `$user-name` と表示されている場合は、その文字列を実際の IAM ユーザー名か、IAM ユーザー名を含むポリシー変数に置き換える必要があります。ARN の詳細については、「[IAM ARN](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_identifiers.html#identifiers-arns)」と「[Amazon Neptune で ARN を使用する](tagging-arns.md)」を参照してください。
` Condition Keys ` 列では、このリソースとサポートするアクションの両方がステートメントに含まれている場合にのみ IAM ポリシーステートメントに含むことができる条件コンテキストキーを指定します。
****
| リソースタイプ | ARN | 条件キー |
| --- | --- | --- |
| `cluster` (DB クラスター) | arn:partition:rds:region:account-id:cluster:instance-name | [aws:ResourceTag/*tag-key*](iam-admin-condition-keys.md#admin-aws_ResourceTag) [rds:cluster-tag/*tag-key*](iam-admin-condition-keys.md#admin-rds_cluster-tag) |
| `cluster-pg` (DB クラスターのパラメータグループ) | arn:partition:rds:region:account-id:cluster-pg:neptune-DBClusterParameterGroupName | [aws:ResourceTag/*tag-key*](iam-admin-condition-keys.md#admin-aws_ResourceTag) |
| `cluster-snapshot` (DB クラスタースナップショット) | arn:partition:rds:region:account-id:cluster-snapshot:neptune-DBClusterSnapshotName | [aws:ResourceTag/*tag-key*](iam-admin-condition-keys.md#admin-aws_ResourceTag) [rds:cluster-snapshot-tag/*tag-key*](iam-admin-condition-keys.md#admin-rds_cluster-snapshot-tag) |
| `db` (DB インスタンス) | arn:partition:rds:region:account-id:db:neptune-DbInstanceName | [aws:ResourceTag/*tag-key*](iam-admin-condition-keys.md#admin-aws_ResourceTag) [rds:DatabaseClass](iam-admin-condition-keys.md#admin-rds_DatabaseClass) [rds:DatabaseEngine](iam-admin-condition-keys.md#admin-rds_DatabaseEngine) [rds: db-tag*tag-key*](iam-admin-condition-keys.md#admin-rds_db-tag) |
| `es` (イベントサブスクリプション) | arn:partition:rds:region:account-id:es:neptune-CustSubscriptionId | [aws:ResourceTag/*tag-key*](iam-admin-condition-keys.md#admin-aws_ResourceTag) [rds: es-tag*tag-key*](iam-admin-condition-keys.md#admin-rds_es-tag) |
| `pg` (DB パラメータグループを編集する) | arn:partition:rds:region:account-id:pg:neptune-ParameterGroupName | [aws:ResourceTag/*tag-key*](iam-admin-condition-keys.md#admin-aws_ResourceTag) [rds: pg-tag*tag-key*](iam-admin-condition-keys.md#admin-rds_pg-tag) |
| `subgrp` (DB サブネットグループ) | arn:partition:rds:region:account-id:subgrp:neptune-DBSubnetGroupName\$1 | [aws:ResourceTag/*tag-key*](iam-admin-condition-keys.md#admin-aws_ResourceTag) [rds: subgrp-tag/*tag-key*](iam-admin-condition-keys.md#admin-rds_subgrp-tag) |
# Amazon Neptune を管理するための IAM 条件キー
[条件キーを使用すると](security-iam-access-manage.md#iam-using-condition-keys)、IAM ポリシーステートメントで条件を指定して、条件が満たされた場合にのみステートメントが有効になるようにすることができます。Neptune 管理ポリシーステートメントで使用できる条件キーは、次のカテゴリに分類されます。
+ [グローバル条件キー](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_condition-keys.html) – これらは、 AWS サービスでの一般的な使用 AWS のために で定義されます。ほとんどは Neptune 管理ポリシーステートメントで使用できます。
+ [管理リソースプロパティ条件キー](#iam-rds-property-condition-keys) — [以下に](#iam-rds-property-condition-keys)示すこれらのキーは、管理リソースのプロパティに基づいています。
+ [タグベースのアクセス条件キー](#iam-rds-tag-based-condition-keys) — [以下に](#iam-rds-tag-based-condition-keys)示すこれらのキーは、管理リソースに付けられた [AWS タグ](https://docs.aws.amazon.com/general/latest/gr/aws_tagging.html)に基づいています。
## Neptune 管理リソースプロパティの条件キー
| 条件キー | 説明 | タイプ |
| --- | --- | --- |
| rds:DatabaseClass | DB インスタンスクラスのタイプによってアクセスをフィルタリングします。 | String |
| rds:DatabaseEngine | データベースエンジンでアクセスをフィルタリングします。可能な値については、CreateDBInstance API のエンジンパラメータを参照してください。 | 文字列 |
| rds:DatabaseName | DB インスタンス上のデータベースのユーザー定義名でアクセスをフィルタリングします。 | 文字列 |
| rds:EndpointType | エンドポイントのタイプでアクセスをフィルタリングします。READER、WRITER、CUSTOM のいずれか。 | String |
| rds:Vpc | DB インスタンスを Amazon Virtual Private Cloud (Amazon VPC) で実行するかどうかを指定する値でアクセスをフィルタリングします。DB インスタンスが Amazon VPC で実行されていることを示すには、true を指定します。 | ブール値 |
## 管理タグベースの条件キー
Amazon Neptune では、カスタムタグを使用して IAM ポリシーで条件を指定することがサポートされており、[管理 API リファレンス](api.md) を介して Neptune へのアクセスを制御します。
たとえば、DB インスタンスに `environment` という名前のタグを追加するとします。`beta`、`staging`、および `production` のような値を使用します。そのタグの値に基づいてインスタンスへのアクセスを制限するポリシーを作成できます。
**重要**
タグを使用して Neptune リソースへのアクセスを管理する場合は、タグへのアクセスを保護してください。`AddTagsToResource` および `RemoveTagsFromResource` アクションのポリシーを作成することによって、タグへのアクセスを制限できます。
例えば、次のポリシーは、ユーザーがすべてのリソースのタグを追加または削除することを拒否します。次に、特定のユーザーがタグを追加または削除することを許可するポリシーを作成できます。
****
```
{ "Version":"2012-10-17",
"Statement":[
{ "Sid": "DenyTagUpdates",
"Effect": "Deny",
"Action": [
"rds:AddTagsToResource",
"rds:RemoveTagsFromResource"
],
"Resource":"*"
}
]
}
```
以下のタグベースの条件キーは、管理ポリシーステートメント内の管理リソースでのみ機能します。
**タグベースの管理条件キー**
| 条件キー | 説明 | タイプ |
| --- | --- | --- |
| [https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_condition-keys.html#condition-keys-requesttag](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_condition-keys.html#condition-keys-requesttag) | リクエスト内のタグキーと値のペアの有無に基づいてアクセスをフィルタリングします。 | String |
| [https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_condition-keys.html#condition-keys-resourcetag](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_condition-keys.html#condition-keys-resourcetag) | リソースにアタッチされているタグキーと値のペアに基づいてアクセスをフィルタリングします。 | String |
| [https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_condition-keys.html#condition-keyss](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_condition-keys.html#condition-keyss) | リクエスト内のタグキーの有無に基づいてアクセスをフィルタリングします | String |
| rds:cluster-pg-tag/\$1\$1TagKey\$1 | DB クラスターパラメータグループにアタッチされたタグによってアクセスをフィルタリングします。 | String |
| rds:cluster-snapshot-tag/\$1\$1TagKey\$1 | DB クラスタースナップショットにアタッチされたタグによってアクセスをフィルタリングします。 | String |
| rds:cluster-tag/\$1\$1TagKey\$1 | DB クラスターにアタッチされたタグによってアクセスをフィルタリングします。 | String |
| rds:db-tag/\$1\$1TagKey\$1 | DB インスタンスにアタッチされたタグによってアクセスをフィルタリングします。 | String |
| rds:es-tag/\$1\$1TagKey\$1 | イベントサブスクリプションにアタッチされたタグによってアクセスをフィルタリングします。 | String |
| rds:pg-tag/\$1\$1TagKey\$1 | DB パラメータグループにアタッチされたタグによってアクセスをフィルタリングします。 | String |
| rds:req-tag/\$1\$1TagKey\$1 | リソースにタグを付けるために使用できるタグキーと値のセットによってアクセスをフィルタリングします。 | String |
| rds:secgrp-tag/\$1\$1TagKey\$1 | DB セキュリティグループにアタッチされたタグによってアクセスをフィルタリングします。 | String |
| rds:snapshot-tag/\$1\$1TagKey\$1 | DB スナップショットにアタッチされたタグによってアクセスをフィルタリングします | String |
| rds:subgrp-tag/\$1\$1TagKey\$1 | DB サブネットグループにアタッチされたタグでアクセスをフィルタリングします。 | String |
# Amazon Neptune の IAM 管理ポリシーステートメントの作成
## 一般的な管理ポリシーの例
以下の例は、DB クラスターに対してさまざまな管理アクションを実行するためのアクセス許可を付与する Neptune 管理ポリシーを作成する方法を示しています。
### IAM ユーザーが指定した DB インスタンスを削除できないようにするポリシー
以下は、IAM ユーザーが指定した DB インスタンスを削除できないようにするポリシーの例です。
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Sid": "DenyDeleteOneInstance",
"Effect": "Deny",
"Action": "rds:DeleteDBInstance",
"Resource": "arn:aws:rds:us-west-2:123456789012:db:my-instance-name"
}
]
}
```
------
### 新しい DB インスタンスを作成するアクセス許可を付与するポリシー
以下は、IAM ユーザーが指定された Neptune DB クラスターに DB インスタンスを作成できるようにするポリシーの例です。
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Sid": "AllowCreateInstance",
"Effect": "Allow",
"Action": "rds:CreateDBInstance",
"Resource": "arn:aws:rds:us-west-2:123456789012:cluster:my-cluster"
}
]
}
```
------
### 特定の DB パラメータグループを使用する新しい DB インスタンスを作成するアクセス許可を付与するポリシー
以下は、IAM ユーザーが、指定された DB パラメータグループのみを使用して、指定された Neptune DB クラスター内の指定された DB クラスター (ここでは `us-west-2`) に DB インスタンスを作成することを許可するポリシーの例です。
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Sid": "AllowCreateInstanceWithPG",
"Effect": "Allow",
"Action": "rds:CreateDBInstance",
"Resource": [
"arn:aws:rds:us-west-2:123456789012:cluster:my-cluster",
"arn:aws:rds:us-west-2:123456789012:pg:my-instance-pg"
]
}
]
}
```
------
### リソースを記述するアクセス許可を付与するポリシー
以下は、IAM ユーザーが任意の Neptune リソースを記述できるようにするポリシーの例です。
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Sid": "AllowDescribe",
"Effect": "Allow",
"Action": "rds:Describe*",
"Resource": "*"
}
]
}
```
------
## タグベースの管理ポリシーの例
以下の例は、DB クラスターに対してさまざまな管理アクションを実行するためのアクセス許可をフィルタリングするタグを付ける Neptune 管理ポリシーを作成する方法を示しています。
### 例 1: 複数の値を取ることができるカスタムタグを使用して、リソースに対するアクションにアクセス許可を付与する
以下のポリシーでは、`ModifyDBInstance`、`CreateDBInstance`または`DeleteDBInstance` API を `dev` または `test` どちらかに設定した`env` タグを持つある DB インスタンスで使用できます。
------
#### [ JSON ]
****
```
{ "Version":"2012-10-17",
"Statement": [
{
"Sid": "AllowDevTestAccess",
"Effect": "Allow",
"Action": [
"rds:ModifyDBInstance",
"rds:CreateDBInstance",
"rds:DeleteDBInstance"
],
"Resource": "*",
"Condition": {
"StringEquals": {
"rds:db-tag/env": [
"dev",
"test"
],
"rds:DatabaseEngine": "neptune"
}
}
}
]
}
```
------
### 例 2: リソースにタグを付けるために使用できるタグキーと値のセットを制限する
このポリシーでは、`Condition` キーを使って、キー `env` を持つタグと、リソースに追加する `test`、`qa`、または `dev` の値の使用を許可します。
------
#### [ JSON ]
****
```
{ "Version":"2012-10-17",
"Statement": [
{
"Sid": "AllowTagAccessForDevResources",
"Effect": "Allow",
"Action": [
"rds:AddTagsToResource",
"rds:RemoveTagsFromResource"
],
"Resource": "*",
"Condition": {
"StringEquals": {
"rds:req-tag/env": [
"test",
"qa",
"dev"
],
"rds:DatabaseEngine": "neptune"
}
}
}
]
}
```
------
### 例 3: `aws:ResourceTag` に基づいて Neptune リソースへのフルアクセスを許可する
以下のポリシーは、上記の最初の例と似ていますが、代わりに `aws:ResourceTag` を使います。
------
#### [ JSON ]
****
```
{ "Version":"2012-10-17",
"Statement": [
{
"Sid": "AllowFullAccessToDev",
"Effect": "Allow",
"Action": [
"rds:*"
],
"Resource": "*",
"Condition": {
"StringEquals": {
"aws:ResourceTag/env": "dev",
"rds:DatabaseEngine": "neptune"
}
}
}
]
}
```
------
# Amazon Neptune のデータにアクセスするためのカスタム IAM ポリシーステートメントの作成
Neptune データアクセスポリシーステートメントは、[データアクセスアクション](iam-dp-actions.md)、[リソース](iam-data-resources.md)、および[条件キー](iam-data-condition-keys.md#iam-neptune-condition-keys)を使用し、これらはすべて `neptune-db:` プレフィックスが付きます。
**Topics**
+ [Neptune データアクセスポリシーステートメントでのクエリアクションの使用](#iam-data-query-actions)
+ [Amazon Neptune でのデータアクセスのための IAM アクション](iam-dp-actions.md)
+ [Amazon Neptune のデータにアクセスするための IAM リソースタイプ](iam-data-resources.md)
+ [Amazon Neptune のデータにアクセスするための IAM 条件キー](iam-data-condition-keys.md)
+ [Amazon Neptune での IAM データアクセスポリシーの作成](iam-data-access-examples.md)
## Neptune データアクセスポリシーステートメントでのクエリアクションの使用
データアクセスポリシーステートメントで使用できる Neptune クエリアクションには、`ReadDataViaQuery`、`WriteDataViaQuery`、`DeleteDataViaQuery` の 3 つがあります。特定のクエリには、これらのアクションを複数実行するためのアクセス許可が必要な場合があり、クエリを実行するためにこれらのアクションのどの組み合わせを許可する必要があるかが常に明確であるとは限りません。
クエリを実行する前に、Neptune はクエリの各ステップを実行するのに必要なアクセス許可を決定し、それらを組み合わせてクエリに必要なアクセス許可のフルセットにします。このフルセットのアクセス許可には、クエリが実行する*可能性のある*すべてのアクションが含まれますが、必ずしもクエリがデータに対して実際に実行するアクションのセットではないことに注意してください。
つまり、特定のクエリの実行を許可するには、そのクエリが実際に実行するかどうかにかかわらず、そのクエリが実行する可能性のあるすべてのアクションにアクセス許可を与える必要があります。
以下に、Gremlin クエリの例をいくつか示します。これについてさらに詳しく説明しています。
+
```
g.V().count()
```
`g.V()` および `count()` は読み取りアクセスだけを必要とするため、クエリ全体として必要なのは `ReadDataViaQuery` アクセスのみです。
+
```
g.addV()
```
`addV()` は、新しい ID の頂点を挿入する前に、特定の ID の頂点が存在するかどうかを確認する必要があります。つまり、`ReadDataViaQuery` と `WriteDataViaQuery` の両方のアクセスが必要です。
+
```
g.V('1').as('a').out('created').addE('createdBy').to('a')
```
`g.V('1').as('a')` と `out('created')` は読み取りアクセスのみを必要としますが、`addE().from('a')` は読み取りと書き込みの両方のアクセスを必要とします。`addE()` は `from` を読み取る必要があり、`to` は新しい ID のエッジを追加する前に、同じ ID のエッジが既に存在するかどうかを確認する必要があるためです。そのため、クエリ全体としては、`ReadDataViaQuery` と `WriteDataViaQuery` の両方のアクセスが必要です。
+
```
g.V().drop()
```
`g.V()` は読み取りアクセスのみを必要とします。`drop()` は頂点またはエッジを削除する前にそれらを読み取る必要があるため、読み取りアクセスと削除アクセスの両方が必要です。そのため、クエリ全体としては `ReadDataViaQuery` と `DeleteDataViaQuery` の両方のアクセスが必要です。
+
```
g.V('1').property(single, 'key1', 'value1')
```
`g.V('1')` は読み取りアクセスのみを必要としますが、`property(single, 'key1', 'value1')` は読み取り、書き込み、および削除アクセスを必要とします。ここでは、`property()` ステップは、頂点にまだ存在しない場合はキーと値を挿入しますが、既に存在する場合は、既存のプロパティ値を削除し、代わりに新しい値を挿入します。したがって、クエリ全体としては、`ReadDataViaQuery`、`WriteDataViaQuery`、および `DeleteDataViaQuery` アクセスが必要です。
`property()` ステップを含むクエリには、`ReadDataViaQuery`、`WriteDataViaQuery`、および `DeleteDataViaQuery` アクセス許可が必要です。
openCypher の例をいくつか示します。
+
```
MATCH (n)
RETURN n
```
このクエリはデータベース内のすべてのノードを読み込んで返します。必要なのは `ReadDataViaQuery` アクセスだけです。
+
```
MATCH (n:Person)
SET n.dept = 'AWS'
```
このクエリには、`ReadDataViaQuery`、`WriteDataViaQuery`、および `DeleteDataViaQuery` アクセスが必要です。「Person」というラベルの付いたすべてのノードを読み取り、キー `dept` と値 `AWS` を持つ新しいプロパティを追加するか、`dept` プロパティが既に存在する場合は、古い値を削除して、代わりに `AWS` を挿入します。また、設定する値が `null` の場合、`SET` はプロパティをすべて削除します。
`SET` 句は既存の値を削除しなければならない場合があるため、**常に** `DeleteDataViaQuery` アクセス許可だけでなく `ReadDataViaQuery` および `WriteDataViaQuery` アクセス許可も必要です。
+
```
MATCH (n:Person)
DETACH DELETE n
```
このクエリには `ReadDataViaQuery` および `DeleteDataViaQuery` アクセス許可が必要です。ラベル `Person` の付いたノードをすべｒて検索し、それらのノードに接続されているエッジや関連するラベルやプロパティとともに削除します。
+
```
MERGE (n:Person {name: 'John'})-[:knows]->(:Person {name: 'Peter'})
RETURN n
```
このクエリには `ReadDataViaQuery` および `WriteDataViaQuery` アクセス許可が必要です。`MERGE` 句は、指定されたパターンと一致するか、それを作成します。パターンが一致しないと書き込みが発生する可能性があるため、読み取りアクセス許可だけでなく書き込みアクセス許可も必要です。
# Amazon Neptune でのデータアクセスのための IAM アクション
Neptune データアクセスアクションにはプレフィックス `neptune-db:` が付いていますが、Neptune の管理アクションにはプレフィックス `rds:` が付いていることに注意してください。
IAM でのデータの Amazon リソースネーム (ARN) は、作成時にクラスターに割り当てられた ARN とは異なります。「[データリソースの指定](iam-data-resources.md)」に示されているように ARN を構築する必要があります。このようなデータリソース ARN では、ワイルドカードを使用して複数のリソースを含めることができます。
データアクセスポリシーステートメントには、クエリ言語によってアクセスを制限するための [neptune-db:QueryLanguage](iam-data-condition-keys.md#iam-neptune-condition-keys) 条件キーを含めることもできます。
[リリース: 1.2.0.0 (2022-07-21)](engine-releases-1.2.0.0.md) 以降、Neptune は 1 つ以上の[特定の Neptune アクション](https://docs.aws.amazon.com/service-authorization/latest/reference/list_amazonneptune.html)へのアクセス許可の制限をサポートしています。これにより、以前よりもきめ細かなアクセスコントロールが可能になります。
**重要**
IAM ポリシーへの変更は、指定された Neptune リソースへの適用に最大で 10 分かかります。
Neptune DB クラスターに適用された IAM ポリシーは、そのクラスター内のすべてのインスタンスに適用されます。
## *クエリベースのデータアクセスアクション*
**注記**
クエリは、処理するデータによっては複数のアクションを実行することがあるため、特定のクエリを実行するためにどのようなアクセス許可が必要かが常に明確であるとは限りません。詳細については「[クエリアクションの使用](iam-data-access-policies.md#iam-data-query-actions)」を参照してください。
## `neptune-db:ReadDataViaQuery`
`ReadDataViaQuery` を使用すると、ユーザーは、クエリを送信して Neptune データベースからデータを読み取ることができます。
*アクショングループ:* 読み取り専用、読み取り/書き込み。
*アクションコンテキストキー*: `neptune-db:QueryLanguage`。
*必要なリソース:* データベース。
## `neptune-db:WriteDataViaQuery`
`WriteDataViaQuery` を使用すると、ユーザーは、クエリを送信して Neptune データベースにデータを書き込むことができます。
*アクショングループ:* 読み取り/書き込み。
*アクションコンテキストキー*: `neptune-db:QueryLanguage`。
*必要なリソース:* データベース。
## `neptune-db:DeleteDataViaQuery`
`DeleteDataViaQuery` を使用すると、ユーザーは、クエリを送信して Neptune データベースからデータを削除できます。
*アクショングループ:* 読み取り/書き込み。
*アクションコンテキストキー*: `neptune-db:QueryLanguage`。
*必要なリソース:* データベース。
## `neptune-db:GetQueryStatus`
`GetQueryStatus` を使用すると、ユーザーは、すべてのアクティブなクエリのステータスを確認できます。
*アクショングループ:* 読み取り専用、読み取り/書き込み。
*アクションコンテキストキー*: `neptune-db:QueryLanguage`。
*必要なリソース:* データベース。
## `neptune-db:GetStreamRecords`
`GetStreamRecords` を使用すると、ユーザーは、Neptune からストリームレコードを取得できます。
*アクショングループ:* 読み取り/書き込み。
*アクションコンテキストキー*: `neptune-db:QueryLanguage`。
*必要なリソース:* データベース。
## `neptune-db:CancelQuery`
`CancelQuery` を使用すると、ユーザーは、クエリをキャンセルできます。
*アクショングループ:* 読み取り/書き込み。
*必要なリソース:* データベース。
## *一般的なデータアクセスアクション*
## `neptune-db:GetEngineStatus`
`GetEngineStatus` を使用すると、ユーザーは、Neptune エンジンのステータスを確認できます。
*アクショングループ:* 読み取り専用、読み取り/書き込み。
*必要なリソース:* データベース。
## `neptune-db:GetStatisticsStatus`
`GetStatisticsStatus` を使用すると、ユーザーは、データベースについて収集されている統計のステータスを確認できます。
*アクショングループ:* 読み取り専用、読み取り/書き込み。
*必要なリソース:* データベース。
## `neptune-db:GetGraphSummary`
`GetGraphSummary` グラフサマリー API では、グラフの読み取り専用サマリーを取得できます。
*アクショングループ:* 読み取り専用、読み取り/書き込み。
*必要なリソース:* データベース。
## `neptune-db:ManageStatistics`
`ManageStatistics` では、ユーザーは、データベースの統計収集を管理できます。
*アクショングループ:* 読み取り/書き込み。
*必要なリソース:* データベース。
## `neptune-db:DeleteStatistics`
`DeleteStatistics` では、ユーザーは、データベースのすべての統計を削除できます。
*アクショングループ:* 読み取り/書き込み。
*必要なリソース:* データベース。
## `neptune-db:ResetDatabase`
`ResetDatabase` では、ユーザーは、リセットに必要なトークンを取得し、Neptune データベースをリセットできます。
*アクショングループ:* 読み取り/書き込み。
*必要なリソース:* データベース。
## *バルクローダーのデータアクセスアクション*
## `neptune-db:StartLoaderJob`
`StartLoaderJob` では、ユーザーは、バルクローダージョブを開始できます。
*アクショングループ:* 読み取り/書き込み。
*必要なリソース:* データベース。
## `neptune-db:GetLoaderJobStatus`
`GetLoaderJobStatus` では、ユーザーは、バルクローダージョブのステータスを確認できます。
*アクショングループ:* 読み取り専用、読み取り/書き込み。
*必要なリソース:* データベース。
## `neptune-db:ListLoaderJobs`
`ListLoaderJobs` では、ユーザーは、すべてのバルクローダージョブを一覧表示できます。
*アクショングループ:* リスト専用、読み取り専用、読み取り/書き込み。
*必要なリソース:* データベース。
## `neptune-db:CancelLoaderJob`
`CancelLoaderJob` では、ユーザーは、ローダージョブをキャンセルできます。
*アクショングループ:* 読み取り/書き込み。
*必要なリソース:* データベース。
## *機械学習データアクセスアクション*
## `neptune-db:StartMLDataProcessingJob`
`StartMLDataProcessingJob` では、ユーザーは、Neptune ML データ処理ジョブを開始できます。
*アクショングループ:* 読み取り/書き込み。
*必要なリソース:* データベース。
## `neptune-db:StartMLModelTrainingJob`
`StartMLModelTrainingJob` では、ユーザーは、ML モデルトレーニングジョブを開始できます。
*アクショングループ:* 読み取り/書き込み。
*必要なリソース:* データベース。
## `neptune-db:StartMLModelTransformJob`
`StartMLModelTransformJob` では、ユーザーは、ML モデル変換ジョブを開始できます。
*アクショングループ:* 読み取り/書き込み。
*必要なリソース:* データベース。
## `neptune-db:CreateMLEndpoint`
`CreateMLEndpoint` では、ユーザーは、Neptune ML エンドポイントを作成できます。
*アクショングループ:* 読み取り/書き込み。
*必要なリソース:* データベース。
## `neptune-db:GetMLDataProcessingJobStatus`
`GetMLDataProcessingJobStatus` では、ユーザーは、Neptune ML データ処理ジョブのステータスを確認できます。
*アクショングループ:* 読み取り専用、読み取り/書き込み。
*必要なリソース:* データベース。
## `neptune-db:GetMLModelTrainingJobStatus`
`GetMLModelTrainingJobStatus` では、ユーザーは、Neptune ML モデルトレーニングジョブのステータスを確認できます。
*アクショングループ:* 読み取り専用、読み取り/書き込み。
*必要なリソース:* データベース。
## `neptune-db:GetMLModelTransformJobStatus`
`GetMLModelTransformJobStatus` では、ユーザーは、Neptune ML モデル変換ジョブのステータスを確認できます。
*アクショングループ:* 読み取り専用、読み取り/書き込み。
*必要なリソース:* データベース。
## `neptune-db:GetMLEndpointStatus`
`GetMLEndpointStatus` では、ユーザーは、Neptune ML エンドポイントのステータスを確認できます。
*アクショングループ:* 読み取り専用、読み取り/書き込み。
*必要なリソース:* データベース。
## `neptune-db:ListMLDataProcessingJobs`
`ListMLDataProcessingJobs` では、ユーザーは、Neptune ML データ処理ジョブをすべて一覧表示できます。
*アクショングループ:* リスト専用、読み取り専用、読み取り/書き込み。
*必要なリソース:* データベース。
## `neptune-db:ListMLModelTrainingJobs`
`ListMLModelTrainingJobs` では、ユーザーは、Neptune ML モデルトレーニングジョブをすべて一覧表示できます。
*アクショングループ:* リスト専用、読み取り専用、読み取り/書き込み。
*必要なリソース:* データベース。
## `neptune-db:ListMLModelTransformJobs`
`ListMLModelTransformJobs` では、ユーザーは、すべての ML モデルの変換ジョブを一覧表示できます。
*アクショングループ:* リスト専用、読み取り専用、読み取り/書き込み。
*必要なリソース:* データベース。
## `neptune-db:ListMLEndpoints`
`ListMLEndpoints` では、ユーザーは、すべての Neptune ML エンドポイントを一覧表示できます。
*アクショングループ:* リスト専用、読み取り専用、読み取り/書き込み。
*必要なリソース:* データベース。
## `neptune-db:CancelMLDataProcessingJob`
`CancelMLDataProcessingJob` では、ユーザーは、Neptune ML データ処理ジョブをキャンセルできます。
*アクショングループ:* 読み取り/書き込み。
*必要なリソース:* データベース。
## `neptune-db:CancelMLModelTrainingJob`
`CancelMLModelTrainingJob` では、ユーザーは、Neptune ML モデルトレーニングジョブをキャンセルできます。
*アクショングループ:* 読み取り/書き込み。
*必要なリソース:* データベース。
## `neptune-db:CancelMLModelTransformJob`
`CancelMLModelTransformJob` では、ユーザーは、Neptune ML モデル変換ジョブをキャンセルできます。
*アクショングループ:* 読み取り/書き込み。
*必要なリソース:* データベース。
## `neptune-db:DeleteMLEndpoint`
`DeleteMLEndpoint` では、ユーザーは、Neptune ML エンドポイントを削除できます。
*アクショングループ:* 読み取り/書き込み。
*必要なリソース:* データベース。
# Amazon Neptune のデータにアクセスするための IAM リソースタイプ
データリソースには、データアクションと同様に、`neptune-db:` プレフィックスがあります。
Neptune データアクセスポリシーでは、アクセスを許可する DB クラスターを次の形式で ARN で指定します。
```
arn:aws:neptune-db:region:account-id:cluster-resource-id/*
```
このようなリソース ARN には次のパートが含まれます。
+ `region` は Amazon Neptune DB クラスターの AWS リージョンです。
+ `account-id` は DB クラスターの A AWS アカウント番号です。
+ `cluster-resource-id` は DB クラスターのリソース ID です。
**重要**
`cluster-resource-id` はクラスター識別子とは異なります。Neptune でクラスターリソース ID を検索するには AWS マネジメントコンソール、該当する DB クラスター**の設定**セクションを参照してください。
# Amazon Neptune のデータにアクセスするための IAM 条件キー
[条件キーを使用すると](security-iam-access-manage.md#iam-using-condition-keys)、IAM ポリシーステートメントで条件を指定して、条件が満たされた場合にのみステートメントが有効になるようにすることができます。
Neptune データアクセスポリシーステートメントで使用できる条件キーは、次のカテゴリに分類されます。
+ [グローバル条件キー](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_condition-keys.html) – Neptune がデータアクセスポリシーステートメントでサポートする AWS グローバル条件キーのサブセットを[以下](#iam-data-global-condition-keys)に示します。
+ [サービス固有の条件キー](#iam-neptune-condition-keys) — これらは Neptune がデータアクセスポリシーステートメントで使用するために特別に定義したキーです。現在は [neptune-db:QueryLanguage](#neptune-db-query-language) の 1 つだけであり、特定のクエリ言語が使用されている場合にのみアクセスを許可します。
## AWS データアクセスポリシーステートメントで Neptune がサポートするグローバル条件コンテキストキー
次の表は、Amazon Neptune がデータアクセスポリシーステートメントでの使用をサポートしている [AWS グローバル条件コンテキストキー](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_condition-keys.html)のサブセットを示しています。
**データアクセスポリシーステートメントで使用できるグローバル条件キー**
| 条件キー | 説明 | タイプ |
| --- | --- | --- |
| [https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_condition-keys.html#condition-keys-currenttime](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_condition-keys.html#condition-keys-currenttime) | リクエストの現在日時によってアクセスをフィルタリングします。 | String |
| [https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_condition-keys.html#condition-keys-epochtime](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_condition-keys.html#condition-keys-epochtime) | UNIX エポック値として表されるリクエストの日付と時刻によってアクセスをフィルタリングします。 | Numeric |
| [https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_condition-keys.html#condition-keys-principalaccount](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_condition-keys.html#condition-keys-principalaccount) | リクエスト元のプリンシパルが属するアカウントによってアクセスをフィルタリングします。 | String |
| [https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_condition-keys.html#condition-keys-principalarn](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_condition-keys.html#condition-keys-principalarn) | リクエストを実行したプリンシパルの ARN によってアクセスをフィルタリングします。 | String |
| [https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_condition-keys.html#condition-keys-principalisawsservice](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_condition-keys.html#condition-keys-principalisawsservice) | 呼び出しが AWS サービスプリンシパルによって直接行われている場合にのみアクセスを許可します。 | Boolean |
| [https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_condition-keys.html#condition-keys-principalorgid](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_condition-keys.html#condition-keys-principalorgid) | リクエスト元のプリンシパルが属する AWS Organizations 内の組織の識別子でアクセスをフィルタリングします。 | String |
| [https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_condition-keys.html#condition-keys-principalorgpaths](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_condition-keys.html#condition-keys-principalorgpaths) | リクエストを行うプリンシパルの AWS Organizations パスでアクセスをフィルタリングします。 | String |
| [https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_condition-keys.html#condition-keys-principaltag](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_condition-keys.html#condition-keys-principaltag) | リクエストを行っているプリンシパルに付けられたタグによってアクセスをフィルタリングします。 | String |
| [https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_condition-keys.html#condition-keys-principaltype](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_condition-keys.html#condition-keys-principaltype) | リクエストを行っているプリンシパルのタイプによってアクセスをフィルタリングします。 | String |
| [https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_condition-keys.html#condition-keys-requestedregion](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_condition-keys.html#condition-keys-requestedregion) | リクエストで呼び出された AWS リージョンでアクセスをフィルタリングします。 | String |
| [https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_condition-keys.html#condition-keys-securetransport](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_condition-keys.html#condition-keys-securetransport) | リクエストが SSL を使用して送信された場合にのみアクセスを許可します。 | Boolean |
| [https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_condition-keys.html#condition-keys-sourceip](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_condition-keys.html#condition-keys-sourceip) | リクエスタの IP アドレスによってアクセスをフィルタリングします。 | String |
| [https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_condition-keys.html#condition-keys-tokenissuetime](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_condition-keys.html#condition-keys-tokenissuetime) | 一時的セキュリティ認証情報が発行された日付と時刻によってアクセスをフィルタリングします。 | String |
| [https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_condition-keys.html#condition-keys-useragent](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_condition-keys.html#condition-keys-useragent) | リクエスタのクライアントアプリケーションによってアクセスをフィルタリングします。 | String |
| [https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_condition-keys.html#condition-keys-userid](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_condition-keys.html#condition-keys-userid) | リクエスタのプリンシパル識別子によってアクセスをフィルタリングします。 | String |
| [https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_condition-keys.html#condition-keys-viaawsservice](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_condition-keys.html#condition-keys-viaawsservice) | AWS サービスがユーザーに代わってリクエストを行った場合にのみアクセスを許可します。 | Boolean |
## Neptune サービス固有の条件キー
Neptune は IAM ポリシーについて、以下のサービス固有の条件キーをサポートします。
**Neptune サービス固有の条件キー**
| 条件キー | 説明 | タイプ |
| --- | --- | --- |
| neptune-db:QueryLanguage | 使用されているクエリ言語によってアクセスをフィルタリングします。 有効な値は、`Gremlin`、`OpenCypher`、`Sparql` です。 サポートされるアクションは、`ReadDataViaQuery`、`WriteDataViaQuery`、`DeleteDataViaQuery`、`GetQueryStatus`、および `CancelQuery` です。 | String |
# Amazon Neptune での IAM データアクセスポリシーの作成
以下の例は、Neptune [エンジンリリースバージョン 1.2.0.0](engine-releases-1.2.0.0.md) で導入された、データプレーン API とアクションのきめ細かいアクセスコントロールを使用するカスタム IAM ポリシーを作成する方法を示しています。
## Neptune DB クラスター内のデータへの無制限アクセスを許可するポリシーの例
次のサンプルポリシーは、IAM ユーザーが IAM データベース認証を使用して Neptune DB クラスターに接続し、「`*`」文字を使用して使用可能なすべてのアクションに一致するのを許可します。
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": "neptune-db:*",
"Resource": "arn:aws:neptune-db:us-east-1:123456789012:cluster-ABCD1234EFGH5678IJKL90MNOP/*"
}
]
}
```
------
上記のリソースセクションには、Neptune の IAM 認証に固有の形式であるリソース ARN が含まれます。ARN を作成するには、「[データリソースの指定](iam-data-resources.md)」を参照してください。IAM 承認 `Resource` に使用される ARN は、クラスターの作成時に割り当てられる ARN とは異なることに注意してください。
## Neptune DB クラスターへの読み取り専用アクセスを許可するポリシーの例
以下のポリシーは、Neptune DB クラスター内のデータへの完全な読み取り専用アクセスのためのアクセス許可を付与します。
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement":[
{
"Effect": "Allow",
"Action": [
"neptune-db:Read*",
"neptune-db:Get*",
"neptune-db:List*"
],
"Resource": "arn:aws:neptune-db:us-east-1:123456789012:cluster-ABCD1234EFGH5678IJKL90MNOP/*"
}
]
}
```
------
## Neptune DB クラスターへのすべてのアクセスを拒否するポリシーの例
デフォルトの IAM アクションでは、`Allow` *Effect* が付与されない限り、DB クラスターへのアクセスが拒否されます。ただし、次のポリシーでは、特定の AWS アカウントとリージョンの DB クラスターへのすべてのアクセスを拒否します。このアクセスは、`Allow`効果よりも優先されます。
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Deny",
"Action": "neptune-db:*",
"Resource": "arn:aws:neptune-db:us-east-1:123456789012:cluster-ABCD1234EFGH5678IJKL90MNOP/*"
}
]
}
```
------
## クエリを通じて読み取りアクセスを許可するポリシーの例
次のポリシーは、クエリを使用して Neptune DB クラスターから読み取るアクセス許可のみを付与します。
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": "neptune-db:ReadDataViaQuery",
"Resource": "arn:aws:neptune-db:us-east-1:123456789012:cluster-ABCD1234EFGH5678IJKL90MNOP/*"
}
]
}
```
------
## Gremlin クエリのみを許可するポリシーの例
次のポリシーは、`neptune-db:QueryLanguage` 条件キーを使用して、Gremlin クエリ言語のみを使用して Neptune をクエリするアクセス許可を付与します。
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"neptune-db:ReadDataViaQuery",
"neptune-db:WriteDataViaQuery",
"neptune-db:DeleteDataViaQuery"
],
"Resource": "*",
"Condition": {
"StringEquals": {
"neptune-db:QueryLanguage": "Gremlin"
}
}
}
]
}
```
------
## Neptune ML モデル管理を除くすべてのアクセスを許可するポリシーの例
次のポリシーは、Neptune ML モデル管理機能を除く Neptune グラフ操作へのフルアクセスを許可します。
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement":[
{
"Effect": "Allow",
"Action": [
"neptune-db:CancelLoaderJob",
"neptune-db:CancelQuery",
"neptune-db:DeleteDataViaQuery",
"neptune-db:DeleteStatistics",
"neptune-db:GetEngineStatus",
"neptune-db:GetLoaderJobStatus",
"neptune-db:GetQueryStatus",
"neptune-db:GetStatisticsStatus",
"neptune-db:GetStreamRecords",
"neptune-db:ListLoaderJobs",
"neptune-db:ManageStatistics",
"neptune-db:ReadDataViaQuery",
"neptune-db:ResetDatabase",
"neptune-db:StartLoaderJob",
"neptune-db:WriteDataViaQuery"
],
"Resource": "arn:aws:neptune-db:us-east-1:123456789012:cluster-ABCD1234EFGH5678IJKL90MNOP/*"
}
]
}
```
------
## Neptune ML モデル管理へのアクセスを許可するポリシーの例
このポリシーは、Neptune ML モデル管理機能へのアクセスを許可します。
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement":[
{
"Effect": "Allow",
"Action": [
"neptune-db:CancelMLDataProcessingJob",
"neptune-db:CancelMLModelTrainingJob",
"neptune-db:CancelMLModelTransformJob",
"neptune-db:CreateMLEndpoint",
"neptune-db:DeleteMLEndpoint",
"neptune-db:GetMLDataProcessingJobStatus",
"neptune-db:GetMLEndpointStatus",
"neptune-db:GetMLModelTrainingJobStatus",
"neptune-db:GetMLModelTransformJobStatus",
"neptune-db:ListMLDataProcessingJobs",
"neptune-db:ListMLEndpoints",
"neptune-db:ListMLModelTrainingJobs",
"neptune-db:ListMLModelTransformJobs",
"neptune-db:StartMLDataProcessingJob",
"neptune-db:StartMLModelTrainingJob",
"neptune-db:StartMLModelTransformJob"
],
"Resource": "arn:aws:neptune-db:us-east-1:123456789012:cluster-ABCD1234EFGH5678IJKL90MNOP/*"
}
]
}
```
------
## クエリのフルアクセスを許可するポリシーの例
次のポリシーは、Neptune グラフクエリ操作へのフルアクセスを許可しますが、高速リセット、ストリーム、バルクローダー、Neptune ML モデル管理などの機能へのアクセスは許可しません。
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement":[
{
"Effect": "Allow",
"Action": [
"neptune-db:ReadDataViaQuery",
"neptune-db:WriteDataViaQuery",
"neptune-db:DeleteDataViaQuery",
"neptune-db:GetEngineStatus",
"neptune-db:GetQueryStatus",
"neptune-db:CancelQuery"
],
"Resource": "arn:aws:neptune-db:us-east-1:123456789012:cluster-ABCD1234EFGH5678IJKL90MNOP/*"
}
]
}
```
------
## Gremlin クエリにのみフルアクセスを許可するポリシーの例
次のポリシーは、Gremlin クエリ言語を使用した Neptune グラフクエリ操作へのフルアクセスを許可しますが、他の言語でのアクセスや、高速リセット、ストリーム、バルクローダー、Neptune ML モデル管理などの機能へのアクセスは許可しません。
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement":[
{
"Effect": "Allow",
"Action": [
"neptune-db:ReadDataViaQuery",
"neptune-db:WriteDataViaQuery",
"neptune-db:DeleteDataViaQuery",
"neptune-db:GetEngineStatus",
"neptune-db:GetQueryStatus",
"neptune-db:CancelQuery"
],
"Resource": [
"arn:aws:neptune-db:us-east-1:123456789012:cluster-ABCD1234EFGH5678IJKL90MNOP/*"
],
"Condition": {
"StringEquals": {
"neptune-db:QueryLanguage":"Gremlin"
}
}
}
]
}
```
------
## 高速リセット以外のフルアクセスを許可するポリシーの例
次のポリシーは、高速リセットの使用を除き、Neptune DB クラスターへのフルアクセスを付与します。
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": "neptune-db:*",
"Resource": "arn:aws:neptune-db:us-east-1:123456789012:cluster-ABCD1234EFGH5678IJKL90MNOP/*"
},
{
"Effect": "Deny",
"Action": "neptune-db:ResetDatabase",
"Resource": "arn:aws:neptune-db:us-east-1:123456789012:cluster-ABCD1234EFGH5678IJKL90MNOP/*"
}
]
}
```
------
# Amazon Neptune のサービスにリンクされたロールの使用
Amazon Neptune は AWS Identity and Access Management (IAM)[ サービスにリンクされたロール](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_terms-and-concepts.html#iam-term-service-linked-role)を使用します。サービスにリンクされたロールは、Neptune に直接リンクされた一意のタイプの IAM ロールです サービスにリンクされたロールは Neptune によって事前定義されており、サービスがユーザーに代わって他の AWS サービスを呼び出すために必要なすべてのアクセス許可が含まれています。
**重要**
特定の管理機能のために、Amazon Neptune は Amazon RDS と共有される運用テクノロジーを使用します。これには、*サービスにリンクされたロール*と管理 API のアクセス権限が含まれます。
サービスにリンクされたロールを使用することで、必要なアクセス権限を手動で追加する必要がなくなるため、Neptune の使用が簡単になります。Neptune は、サービスにリンクされたロールのアクセス許可を定義します。特に定義されている場合を除き、Neptune のみがそのロールを引き受けることができます。定義されたアクセス許可には、信頼ポリシーとアクセス許可ポリシーが含まれ、そのアクセス許可ポリシーを他の IAM エンティティにアタッチすることはできません。
ロールを削除するには、まず関連リソースを削除します。これにより、リソースへの意図しないアクセスによるアクセス許可の削除が防止され、Neptune リソースは保護されます。
サービスにリンクされたロールをサポートする他のサービスの詳細については、[AWS 「IAM と連携するサービス](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_aws-services-that-work-with-iam.html)」を参照し、「サービス**にリンクされたロール**」列で**「はい**」を持つサービスを探します。サービスリンクロールに関するドキュメントをサービスで表示するには、リンクで **[はい]** を選択します。
## Neptune のサービスにリンクされたロールにおけるアクセス許可
Neptune は、`AWSServiceRoleForRDS`サービスにリンクされたロールを使用して、Neptune と Amazon RDS がデータベースインスタンスに代わって AWS サービスを呼び出すことを許可します。`AWSServiceRoleForRDS` サービスにリンクされたロールは、ロールを継承するために `rds.amazonaws.com` のサービスを信頼します。
ロールのアクセス許可ポリシーは、指定したリソースに対して以下のアクションを実行することを Neptune に許可します。
+ `ec2` でのアクション:
+ `AssignPrivateIpAddresses`
+ `AuthorizeSecurityGroupIngress`
+ `CreateNetworkInterface`
+ `CreateSecurityGroup`
+ `DeleteNetworkInterface`
+ `DeleteSecurityGroup`
+ `DescribeAvailabilityZones`
+ `DescribeInternetGateways`
+ `DescribeSecurityGroups`
+ `DescribeSubnets`
+ `DescribeVpcAttribute`
+ `DescribeVpcs`
+ `ModifyNetworkInterfaceAttribute`
+ `RevokeSecurityGroupIngress`
+ `UnassignPrivateIpAddresses`
+ `sns` でのアクション:
+ `ListTopic`
+ `Publish`
+ `cloudwatch` でのアクション:
+ `PutMetricData`
+ `GetMetricData`
+ `CreateLogStream`
+ `PullLogEvents`
+ `DescribeLogStreams`
+ `CreateLogGroup`
**注記**
サービスリンクロールの作成、編集、削除を IAM エンティティ (ユーザー、グループ、ロールなど) に許可するにはアクセス許可を設定する必要があります。次のエラーメッセージが返される場合があります。
リソースを作成できません。サービスにリンクされたロールを作成するために必要なアクセス許可があることを確認します。それ以外の場合は、時間をおいてからもう一度お試しください。
このメッセージが表示された場合は、次のアクセス許可が有効であることを確認します。
```
{
"Action": "iam:CreateServiceLinkedRole",
"Effect": "Allow",
"Resource": "arn:aws:iam::*:role/aws-service-role/rds.amazonaws.com/AWSServiceRoleForRDS",
"Condition": {
"StringLike": {
"iam:AWSServiceName":"rds.amazonaws.com"
}
}
}
```
詳細については、「*IAM ユーザーガイド*」の「[サービスリンクロールの許可](https://docs.aws.amazon.com/IAM/latest/UserGuide/using-service-linked-roles.html#service-linked-role-permissions)」を参照してください。
## Neptune 用に作成されたサービスリンクロール
サービスリンクロールを手動で作成する必要はありません。インスタンスまたはクラスターを作成すると、サービスにリンクされたロールが再度 Neptune で自動的に作成されます。
**重要**
詳細については、*IAM ユーザーガイド*の[IAM アカウントに新しいロールが表示される](https://docs.aws.amazon.com/IAM/latest/UserGuide/troubleshoot_roles.html#troubleshoot_roles_new-role-appeared)を参照してください。
サービスにリンクされたこのロールを削除したが、再作成する必要がある場合は、同じプロセスで、アカウントにロールを再作成することができます。インスタンスまたはクラスターを作成すると、サービスにリンクされたロールが再度 Neptune で自動的に作成されます。
## Neptune のサービスにリンクされたロールの編集
Neptune では、`AWSServiceRoleForRDS` のサービスにリンクされたロールを編集することはできません。サービスリンクロールの作成後は、さまざまなエンティティがロールを参照する可能性があるため、ロール名を変更することはできません。ただし、IAM を使用してロールの説明を編集することはできます。詳細については、「*IAM ユーザーガイド*」の「[サービスリンクロールの編集](https://docs.aws.amazon.com/IAM/latest/UserGuide/using-service-linked-roles.html#edit-service-linked-role)」を参照してください。
## Neptune でのサービスにリンクされたロールの削除
サービスリンクロールを必要とする機能やサービスが不要になった場合は、ロールを削除することをお勧めします。そうすることで、モニタリングや保守が積極的に行われていない未使用のエンティティを排除できます。ただし、関連付けられているサービスにリンクされたロールを削除する前に、すべてのインスタンスとクラスターを削除する必要があります。
### サービスにリンクされたロールを削除する前にクリーンアップする
IAM を使用してサービスにリンクされたロールを削除するには、まずそのロールにアクティブなセッションがないことを確認し、そのロールで使用されているリソースをすべて削除する必要があります。
**サービスにリンクされたロールにアクティブなセッションがあるかどうかを、IAM コンソールで確認するには**
1. にサインイン AWS マネジメントコンソール し、[https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/) で IAM コンソールを開きます。
1. IAM コンソールのナビゲーションペインで **[ロール]** を選択します。次に、`AWSServiceRoleForRDS` ロールの名前 (チェックボックスではありません) を選択します。
1. 選択したロールの [**概要**] ページで、[**アクセスアドバイザー**] タブを選択します。
1. **アクセスアドバイザー** タブで、サービスにリンクされたロールの最新のアクティビティを確認します。
**注記**
Neptune で `AWSServiceRoleForRDS` ロールが使用されているかどうかが不明な場合は、このロールの削除を試みることができます。サービスでロールが使用されている場合、削除は失敗し、ロールが使用されている リージョンが表示されます。ロールが使用されている場合は、ロールを削除する前にセッションが終了するのを待つ必要があります。サービスにリンクされたロールのセッションを取り消すことはできません。
`AWSServiceRoleForRDS` ロールを削除する場合、最初に*すべて*のインスタンスとクラスターを削除する必要があります。
#### すべてのインスタンスの削除
以下のいずれかの手順を使用して、インスタンスをそれぞれ削除します。
**インスタンスを削除するには (コンソール)**
1. Amazon RDS コンソール ([https://console.aws.amazon.com/rds/](https://console.aws.amazon.com/rds/)) を開きます。
1. ナビゲーションペインで、[**インスタンス**] を選択してください。
1. [**Instances**] リストで、削除するインスタンスを選択します。
1. **[インスタンスアクション]** を選択し、**[削除]** を選択します。
1. [**最終スナップショットを作成しますか?**] で、[**はい**] または [**いいえ**] を選択します。
1. 前のステップで [**はい**] を選択した場合は、[**最終スナップショット名**] に最終スナップショットの名前を入力します。
1. **[削除]** を選択します。
**インスタンスを削除するには (AWS CLI)**
*AWS CLI コマンドリファレンス* の「`[delete-db-instance](https://docs.aws.amazon.com/cli/latest/reference/neptune/delete-db-instance.html)`」を参照してください。
**インスタンスを削除するには (API)**
「`[DeleteDBInstance](&doc-domaiAPI_DeleteDBInstance.html)`」を参照してください。
#### すべての クラスターの削除
次のいずれかの手順を使用して単一のクラスターを削除してから、各クラスターに対してこの手順を繰り返します。
**クラスターを削除するには (コンソール)**
1. AWS マネジメントコンソールにサインインし、[https://console.aws.amazon.com/neptune/home](https://console.aws.amazon.com/neptune/home) で Amazon Neptune コンソールを開きます。
1. [**Clusters**] リストで、削除するクラスターを選択します。
1. [**Cluster Actions**] を選択してから、[**Delete**] を選択します。
1. **[削除]** を選択します。
**クラスターを削除するには (CLI)**
*AWS CLI コマンドリファレンス* の「`[delete-db-cluster](https://docs.aws.amazon.com/cli/latest/reference/neptune/delete-db-cluster.html)`」を参照してください。
**クラスターを削除するには (API)**
`[DeleteDBCluster](API_DeleteDBCluster.html)` を参照してください。
`AWSServiceRoleForRDS` サービスにリンクされたロールは、IAM コンソール、IAM CLI、または IAM API を使用して削除することができます。詳細については、「[IAM ユーザーガイド](https://docs.aws.amazon.com/IAM/latest/UserGuide/using-service-linked-roles.html#delete-service-linked-role)」の「*サービスリンクロールの削除*」を参照してください。
# 一時認証情報を使用した Amazon Neptune への接続
Amazon Neptune は一時的な認証情報を使用した IAM 認証をサポートしています。
前のセクションのポリシー例などの IAM 認証ポリシーを使用して認証するために、引き受けたロールを使用できます。
一時的なセキュリティ認証情報を使用している場合は、`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)」を参照してください。
以下のセクションでは、一時的な認証情報のアクセスを許可する方法と取得方法について説明します。
**一時的な認証情報を使用して認証するには**
1. Neptune クラスターにアクセスする権限を持つ IAM ロールを作成します。このロールの作成の詳細については、「[Neptune へのアクセスを制御するためのさまざまな種類の IAM ポリシーの使用](security-iam-access-manage.md#iam-auth-policy)」を参照してください。
1. 認証情報へのアクセスを許可するロールに信頼関係を追加します。
`AWS_ACCESS_KEY_ID`、`AWS_SECRET_ACCESS_KEY`、`AWS_SESSION_TOKEN` を含む一時的な認証情報を取得します。
1. Neptune クラスターに接続し、一時的な認証情報を使用してリクエストに署名します。リクエストへの接続と署名の詳細については、「[AWS Identity and Access Management 認証を使用した Amazon Neptune データベースへの接続](iam-auth-connecting.md)」を参照してください。
一時的な認証情報を取得する方法は、環境に応じてさまざまです。
**Topics**
+ [を使用した一時的な認証情報の取得 AWS CLI](#iam-auth-temporary-credentials-cli)
+ [Neptune IAM 認証用の AWS Lambda のセットアップ](#iam-auth-temporary-credentials-lambda)
+ [Neptune IAM 認証用の Amazon EC2 のセットアップ](#iam-auth-temporary-credentials-ec2)
## を使用した一時的な認証情報の取得 AWS CLI
AWS Command Line Interface (AWS CLI) を使用して認証情報を取得するには、まず、 AWS CLI コマンドを実行する AWS ユーザーにロールを引き受けるアクセス許可を付与する信頼関係を追加する必要があります。
Neptune IAM 認証ロールに次の信頼関係を追加します。Neptune IAM 認証ロールがない場合は、[Neptune へのアクセスを制御するためのさまざまな種類の IAM ポリシーの使用](security-iam-access-manage.md#iam-auth-policy) を参照してください。
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Principal": {
"AWS": "arn:aws:iam::123456789012:user/test"
},
"Action": "sts:AssumeRole"
}
]
}
```
------
ロールに信頼関係を追加する方法の詳細については、*AWS Directory Service 管理ガイド*の[既存のロールの信頼関係の編集](https://docs.aws.amazon.com/directoryservice/latest/admin-guide/edit_trust.html)を参照してください。
まだ Neptune ポリシーがロールにアタッチされていない場合は、新しいロールを作成します。Neptune IAM 認証ポリシーをアタッチし、その後信頼ポリシーを追加します。新しいロールの作成の詳細については、「[新しいロールの作成](https://docs.aws.amazon.com/directoryservice/latest/admin-guide/create_role.html)」を参照してください。
**注記**
以下のセクションでは、 AWS CLI がインストールされていることを前提としています。
**AWS CLI を手動で実行するには**
1. AWS CLIを使用して認証情報をリクエストするには、次のコマンドを入力します。ロール ARN、セッション名、プロフィールを独自の値に置き換えます。
```
aws sts assume-role --role-arn arn:aws:iam::123456789012:role/NeptuneIAMAuthRole --role-session-name test --profile testprofile
```
1. コマンドからの出力例を次に示します。`Credentials` セクションには、必要な値が含まれます。
**注記**
これ以降に新しい認証情報を取得する必要があるため、`Expiration` 値を記録します。
```
{
"AssumedRoleUser": {
"AssumedRoleId": "AROA3XFRBF535PLBIFPI4:s3-access-example",
"Arn": "arn:aws:sts::123456789012:assumed-role/xaccounts3access/s3-access-example"
},
"Credentials": {
"SecretAccessKey": "9drTJvcXLB89EXAMPLELB8923FB892xMFI",
"SessionToken": "AQoXdzELDDY//////////wEaoAK1wvxJY12r2IrDFT2IvAzTCn3zHoZ7YNtpiQLF0MqZye/qwjzP2iEXAMPLEbw/m3hsj8VBTkPORGvr9jM5sgP+w9IZWZnU+LWhmg+a5fDi2oTGUYcdg9uexQ4mtCHIHfi4citgqZTgco40Yqr4lIlo4V2b2Dyauk0eYFNebHtYlFVgAUj+7Indz3LU0aTWk1WKIjHmmMCIoTkyYp/k7kUG7moeEYKSitwQIi6Gjn+nyzM+PtoA3685ixzv0R7i5rjQi0YE0lf1oeie3bDiNHncmzosRM6SFiPzSvp6h/32xQuZsjcypmwsPSDtTPYcs0+YN/8BRi2/IcrxSpnWEXAMPLEXSDFTAQAM6Dl9zR0tXoybnlrZIwMLlMi1Kcgo5OytwU=",
"Expiration": "2016-03-15T00:05:07Z",
"AccessKeyId": "ASIAJEXAMPLEXEG2JICEA"
}
}
```
1. 返された認証情報を使用して環境変数を設定します。
```
export AWS_ACCESS_KEY_ID=ASIAJEXAMPLEXEG2JICEA
export AWS_SECRET_ACCESS_KEY=9drTJvcXLB89EXAMPLELB8923FB892xMFI
export AWS_SESSION_TOKEN=AQoXdzELDDY//////////wEaoAK1wvxJY12r2IrDFT2IvAzTCn3zHoZ7YNtpiQLF0MqZye/qwjzP2iEXAMPLEbw/m3hsj8VBTkPORGvr9jM5sgP+w9IZWZnU+LWhmg+a5fDi2oTGUYcdg9uexQ4mtCHIHfi4citgqZTgco40Yqr4lIlo4V2b2Dyauk0eYFNebHtYlFVgAUj+7Indz3LU0aTWk1WKIjHmmMCIoTkyYp/k7kUG7moeEYKSitwQIi6Gjn+nyzM+PtoA3685ixzv0R7i5rjQi0YE0lf1oeie3bDiNHncmzosRM6SFiPzSvp6h/32xQuZsjcypmwsPSDtTPYcs0+YN/8BRi2/IcrxSpnWEXAMPLEXSDFTAQAM6Dl9zR0tXoybnlrZIwMLlMi1Kcgo5OytwU=
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
```
1. 以下のいずれかの方法を使用して接続します。
+ [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)
+ [Python による IAM 認証を使用した Amazon Neptune データベースへの接続](iam-auth-connecting-python.md)
**スクリプトを使用して認証情報を取得する**
1. 以下のコマンドを実行して、**jq** コマンドをインストールします。スクリプトはこのコマンドを使用して、 AWS CLI コマンドの出力を解析します。
```
sudo yum -y install jq
```
1. テキストエディターで `credentials.sh` という名前のファイルを作成して、次のテキストを追加します。サービスリージョン、ロール ARN、セッション名、プロフィールを独自の値に置き換えます。
```
#!/bin/bash
creds_json=$(aws sts assume-role --role-arn arn:aws:iam::123456789012:role/NeptuneIAMAuthRole --role-session-name test --profile testprofile)
export AWS_ACCESS_KEY_ID=$(echo "$creds_json" | jq .Credentials.AccessKeyId |tr -d '"')
export AWS_SECRET_ACCESS_KEY=$(echo "$creds_json" | jq .Credentials.SecretAccessKey| tr -d '"')
export AWS_SESSION_TOKEN=$(echo "$creds_json" | jq .Credentials.SessionToken|tr -d '"')
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
```
1. 以下のいずれかの方法を使用して接続します。
+ [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)
+ [Python による IAM 認証を使用した Amazon Neptune データベースへの接続](iam-auth-connecting-python.md)
## Neptune IAM 認証用の AWS Lambda のセットアップ
AWS Lambda には、Lambda 関数が実行されるたびに自動的に認証情報が含まれます。
最初に Lambda サービスにロールを引き受けるアクセス権限を与える信頼関係を追加します。
Neptune IAM 認証ロールに次の信頼関係を追加します。Neptune IAM 認証ロールがない場合は、[Neptune へのアクセスを制御するためのさまざまな種類の IAM ポリシーの使用](security-iam-access-manage.md#iam-auth-policy) を参照してください。
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Sid": "",
"Effect": "Allow",
"Principal": {
"Service": "lambda.amazonaws.com"
},
"Action": "sts:AssumeRole"
}
]
}
```
------
ロールに信頼関係を追加する方法の詳細については、*AWS Directory Service管理ガイド*の[既存のロールの信頼関係の編集](https://docs.aws.amazon.com/directoryservice/latest/admin-guide/edit_trust.html)を参照してください。
まだ Neptune ポリシーがロールにアタッチされていない場合は、新しいロールを作成します。Neptune IAM 認証ポリシーをアタッチし、その後信頼ポリシーを追加します。新しいロールの作成の詳細については、*AWS Directory Service 管理ガイド*の[新しいロールの作成](https://docs.aws.amazon.com/directoryservice/latest/admin-guide/create_role.html)を参照してください。
**Lambda から Neptune にアクセスするには**
1. にサインイン AWS マネジメントコンソール し、[https://console.aws.amazon.com/lambda/](https://console.aws.amazon.com/lambda/) で AWS Lambda コンソールを開きます。
1. Python バージョン 3.6 用に新しい Lambda 関数を作成します。
1. Lambda 関数に `AWSLambdaVPCAccessExecutionRole` ロールを割り当てます。これは、VPC のみの Neptune リソースにアクセスするために必要です。
1. Lambda 関数に Neptune 認証 IAM ロールを割り当てます。
詳細については、*AWS Lambda デベロッパーガイド*の[AWS Lambda 関数のエラー](https://docs.aws.amazon.com/lambda/latest/dg/intro-permission-model.html)を参照してください。
1. IAM 認証の Python サンプルを Lambda 関数コードにコピーします。
サンプルおよびサンプルコードの詳細については、「[Python による IAM 認証を使用した Amazon Neptune データベースへの接続](iam-auth-connecting-python.md)」を参照してください。
## Neptune IAM 認証用の Amazon EC2 のセットアップ
Amazon EC2 ではインスタンスプロファイルを使用して、認証情報を自動的に提供することができます。詳細については、*IAM ユーザーガイド*の[インスタンスプロファイルの使用](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_use_switch-role-ec2_instance-profiles.html)を参照してください。
最初に Amazon EC2 サービスにロールを引き受けるアクセス権限を与える信頼関係を追加します。
Neptune IAM 認証ロールに次の信頼関係を追加します。Neptune IAM 認証ロールがない場合は、[Neptune へのアクセスを制御するためのさまざまな種類の IAM ポリシーの使用](security-iam-access-manage.md#iam-auth-policy) を参照してください。
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Sid": "",
"Effect": "Allow",
"Principal": {
"Service": "ec2.amazonaws.com"
},
"Action": "sts:AssumeRole"
}
]
}
```
------
ロールに信頼関係を追加する方法の詳細については、*AWS Directory Service 管理ガイド*の[既存のロールの信頼関係の編集](https://docs.aws.amazon.com/directoryservice/latest/admin-guide/edit_trust.html)を参照してください。
まだ Neptune ポリシーがロールにアタッチされていない場合は、新しいロールを作成します。Neptune IAM 認証ポリシーをアタッチし、その後信頼ポリシーを追加します。新しいロールの作成の詳細については、*AWS Directory Service 管理ガイド*の[新しいロールの作成](https://docs.aws.amazon.com/directoryservice/latest/admin-guide/create_role.html)を参照してください。
**スクリプトを使用して認証情報を取得する**
1. 以下のコマンドを実行して、**jq** コマンドをインストールします。スクリプトはこのコマンドを使用して、**curl** コマンドの出力を解析します。
```
sudo yum -y install jq
```
1. テキストエディターで `credentials.sh` という名前のファイルを作成して、次のテキストを追加します。サービスリージョンを独自の値に置き換えます。
```
TOKEN=$( curl -X PUT "http://169.254.169.254/latest/api/token" -H "X-aws-ec2-metadata-token-ttl-seconds: 21600" )
role_name=$( curl -H "X-aws-ec2-metadata-token: $TOKEN" http://169.254.169.254/latest/meta-data/iam/security-credentials/ )
creds_json=$( curl -H "X-aws-ec2-metadata-token: $TOKEN" http://169.254.169.254/latest/meta-data/iam/security-credentials/${role_name} )
export AWS_ACCESS_KEY_ID=$(echo "$creds_json" | jq .AccessKeyId |tr -d '"')
export AWS_SECRET_ACCESS_KEY=$(echo "$creds_json" | jq .SecretAccessKey| tr -d '"')
export AWS_SESSION_TOKEN=$(echo "$creds_json" | jq .Token|tr -d '"')
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
```
1. `source` コマンドを使用して、`bash` シェルでスクリプトを実行します。
```
source credentials.sh
```
さらに良い方法は、このスクリプトのコマンドを EC2 インスタンス上の `.bashrc` ファイルに追加して、ログイン時に自動的に呼び出されるようにします。これにより、一時的な認証情報が Gremlin コンソールで使用できるようになります。
1. 以下のいずれかの方法を使用して接続します。
+ [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)
+ [Python による IAM 認証を使用した Amazon Neptune データベースへの接続](iam-auth-connecting-python.md)
# Amazon Neptune での使用状況とパフォーマンスのログ記録およびモニタリング
Amazon Neptune では、パフォーマンスと使用状況をモニタリングするためのさまざまな方法をサポートしています。
+ **クラスターのステータス** – クラスターのグラフデータベースエンジンの正常性をチェックします。詳細については、「[Neptune インスタンスのヘルスステータスをチェックする](access-graph-status.md)」を参照してください。
+ **Amazon CloudWatch** — Neptune はメトリクスを自動的に送信し、CloudWatch アラームもサポートしています。詳細については、「[Amazon CloudWatch を使用した Neptune のモニタリング](cloudwatch.md)」を参照してください。
+ **監査ログファイル** – Neptune コンソールを使用して、データベースログファイルを表示、ダウンロード、調査します。詳細については、「[Amazon Neptune クラスターで監査ログを使用する](auditing.md)」を参照してください。
+ **Amazon CloudWatch Logsにログを発行する** – 監査ログを Amazon CloudWatch Logs のロググループに発行するように Neptune DB クラスターを設定することができます。CloudWatch Logs を使用すると、ログデータのリアルタイム分析、CloudWatch を使用したアラームの作成およびメトリクスの表示、CloudWatch Logs を使用した、耐久性に優れたストレージへのログレコードの保存を行うことができます。詳細については、「[Neptune CloudWatch Logs](cloudwatch-logs.md)」を参照してください。
+ **AWS CloudTrail**— Neptune は CloudTrail を使用して API ログ作成をサポートしています。詳細については、「[を使用した Amazon Neptune API コールのログ記録 AWS CloudTrail](cloudtrail.md)」を参照してください。
+ **タグ付け** – タグを使用してメタデータを Neptune リソースに追加し、タグに基づいて使用量を追跡します。詳細については、「[Amazon Neptune リソースのタグ付け](tagging.md)」を参照してください。
# Amazon Neptune とインターフェイス VPC エンドポイント (AWS PrivateLink)
[AWS PrivateLink](https://aws.amazon.com/privatelink/) を使用して、VPC と Amazon Neptune API エンドポイント間にプライベート接続を作成できます。インターネットゲートウェイ、NAT デバイス、VPN 接続、または 接続を使用せずに、VPC 内にあるかのように Amazon Neptune API オペレーションにアクセスできます。VPC と Amazon Neptune 間のトラフィックは Amazon ネットワーク内にとどまります。
Amazon Neptune はAmazon Relational Database Service と API インフラストラクチャを共有します。Amazon Neptune のインターフェイス VPC エンドポイントを設定するには、「Amazon *Aurora ユーザーガイド*」の[「Amazon RDS API とインターフェイス VPC エンドポイント (AWS PrivateLink)](https://docs.aws.amazon.com/AmazonRDS/latest/AuroraUserGuide/vpc-interface-endpoints.html)」の手順に従います。
# Amazon Neptune のコンプライアンスに関する考慮事項
AWS のサービス が特定のコンプライアンスプログラムの範囲内にあるかどうかを確認するには、[AWS のサービス 「コンプライアンスプログラムによる対象範囲内](https://aws.amazon.com/compliance/services-in-scope/)」の「コンプライアンス」を参照して、関心のあるコンプライアンスプログラムを選択します。一般的な情報については、[AWS 「コンプライアンスプログラム](https://aws.amazon.com/compliance/programs/)」を参照してください。
を使用して、サードパーティーの監査レポートをダウンロードできます AWS Artifact。詳細については、[「Downloading Reports in AWS Artifact](https://docs.aws.amazon.com/artifact/latest/ug/downloading-documents.html)」を参照してください。
を使用する際のお客様のコンプライアンス責任 AWS のサービス は、お客様のデータの機密性、貴社のコンプライアンス目的、適用される法律および規制によって決まります。を使用する際のコンプライアンス責任の詳細については AWS のサービス、[AWS 「 セキュリティドキュメント](https://docs.aws.amazon.com/security/)」を参照してください。
# 回復力と耐障害性に優れた Amazon Neptune デプロイの構築
AWS グローバルインフラストラクチャは、 AWS リージョンとアベイラビリティーゾーンを中心に構築されています。 AWS リージョンは、低レイテンシー、高スループット、高度に冗長なネットワークで接続された、物理的に分離された複数のアベイラビリティーゾーンを提供します。アベイラビリティーゾーンでは、アベイラビリティーゾーン間で中断せずに、自動的にフェイルオーバーするアプリケーションとデータベースを設計および運用することができます。アベイラビリティーゾーンは、従来の単一または複数のデータセンターインフラストラクチャよりも可用性、耐障害性、およびスケーラビリティが優れています。
Amazon Neptune DB クラスターは、最低 2 つのアベイラビリティーゾーンに最低 2 つのサブネットがある Amazon VPC 内にのみ作成できます。少なくとも 2 つのアベイラビリティーゾーンにまたがってクラスターインスタンスを配布することで、万一アベイラビリティーゾーンに障害が発生した場合でも、Neptune では、DB クラスター内でインスタンスを使用できます。Neptune DB クラスターのクラスターボリュームは、データ損失の可能性が少ない耐久性のあるストレージを提供するために、常に 3 つのアベイラビリティーゾーンにまたがっています。
AWS リージョンとアベイラビリティーゾーンの詳細については、[AWS 「 グローバルインフラストラクチャ](https://aws.amazon.com/about-aws/global-infrastructure/)」を参照してください。