Terjemahan disediakan oleh mesin penerjemah. Jika konten terjemahan yang diberikan bertentangan dengan versi bahasa Inggris aslinya, utamakan versi bahasa Inggris.
# Menghubungkan ke database Amazon Neptunus Anda menggunakan otentikasi AWS Identity and Access Management
Sumber daya Amazon Neptunus yang mengaktifkan autentikasi IAM DB memerlukan semua permintaan HTTP ditandatangani menggunakan Signature Version 4. AWS Untuk informasi umum tentang penandatanganan permintaan dengan AWS Signature Versi 4, lihat [Menandatangani permintaan AWS API](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_aws-signing.html).
AWS Signature Version 4 adalah proses untuk menambahkan informasi otentikasi ke AWS permintaan. Untuk keamanan, sebagian besar permintaan AWS harus ditandatangani dengan kunci akses, yang terdiri dari ID kunci akses dan kunci akses rahasia.
**catatan**
Jika Anda menggunakan kredensial sementara, kredensial kedaluwarsa setelah interval tertentu, *termasuk token sesinya*.
Anda harus memperbarui token sesi Anda ketika Anda meminta kredensial baru. Untuk informasi selengkapnya, lihat [Menggunakan Kredensil Keamanan Sementara untuk Meminta Akses ke AWS Sumber Daya](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_temp_use-resources.html).
**penting**
Mengakses Neptune dengan autentikasi berbasis IAM mengharuskan Anda membuat permintaan HTTP dan menandatangani permintaan itu sendiri.
**Cara Kerja Tanda Tangan Version 4**
1. Anda membuat permintaan kanonik.
1. Anda menggunakan permintaan kanonik dan beberapa informasi lainnya untuk membuat. string-to-sign
1. Anda menggunakan kunci akses AWS rahasia Anda untuk mendapatkan kunci penandatanganan, dan kemudian menggunakan kunci penandatanganan itu dan string-to-sign untuk membuat tanda tangan.
1. Anda menambahkan tanda tangan yang dihasilkan untuk permintaan HTTP di header atau sebagai parameter string kueri.
Ketika Neptune menerima permintaan, ia melakukan langkah yang sama seperti yang Anda lakukan untuk menghitung tanda tangan. Neptune kemudian membandingkan tanda tangan yang dihitung dengan yang Anda kirim bersama permintaan. Jika tanda tangan cocok, permintaan diproses. Jika tanda tangan tidak cocok, permintaan ditolak.
Untuk informasi umum tentang penandatanganan permintaan dengan AWS Tanda Tangan Versi 4, lihat [Proses Penandatanganan Versi Tanda Tangan 4](https://docs.aws.amazon.com/general/latest/gr/signature-version-4.html) di *Referensi Umum AWS*.
Bagian berikut berisi contoh yang menunjukkan cara mengirim permintaan yang ditandatangani ke titik akhir Gremlin dan SPARQL dari instans DB Neptune dengan autentikasi IAM diaktifkan.
**Topics**
+ [Prasyarat untuk menghubungkan database Amazon Neptunus menggunakan otentikasi IAM](iam-auth-connect-prerq.md)
+ [Menghubungkan ke database Amazon Neptunus menggunakan otentikasi IAM dari baris perintah](iam-auth-connect-command-line.md)
+ [Menghubungkan ke database Amazon Neptunus menggunakan otentikasi IAM dengan konsol Gremlin](iam-auth-connecting-gremlin-console.md)
+ [Menghubungkan ke database Amazon Neptunus menggunakan IAM dengan Gremlin Java](iam-auth-connecting-gremlin-java.md)
+ [Menghubungkan ke database Amazon Neptunus menggunakan otentikasi IAM dengan Java dan SPARQL](iam-auth-connecting-sparql-java.md)
+ [Menghubungkan ke database Amazon Neptunus menggunakan otentikasi IAM dengan SPARQL dan Node.js](iam-auth-connecting-sparql-node.md)
+ [Menghubungkan ke database Amazon Neptunus menggunakan otentikasi IAM dengan Python](iam-auth-connecting-python.md)
+ [Menghubungkan ke database Amazon Neptunus menggunakan otentikasi IAM dengan Python Gremlin](gremlin-python-iam-auth.md)
+ [Menghubungkan ke database Amazon Neptunus menggunakan otentikasi IAM dengan Gremlin JavaScript](gremlin-javascript-iam-auth.md)
+ [Menghubungkan ke database Amazon Neptunus menggunakan otentikasi IAM dengan Gremlin Go](gremlin-go-iam-auth.md)
+ [Menghubungkan ke database Amazon Neptunus menggunakan otentikasi IAM dengan Gremlin.NET](gremlin-dotnet-iam-auth.md)
# Prasyarat untuk menghubungkan database Amazon Neptunus menggunakan otentikasi IAM
Berikut ini adalah petunjuk untuk menginstal Apache Maven dan Java 8 pada instans Amazon EC2. Ini diperlukan untuk sampel autentikasi Amazon Neptune Signature Versi 4.
**Untuk menginstal Apache Maven dan Java 8 pada instans EC2 Anda**
1. Hubungkan ke instans Amazon EC2 dengan klien SSH.
1. Install Apache Maven di instans EC2 Anda. Jika menggunakan Amazon Linux 2023 (lebih disukai), gunakan:
```
sudo dnf update -y
sudo dnf install maven -y
```
Jika menggunakan Amazon Linux 2, unduh biner terbaru dari [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. Pustaka Gremlin membutuhkan Java 8. Masukkan hal berikut ini untuk menginstal Java 8 pada instans EC2 Anda.
```
sudo yum install java-1.8.0-devel
```
1. Masukkan hal berikut untuk mengatur Java 8 sebagai runtime default pada instans EC2 Anda.
```
sudo /usr/sbin/alternatives --config java
```
Saat diminta, masukkan nomor untuk Java 8.
1. Masukkan hal berikut untuk mengatur Java 8 sebagai compiler default pada instans EC2 Anda.
```
sudo /usr/sbin/alternatives --config javac
```
Saat diminta, masukkan nomor untuk Java 8.
# Menghubungkan ke database Amazon Neptunus menggunakan otentikasi IAM dari baris perintah
Memiliki alat baris perintah untuk mengirimkan kueri ke cluster DB Neptunus Anda sangat berguna, seperti yang diilustrasikan dalam banyak contoh dalam dokumentasi ini. Alat [curl](https://curl.haxx.se/) adalah opsi yang sangat baik untuk berkomunikasi dengan titik akhir Neptunus jika otentikasi IAM tidak diaktifkan.
**Namun, untuk menjaga keamanan data Anda, yang terbaik adalah mengaktifkan otentikasi IAM.**
Ketika autentikasi IAM diaktifkan, setiap permintaan harus [ditandatangani menggunakan Signature Version 4 (Sig4)](https://docs.aws.amazon.com/general/latest/gr/signing-aws-api-requests.html). Alat baris perintah [awscurl](https://github.com/okigan/awscurl) pihak ketiga menggunakan sintaks yang sama seperti, dan dapat menandatangani kueri menggunakan `curl` penandatanganan Sig4. [Menggunakan `awscurl`](#iam-auth-connect-awscurl)Bagian di bawah ini menjelaskan cara menggunakan `awscurl` secara aman dengan kredensil sementara.
## Menyiapkan alat baris perintah untuk menggunakan HTTPS
Neptunus mengharuskan semua koneksi menggunakan HTTPS. Alat baris perintah apa pun seperti `curl` atau `awscurl` memerlukan akses ke sertifikat yang sesuai untuk menggunakan HTTPS. Selama `curl` atau `awscurl` dapat menemukan sertifikat yang sesuai, mereka menangani koneksi HTTPS seperti koneksi HTTP, tanpa memerlukan parameter tambahan. Contoh dalam dokumentasi ini didasarkan pada skenario tersebut.
Untuk mempelajari cara mendapatkan sertifikat tersebut dan cara memformatnya dengan benar ke dalam penyimpanan sertifikat otoritas sertifikat (CA) yang `curl` dapat digunakan, lihat [Verifikasi Sertifikat SSL](https://curl.haxx.se/docs/sslcerts.html) dalam `curl` dokumentasi.
Anda kemudian dapat menentukan lokasi penyimpanan sertifikat CA ini menggunakan variabel lingkungan `CURL_CA_BUNDLE`. Pada Windows, `curl` secara otomatis mencarinya dalam sebuah file bernama `curl-ca-bundle.crt`. Ia pertama mencari dalam direktori yang sama dengan `curl.exe` dan kemudian di tempat lain di jalurnya. Untuk informasi lebih lanjut, lihat [Verifikasi Sertifikat SSL](https://curl.haxx.se/docs/sslcerts.html).
## Menggunakan `awscurl` dengan kredensyal sementara untuk terhubung dengan aman ke cluster DB dengan otentikasi IAM diaktifkan
Alat [awscurl](https://github.com/okigan/awscurl) menggunakan sintaks yang sama seperti`curl`, tetapi membutuhkan informasi tambahan juga:
+ **`--access_key`**— Kunci akses yang valid. Jika tidak disediakan menggunakan parameter ini, itu harus disediakan dalam variabel `AWS_ACCESS_KEY_ID` lingkungan, atau dalam file konfigurasi.
+ **`--secret_key`**— Kunci rahasia yang valid sesuai dengan kunci akses. Jika tidak disediakan menggunakan parameter ini, itu harus disediakan dalam variabel `AWS_SECRET_ACCESS_KEY` lingkungan, atau dalam file konfigurasi.
+ **`--security_token`**— Token sesi yang valid. Jika tidak disediakan menggunakan parameter ini, itu harus disediakan dalam variabel `AWS_SECURITY_TOKEN` lingkungan, atau dalam file konfigurasi.
Di masa lalu, itu adalah praktik umum untuk menggunakan kredensil persisten dengan`awscurl`, seperti kredensil pengguna IAM atau bahkan kredensil root, tetapi ini tidak disarankan. [Sebagai gantinya, buat kredensyal sementara menggunakan salah satu [AWS Security Token Service (STS) APIs](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_temp_request.html), atau salah satu pembungkusnya AWS CLI .](https://docs.aws.amazon.com/cli/latest/reference/sts/index.html)
Yang terbaik adalah menempatkan`AccessKeyId`,`SecretAccessKey`, dan `SessionToken` nilai yang dikembalikan oleh panggilan STS ke variabel lingkungan yang sesuai di sesi shell Anda daripada ke dalam file konfigurasi. Kemudian, ketika shell berakhir, kredensyal secara otomatis dibuang, yang tidak terjadi dengan file konfigurasi. Demikian pula, jangan meminta durasi yang lebih lama untuk kredensyal sementara daripada yang mungkin Anda butuhkan.
Contoh berikut menunjukkan langkah-langkah yang mungkin Anda ambil dalam shell Linux untuk mendapatkan kredensyal sementara yang baik selama setengah jam menggunakan [sts assume-role](https://docs.aws.amazon.com/cli/latest/reference/sts/assume-role), dan kemudian menempatkannya dalam variabel lingkungan di mana dapat menemukannya: `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
```
Anda kemudian dapat menggunakan `awscurl` untuk membuat permintaan yang ditandatangani ke cluster DB Anda seperti ini:
```
awscurl (your cluster endpoint):8182/status \
--region us-east-1 \
--service neptune-db
```
# Menghubungkan ke database Amazon Neptunus menggunakan otentikasi IAM dengan konsol Gremlin
Untuk menyambung ke Amazon Neptunus menggunakan konsol Gremlin dengan otentikasi Signature Version 4, Anda `requestInterceptor()` gunakan untuk menyambungkan tanda tangan SiGv4 ke sambungan yang dibuat oleh perintah. `:remote` Ini mengharuskan Anda untuk mengkonfigurasi `Cluster` objek secara manual dan kemudian meneruskannya ke `:remote` perintah.
Perhatikan bahwa ini sangat berbeda dari situasi khas di mana `:remote` perintah mengambil file konfigurasi untuk membentuk koneksi. Pendekatan file konfigurasi tidak akan berfungsi karena `requestInterceptor()` harus diatur secara terprogram, dan tidak dapat memuat konfigurasinya dari file.
**catatan**
Contoh berikut digunakan`requestInterceptor()`, yang diperkenalkan di TinkerPop 3.6.6. Jika Anda menggunakan TinkerPop versi lebih awal dari 3.6.6 (tetapi 3.5.5 atau lebih tinggi), gunakan `handshakeInterceptor()` alih-alih `requestInterceptor()` dalam contoh kode di bawah ini.
Prasyarat berikut diperlukan:
+ Anda harus memiliki kredensyal IAM yang diperlukan untuk menandatangani permintaan. Lihat [Menggunakan rantai penyedia kredensi default](https://docs.aws.amazon.com//sdk-for-java/latest/developer-guide/credentials-chain.html) di Panduan AWS SDK untuk Java Pengembang.
+ Anda harus menginstal versi konsol Gremlin yang kompatibel dengan versi mesin Neptunus yang digunakan oleh cluster DB Anda.
Jika Anda menggunakan kredensil sementara, kredensil tersebut akan kedaluwarsa setelah interval tertentu, seperti halnya token sesi, jadi Anda harus memperbarui token sesi saat Anda meminta kredensil baru. Lihat [Menggunakan kredensil keamanan sementara untuk meminta akses ke AWS sumber daya](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_temp_use-resources.html) di Panduan Pengguna IAM.
Untuk bantuan menghubungkan menggunakan SSL/TLS, lihat. [Konfigurasi SSL/TLS](access-graph-gremlin-java.md#access-graph-gremlin-java-ssl)
**Hubungkan konsol Gremlin dengan penandatanganan Sig4**
1. Mulai konsol Gremlin:
```
$ bin/gremlin.sh
```
1. Pada `gremlin>` prompt, instal `amazon-neptune-sigv4-signer` perpustakaan (ini hanya perlu dilakukan sekali untuk konsol):
```
:install com.amazonaws amazon-neptune-sigv4-signer 2.4.0
```
Jika Anda mengalami masalah dengan langkah ini, mungkin membantu untuk berkonsultasi dengan [TinkerPop dokumentasi](https://tinkerpop.apache.org/docs/current/reference/#gremlin-applications) tentang konfigurasi [Grape](http://docs.groovy-lang.org/latest/html/documentation/grape.html).
**catatan**
Jika Anda menggunakan proxy HTTP, Anda mungkin mengalami kesalahan dengan langkah ini di mana `:install` perintah tidak selesai. Untuk mengatasi masalah ini, jalankan perintah berikut untuk memberi tahu konsol tentang proxy:
```
System.setProperty("https.proxyHost", "(the proxy IP address)")
System.setProperty("https.proxyPort", "(the proxy port)")
```
1. Impor kelas yang diperlukan untuk menangani masuk ke`requestInterceptor()`:
```
:import software.amazon.awssdk.auth.credentials.DefaultCredentialsProvider
:import com.amazonaws.neptune.auth.NeptuneNettyHttpSigV4Signer
```
1. Jika Anda menggunakan kredensi sementara, Anda juga perlu menyediakan Token Sesi Anda sebagai berikut:
```
System.setProperty("aws.sessionToken","(your session token)")
```
1. Jika Anda belum menetapkan kredensi akun Anda, Anda dapat menetapkannya sebagai berikut:
```
System.setProperty("aws.accessKeyId","(your access key)")
System.setProperty("aws.secretKey","(your secret key)")
```
1. Buat `Cluster` objek secara manual untuk terhubung ke Neptunus:
```
cluster = Cluster.build("(host name)") \
.enableSsl(true) \
.requestInterceptor { r -> \
def sigV4Signer = new NeptuneNettyHttpSigV4Signer("(Amazon region)", \
DefaultCredentialsProvider.create()); \
sigV4Signer.signRequest(r); \
return r; } \
.create()
```
Untuk bantuan menemukan nama host dari instans DB Neptunus, lihat. [Menghubungkan ke Titik Akhir Amazon Neptune.](feature-overview-endpoints.md)
1. Buat `:remote` koneksi menggunakan nama variabel `Cluster` objek pada langkah sebelumnya:
```
:remote connect tinkerpop.server cluster
```
1. Masukkan perintah berikut untuk beralih ke mode jarak jauh. Ini mengirimkan semua kueri Gremlin ke koneksi jarak jauh:
```
:remote console
```
# Menghubungkan ke database Amazon Neptunus menggunakan IAM dengan Gremlin Java
Berikut adalah contoh cara terhubung ke Neptunus menggunakan Gremlin Java API dengan penandatanganan Sig4 (ini mengasumsikan pengetahuan umum tentang penggunaan Maven). Contoh ini menggunakan library [Amazon Neptune SiGv4 Signer](https://github.com/aws/amazon-neptune-sigv4-signer) untuk membantu penandatanganan permintaan. Pertama, tentukan dependensi sebagai bagian dari file: `pom.xml`
**catatan**
Contoh berikut digunakan`requestInterceptor()`, yang diperkenalkan di TinkerPop 3.6.6. Jika Anda menggunakan TinkerPop versi lebih awal dari 3.6.6 (tetapi 3.5.5 atau lebih tinggi), gunakan `handshakeInterceptor()` alih-alih `requestInterceptor()` dalam contoh kode di bawah ini.
```
com.amazonaws
amazon-neptune-sigv4-signer
3.1.0
```
Amazon Neptune SiGv4 Signer mendukung kedua versi 1.x dan 2.x dari Java SDK. AWS Contoh berikut menggunakan 2.x, di mana `DefaultCredentialsProvider` adalah sebuah `software.amazon.awssdk.auth.credentials.AwsCredentialsProvider` instance. Jika Anda memutakhirkan dari 1.x ke 2.x, lihat [perubahan penyedia Credentials](https://docs.aws.amazon.com//sdk-for-java/latest/developer-guide/migration-client-credentials.html) dalam dokumentasi SDK for AWS Java 2.x.
```
import software.amazon.awssdk.auth.credentials.DefaultCredentialsProvider;
import com.amazonaws.neptune.auth.NeptuneNettyHttpSigV4Signer;
import com.amazonaws.neptune.auth.NeptuneSigV4SignerException;
...
System.setProperty("aws.accessKeyId","your-access-key");
System.setProperty("aws.secretKey","your-secret-key");
...
Cluster cluster = Cluster.build((your cluster))
.enableSsl(true)
.requestInterceptor( r ->
{
try {
NeptuneNettyHttpSigV4Signer sigV4Signer =
new NeptuneNettyHttpSigV4Signer("(your region)", DefaultCredentialsProvider.create());
sigV4Signer.signRequest(r);
} catch (NeptuneSigV4SignerException e) {
throw new RuntimeException("Exception occurred while signing the request", e);
}
return r;
}
).create();
try {
Client client = cluster.connect();
client.submit("g.V().has('code','IAD')").all().get();
} catch (Exception e) {
throw new RuntimeException("Exception occurred while connecting to cluster", e);
}
```
## Autentikasi IAM lintas akun
[Amazon Neptunus mendukung otentikasi IAM lintas akun melalui penggunaan asumsi peran, juga kadang-kadang disebut sebagai rantai peran.](https://docs.aws.amazon.com//neptune/latest/userguide/bulk-load-tutorial-chain-roles.html#bulk-load-tutorial-chain-cross-account) Untuk menyediakan akses ke cluster Neptunus dari aplikasi yang dihosting di akun yang berbeda: AWS
+ Buat pengguna atau peran IAM baru di AWS akun aplikasi, dengan kebijakan kepercayaan yang memungkinkan pengguna atau peran untuk mengambil peran IAM lain. Tetapkan peran ini ke komputasi yang menghosting aplikasi (instans EC2, fungsi Lambda, Tugas ECS, dll.).
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Sid": "assumeRolePolicy",
"Effect": "Allow",
"Action": "sts:AssumeRole",
"Resource": "arn:aws:iam::111122223333:role/role-name"
}
]
}
```
------
+ Buat peran IAM baru di akun AWS database Neptunus yang memungkinkan akses ke database Neptunus dan memungkinkan asumsi peran dari pengguna/peran IAM akun aplikasi. Gunakan kebijakan kepercayaan:
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Principal": {
"AWS": [
"(ARN of application account IAM user or role)"
]
},
"Action": "sts:AssumeRole",
"Condition": {}
}
]
}
```
------
+ Gunakan contoh kode berikut sebagai panduan tentang cara menggunakan dua peran ini untuk memungkinkan aplikasi mengakses Neptunus. Dalam contoh ini, peran akun aplikasi akan diasumsikan melalui [DefaultCredentialProviderChain](https://docs.aws.amazon.com//sdk-for-java/v1/developer-guide/credentials.html)saat membuat`STSclient`. Kemudian `STSclient` digunakan melalui `STSAssumeRoleSessionCredentialsProvider` untuk mengambil peran yang dihosting di akun database AWS Neptunus.
```
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();
}
```
# Menghubungkan ke database Amazon Neptunus menggunakan otentikasi IAM dengan Java dan SPARQL
Bagian ini menunjukkan cara terhubung ke Neptunus menggunakan J RDF4 atau Apache Jena dengan otentikasi Signature Version 4.
**Prasyarat**
+ Java 8 atau lebih tinggi.
+ Apache Maven 3.3 atau lebih tinggi.
Untuk informasi tentang menginstal prasyarat ini di instans EC2 yang menjalankan Amazon Linux, lihat [Prasyarat untuk menghubungkan database Amazon Neptunus menggunakan otentikasi IAM](iam-auth-connect-prerq.md).
+ Kredensial IAM untuk menandatangani permintaan. Untuk informasi selengkapnya, lihat [Menggunakan Rantai Penyedia Kredential Default](https://docs.aws.amazon.com/sdk-for-java/v1/developer-guide/credentials.html#credentials-default) dalam *Panduan Developer AWS SDK untuk Java *.
**catatan**
Jika Anda menggunakan kredensial sementara, kredensial kedaluwarsa setelah interval tertentu, *termasuk token sesinya*.
Anda harus memperbarui token sesi Anda ketika Anda meminta kredensial baru. Untuk informasi selengkapnya, lihat [Menggunakan Kredensyal Keamanan Sementara untuk Meminta Akses ke AWS Sumber Daya](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_temp_use-resources.html) di Panduan Pengguna *IAM*.
+ Atur variabel `SERVICE_REGION` ke salah satu dari berikut ini, menunjukkan Wilayah instans DB Neptune Anda:
+ US East (N. Virginia): `us-east-1`
+ AS Timur (Ohio): `us-east-2`
+ US West (N. California): `us-west-1`
+ US West (Oregon): `us-west-2`
+ Canada (Central): `ca-central-1`
+ Kanada Barat (Calgary): `ca-west-1`
+ South America (São Paulo): `sa-east-1`
+ Eropa (Stockholm): `eu-north-1`
+ Eropa (Spanyol): `eu-south-2`
+ Eropa (Irlandia): `eu-west-1`
+ Eropa (London): `eu-west-2`
+ Eropa (Paris): `eu-west-3`
+ Eropa (Frankfurt): `eu-central-1`
+ Timur Tengah (Bahrain): `me-south-1`
+ Timur Tengah (UEA): `me-central-1`
+ Israel (Tel Aviv): `il-central-1`
+ Afrika (Cape Town): `af-south-1`
+ Asia Pasifik (Hong Kong): `ap-east-1`
+ Asia Pacific (Tokyo): `ap-northeast-1`
+ Asia Pasifik (Seoul): `ap-northeast-2`
+ Asia Pasifik (Osaka): `ap-northeast-3`
+ Asia Pacific (Singapore): `ap-southeast-1`
+ Asia Pacific (Sydney): `ap-southeast-2`
+ Asia Pasifik (Jakarta): `ap-southeast-3`
+ Asia Pasifik (Melbourne): `ap-southeast-4`
+ Asia Pasifik (Malaysia): `ap-southeast-5`
+ Asia Pasifik (Mumbai): `ap-south-1`
+ Asia Pasifik (Hyderabad): `ap-south-2`
+ Tiongkok (Beijing): `cn-north-1`
+ Tiongkok (Ningxia): `cn-northwest-1`
+ AWS GovCloud (AS-Barat): `us-gov-west-1`
+ AWS GovCloud (AS-Timur): `us-gov-east-1`
**Untuk terhubung ke Neptunus menggunakan J RDF4 atau Apache Jena dengan penandatanganan Signature Version 4**
1. Kloning repositori sampel dari. GitHub
```
git clone https://github.com/aws/amazon-neptune-sparql-java-sigv4.git
```
1. Ubah ke dalam direktori kloning.
```
cd amazon-neptune-sparql-java-sigv4
```
1. Dapatkan versi terbaru dari proyek dengan memeriksa cabang dengan tanda terbaru.
```
git checkout $(git describe --tags `git rev-list --tags --max-count=1`)
```
1. Masukkan salah satu perintah berikut untuk mengompilasi dan menjalankan kode contoh.
Ganti *your-neptune-endpoint* dengan nama host atau alamat IP instans DB Neptunus Anda. Port default adalah 8182.
**catatan**
Untuk informasi tentang menemukan nama host instans DB Neptune Anda, lihat bagian [Menghubungkan ke Titik Akhir Amazon Neptune.](feature-overview-endpoints.md).
**Gerhana J RDF4**
Masukkan yang berikut ini untuk menjalankan contoh RDF4 J.
```
mvn compile exec:java \
-Dexec.mainClass="com.amazonaws.neptune.client.rdf4j.NeptuneRdf4JSigV4Example" \
-Dexec.args="https://your-neptune-endpoint:portsparql region-name"
```
**Apache Jena**
Masukkan berikut ini untuk menjalankan contoh Apache Jena.
```
mvn compile exec:java \
-Dexec.mainClass="com.amazonaws.neptune.client.jena.NeptuneJenaSigV4Example" \
-Dexec.args="https://your-neptune-endpoint:port"
```
1. Untuk melihat kode sumber untuk contoh, lihat contoh dalam direktori `src/main/java/com/amazonaws/neptune/client/`.
Untuk menggunakan driver penandatanganan SigV4 di aplikasi Java Anda sendiri, tambahkan paket Maven `amazon-neptune-sigv4-signer` ke bagian `` dari `pom.xml` Anda. Sebaiknya Anda menggunakan contoh sebagai titik awal.
# Menghubungkan ke database Amazon Neptunus menggunakan otentikasi IAM dengan SPARQL dan Node.js
## Kueri menggunakan penandatanganan Signature V4 dan AWS SDK untuk Javascript V3
Berikut adalah contoh cara menghubungkan ke Neptunus SPARQL menggunakan Node.js dengan otentikasi Signature Version 4 dan SDK untuk Javascript V3: AWS
```
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);
}
);
}
```
## Kueri menggunakan penandatanganan Signature V4 dan AWS SDK untuk Javascript V2
Berikut adalah contoh cara menghubungkan ke Neptunus SPARQL menggunakan Node.js dengan otentikasi Signature Version 4 dan SDK untuk Javascript V2: AWS
```
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);
});
}
```
# Menghubungkan ke database Amazon Neptunus menggunakan otentikasi IAM dengan Python
Bagian ini menunjukkan contoh program yang ditulis dengan Python yang menggambarkan bagaimana bekerja dengan Signature Versi 4 untuk Amazon Neptune. Contoh ini didasarkan pada contoh di bagian [Proses Penandatanganan Versi Tanda Tangan 4](https://docs.aws.amazon.com/general/latest/gr/sigv4-signed-request-examples.html) di bagian *Referensi Umum Amazon Web*.
Untuk bekerja dengan program contoh ini, Anda memerlukan yang berikut ini:
+ Python 3.x diinstal pada komputer Anda, yang bisa didapatkan dari [Situs Python](https://www.python.org/downloads/). Program-program ini diuji menggunakan Python 3.6.
+ [Pustakan permintaan Python](https://pypi.python.org/pypi/requests), yang digunakan dalam skrip contoh untuk membuat permintaan web. Cara mudah untuk menginstal paket Python adalah dengan menggunakan `pip`, yang mendapat paket dari situs indeks paket Python. Anda kemudian dapat menginstal `requests` dengan menjalankan `pip install requests` pada baris perintah.
+ Kunci akses (access key ID dan secret access key) di variabel lingkungan bernama `AWS_ACCESS_KEY_ID` dan `AWS_SECRET_ACCESS_KEY`. Sebagai praktik terbaik, kami menyarankan Anda untuk *tidak* menanamkan kredensial dalam kode. Untuk informasi selengkapnya, lihat [Praktik Terbaik untuk akun AWS](https://docs.aws.amazon.com//accounts/latest/reference/best-practices.html) di *Panduan Referensi AWS Account Management *.
Wilayah klaster DB Neptune Anda dalam variabel lingkungan bernama `SERVICE_REGION`.
Jika Anda menggunakan kredensial sementara, Anda harus menentukan `AWS_SESSION_TOKEN` selain `AWS_ACCESS_KEY_ID`, `AWS_SECRET_ACCESS_KEY`, dan `SERVICE_REGION`.
**catatan**
Jika Anda menggunakan kredensial sementara, kredensial kedaluwarsa setelah interval tertentu, *termasuk token sesinya*.
Anda harus memperbarui token sesi Anda ketika Anda meminta kredensial baru. Untuk informasi selengkapnya, lihat [Menggunakan Kredensial Keamanan Sementara untuk Meminta Akses ke Sumber Daya AWS](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_temp_use-resources.html).
Contoh berikut menunjukkan cara membuat permintaan yang ditandatangani ke Neptune menggunakan Python. Permintaan tersebut membuat permintaan GET atau POST. Informasi autentikasi dilewatkan menggunakan header permintaan `Authorization`.
Contoh ini juga berfungsi sebagai AWS Lambda fungsi. Untuk informasi selengkapnya, lihat [Menyiapkan AWS Lambda untuk Otentikasi IAM Neptunus](iam-auth-temporary-credentials.md#iam-auth-temporary-credentials-lambda).
**Untuk membuat permintaan yang ditandatangani ke titik akhir Gremlin dan SPARQL Neptune**
1. Buat file baru bernama `neptunesigv4.py`, lalu buka file tersebut dalam editor teks.
1. Salin kode berikut dan tempelkan ke file `neptunesigv4.py`.
```
# Amazon Neptune version 4 signing example (version v3)
# The following script requires python 3.6+
# (sudo yum install python36 python36-virtualenv python36-pip)
# => the reason is that we're using urllib.parse() to manually encode URL
# parameters: the problem here is that SIGV4 encoding requires whitespaces
# to be encoded as %20 rather than not or using '+', as done by previous/
# default versions of the library.
# See: https://docs.aws.amazon.com/general/latest/gr/sigv4_signing.html
import sys, datetime, hashlib, hmac
import requests # pip3 install requests
import urllib
import os
import json
from botocore.auth import SigV4Auth
from botocore.awsrequest import AWSRequest
from botocore.credentials import ReadOnlyCredentials
from types import SimpleNamespace
from argparse import RawTextHelpFormatter
from argparse import ArgumentParser
# Configuration. https is required.
protocol = 'https'
# The following lines enable debugging at httplib level (requests->urllib3->http.client)
# You will see the REQUEST, including HEADERS and DATA, and RESPONSE with HEADERS but without DATA.
#
# The only thing missing will be the response.body which is not logged.
#
# import logging
# from http.client import HTTPConnection
# HTTPConnection.debuglevel = 1
# logging.basicConfig()
# logging.getLogger().setLevel(logging.DEBUG)
# requests_log = logging.getLogger("requests.packages.urllib3")
# requests_log.setLevel(logging.DEBUG)
# requests_log.propagate = True
# Read AWS access key from env. variables. Best practice is NOT
# to embed credentials in code.
access_key = os.getenv('AWS_ACCESS_KEY_ID', '')
secret_key = os.getenv('AWS_SECRET_ACCESS_KEY', '')
region = os.getenv('SERVICE_REGION', '')
# AWS_SESSION_TOKEN is optional environment variable. Specify a session token only if you are using temporary
# security credentials.
session_token = os.getenv('AWS_SESSION_TOKEN', '')
### Note same script can be used for AWS Lambda (runtime = python3.6).
## Steps to use this python script for AWS Lambda
# 1. AWS_ACCESS_KEY_ID, AWS_SECRET_ACCESS_KEY and AWS_SESSION_TOKEN and AWS_REGION variables are already part of Lambda's Execution environment
# No need to set them up explicitly.
# 3. Create Lambda deployment package https://docs.aws.amazon.com/lambda/latest/dg/lambda-python-how-to-create-deployment-package.html
# 4. Create a Lambda function in the same VPC and assign an IAM role with neptune access
def lambda_handler(event, context):
# sample_test_input = {
# "host": "END_POINT:8182",
# "method": "GET",
# "query_type": "gremlin",
# "query": "g.V().count()"
# }
# Lambda uses AWS_REGION instead of SERVICE_REGION
global region
region = os.getenv('AWS_REGION', '')
host = event['host']
method = event['method']
query_type = event['query_type']
query = event['query']
return make_signed_request(host, method, query_type, query)
def validate_input(method, query_type):
# Supporting GET and POST for now:
if (method != 'GET' and method != 'POST'):
print('First parameter must be "GET" or "POST", but is "' + method + '".')
sys.exit()
# SPARQL UPDATE requires POST
if (method == 'GET' and query_type == 'sparqlupdate'):
print('SPARQL UPDATE is not supported in GET mode. Please choose POST.')
sys.exit()
def get_canonical_uri_and_payload(query_type, query, method):
# Set the stack and payload depending on query_type.
if (query_type == 'sparql'):
canonical_uri = '/sparql/'
payload = {'query': query}
elif (query_type == 'sparqlupdate'):
canonical_uri = '/sparql/'
payload = {'update': query}
elif (query_type == 'gremlin'):
canonical_uri = '/gremlin/'
payload = {'gremlin': query}
if (method == 'POST'):
payload = json.dumps(payload)
elif (query_type == 'openCypher'):
canonical_uri = '/openCypher/'
payload = {'query': query}
elif (query_type == "loader"):
canonical_uri = "/loader/"
payload = query
elif (query_type == "status"):
canonical_uri = "/status/"
payload = {}
elif (query_type == "gremlin/status"):
canonical_uri = "/gremlin/status/"
payload = {}
elif (query_type == "openCypher/status"):
canonical_uri = "/openCypher/status/"
payload = {}
elif (query_type == "sparql/status"):
canonical_uri = "/sparql/status/"
payload = {}
else:
print(
'Third parameter should be from ["gremlin", "sparql", "sparqlupdate", "loader", "status] but is "' + query_type + '".')
sys.exit()
## return output as tuple
return canonical_uri, payload
def make_signed_request(host, method, query_type, query):
service = 'neptune-db'
endpoint = protocol + '://' + host
print()
print('+++++ USER INPUT +++++')
print('host = ' + host)
print('method = ' + method)
print('query_type = ' + query_type)
print('query = ' + query)
# validate input
validate_input(method, query_type)
# get canonical_uri and payload
canonical_uri, payload = get_canonical_uri_and_payload(query_type, query, method)
# assign payload to data or params
data = payload if method == 'POST' else None
params = payload if method == 'GET' else None
# create request URL
request_url = endpoint + canonical_uri
# create and sign request
creds = SimpleNamespace(
access_key=access_key, secret_key=secret_key, token=session_token, region=region,
)
request = AWSRequest(method=method, url=request_url, data=data, params=params)
SigV4Auth(creds, service, region).add_auth(request)
r = None
# ************* SEND THE REQUEST *************
if (method == 'GET'):
print('++++ BEGIN GET REQUEST +++++')
print('Request URL = ' + request_url)
r = requests.get(request_url, headers=request.headers, verify=False, params=params)
elif (method == 'POST'):
print('\n+++++ BEGIN POST REQUEST +++++')
print('Request URL = ' + request_url)
if (query_type == "loader"):
request.headers['Content-type'] = 'application/json'
r = requests.post(request_url, headers=request.headers, verify=False, data=data)
else:
print('Request method is neither "GET" nor "POST", something is wrong here.')
if r is not None:
print()
print('+++++ RESPONSE +++++')
print('Response code: %d\n' % r.status_code)
response = r.text
r.close()
print(response)
return response
help_msg = '''
export AWS_ACCESS_KEY_ID=[MY_ACCESS_KEY_ID]
export AWS_SECRET_ACCESS_KEY=[MY_SECRET_ACCESS_KEY]
export AWS_SESSION_TOKEN=[MY_AWS_SESSION_TOKEN]
export SERVICE_REGION=[us-east-1|us-east-2|us-west-2|eu-west-1]
python version >=3.6 is required.
Examples: For help
python3 program_name.py -h
Examples: Queries
python3 program_name.py -ho your-neptune-endpoint -p 8182 -a GET -q status
python3 program_name.py -ho your-neptune-endpoint -p 8182 -a GET -q sparql/status
python3 program_name.py -ho your-neptune-endpoint -p 8182 -a GET -q sparql -d "SELECT ?s WHERE { ?s ?p ?o }"
python3 program_name.py -ho your-neptune-endpoint -p 8182 -a POST -q sparql -d "SELECT ?s WHERE { ?s ?p ?o }"
python3 program_name.py -ho your-neptune-endpoint -p 8182 -a POST -q sparqlupdate -d "INSERT DATA { }"
python3 program_name.py -ho your-neptune-endpoint -p 8182 -a GET -q gremlin/status
python3 program_name.py -ho your-neptune-endpoint -p 8182 -a GET -q gremlin -d "g.V().count()"
python3 program_name.py -ho your-neptune-endpoint -p 8182 -a POST -q gremlin -d "g.V().count()"
python3 program_name.py -ho your-neptune-endpoint -p 8182 -a GET -q openCypher/status
python3 program_name.py -ho your-neptune-endpoint -p 8182 -a GET -q openCypher -d "MATCH (n1) RETURN n1 LIMIT 1;"
python3 program_name.py -ho your-neptune-endpoint -p 8182 -a POST -q openCypher -d "MATCH (n1) RETURN n1 LIMIT 1;"
python3 program_name.py -ho your-neptune-endpoint -p 8182 -a GET -q loader -d '{"loadId": "68b28dcc-8e15-02b1-133d-9bd0557607e6"}'
python3 program_name.py -ho your-neptune-endpoint -p 8182 -a GET -q loader -d '{}'
python3 program_name.py -ho your-neptune-endpoint -p 8182 -a POST -q loader -d '{"source": "source", "format" : "csv", "failOnError": "fail_on_error", "iamRoleArn": "iam_role_arn", "region": "region"}'
Environment variables must be defined as AWS_ACCESS_KEY_ID, AWS_SECRET_ACCESS_KEY and SERVICE_REGION.
You should also set AWS_SESSION_TOKEN environment variable if you are using temporary credentials (ex. IAM Role or EC2 Instance profile).
Current Limitations:
- Query mode "sparqlupdate" requires POST (as per the SPARQL 1.1 protocol)
'''
def exit_and_print_help():
print(help_msg)
exit()
def parse_input_and_query_neptune():
parser = ArgumentParser(description=help_msg, formatter_class=RawTextHelpFormatter)
group_host = parser.add_mutually_exclusive_group()
group_host.add_argument("-ho", "--host", type=str)
group_port = parser.add_mutually_exclusive_group()
group_port.add_argument("-p", "--port", type=int, help="port ex. 8182, default=8182", default=8182)
group_action = parser.add_mutually_exclusive_group()
group_action.add_argument("-a", "--action", type=str, help="http action, default = GET", default="GET")
group_endpoint = parser.add_mutually_exclusive_group()
group_endpoint.add_argument("-q", "--query_type", type=str, help="query_type, default = status ", default="status")
group_data = parser.add_mutually_exclusive_group()
group_data.add_argument("-d", "--data", type=str, help="data required for the http action", default="")
args = parser.parse_args()
print(args)
# Read command line parameters
host = args.host
port = args.port
method = args.action
query_type = args.query_type
query = args.data
if (access_key == ''):
print('!!! ERROR: Your AWS_ACCESS_KEY_ID environment variable is undefined.')
exit_and_print_help()
if (secret_key == ''):
print('!!! ERROR: Your AWS_SECRET_ACCESS_KEY environment variable is undefined.')
exit_and_print_help()
if (region == ''):
print('!!! ERROR: Your SERVICE_REGION environment variable is undefined.')
exit_and_print_help()
if host is None:
print('!!! ERROR: Neptune DNS is missing')
exit_and_print_help()
host = host + ":" + str(port)
make_signed_request(host, method, query_type, query)
if __name__ == "__main__":
parse_input_and_query_neptune()
```
1. Di terminal, arahkan ke lokasi file `neptunesigv4.py`.
1. Masukkan perintah berikut, ganti access key, kunci rahasia, dan Wilayah dengan nilai yang benar.
```
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
```
Jika Anda menggunakan kredensial sementara, Anda harus menentukan `AWS_SESSION_TOKEN` selain `AWS_ACCESS_KEY_ID`, `AWS_SECRET_ACCESS_KEY`, dan `SERVICE_REGION`.
```
export AWS_SESSION_TOKEN=MY_AWS_SESSION_TOKEN
```
**catatan**
Jika Anda menggunakan kredensial sementara, kredensial kedaluwarsa setelah interval tertentu, *termasuk token sesinya*.
Anda harus memperbarui token sesi Anda ketika Anda meminta kredensial baru. Untuk informasi selengkapnya, lihat [Menggunakan Kredensial Keamanan Sementara untuk Meminta Akses ke Sumber Daya AWS](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_temp_use-resources.html).
1. Masukkan salah satu perintah berikut untuk mengirim permintaan yang ditandatangani ke instans DB Neptune. Contoh ini menggunakan Python versi 3.6.
**Status Titik Akhir**
```
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()"
```
**Status 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 }"
```
**PEMBARUAN SPARQL**
```
python3.6 neptunesigv4.py -ho your-neptune-endpoint -p 8182 -a POST -q sparqlupdate -d "INSERT DATA { }"
```
**Status 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;"
```
**Status OpenCypher**
```
python3.6 neptunesigv4.py -ho your-neptune-endpoint -p 8182 -a GET -q openCypher/status
```
**Loader**
```
python3.6 neptunesigv4.py -ho your-neptune-endpoint -p 8182 -a GET -q loader -d '{"loadId": "68b28dcc-8e15-02b1-133d-9bd0557607e6"}'
python3.6 neptunesigv4.py -ho your-neptune-endpoint -p 8182 -a GET -q loader -d '{}'
python3.6 neptunesigv4.py -ho your-neptune-endpoint -p 8182 -a POST -q loader -d '{"source": "source", "format" : "csv", "failOnError": "fail_on_error", "iamRoleArn": "iam_role_arn", "region": "region"}'
```
1. Sintaks untuk menjalankan skrip Python adalah sebagai berikut:
```
python3.6 neptunesigv4.py -ho your-neptune-endpoint -p port -a GET|POST -q gremlin|sparql|sparqlupdate|loader|status -d "string0data"
```
SPARQL UPDATE memerlukan `POST`.
# Menghubungkan ke database Amazon Neptunus menggunakan otentikasi IAM dengan Python Gremlin
## Ikhtisar
Panduan ini menunjukkan cara menghubungkan ke database Amazon Neptunus dengan otentikasi IAM diaktifkan menggunakan driver Python Gremlin, dengan otentikasi Signature Version 4 dan SDK for Python (Boto3). AWS
## Buat koneksi dasar
Gunakan contoh kode berikut sebagai panduan tentang cara membuat koneksi dasar dengan otentikasi IAM menggunakan driver Python Gremlin.
```
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()
```
# Menghubungkan ke database Amazon Neptunus menggunakan otentikasi IAM dengan Gremlin JavaScript
## Ikhtisar
Panduan ini menunjukkan cara menyambung ke database Amazon Neptunus dengan autentikasi IAM diaktifkan menggunakan JavaScript driver Gremlin, dengan otentikasi Signature Version 4 dan SDK untuk Javascript v3. AWS
## Prasyarat
+ Cluster Amazon Neptunus dengan otentikasi IAM diaktifkan.
+ Node 13 atau yang lebih baru (lihat versi minimal untuk Gremlin JavaScript dan [AWS SDK untuk Javascript](https://docs.aws.amazon.com//AWSJavaScriptSDK/v3/latest/introduction/#release-cadence) v3).
+ AWS kredensyal dikonfigurasi (melalui variabel lingkungan, file kredensyal bersama, atau peran IAM).
## Buat koneksi dasar
Gunakan contoh kode berikut sebagai panduan tentang cara membuat koneksi dasar dengan otentikasi IAM menggunakan driver JavaScript Gremlin.
```
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();
```
# Menghubungkan ke database Amazon Neptunus menggunakan otentikasi IAM dengan Gremlin Go
## Ikhtisar
Panduan ini menunjukkan cara menyambung ke database Amazon Neptunus dengan autentikasi IAM diaktifkan menggunakan driver Gremlin Go, dengan otentikasi Signature Version 4 dan SDK untuk GO v2. AWS
## Prasyarat
+ Cluster Amazon Neptunus dengan otentikasi IAM diaktifkan.
+ Go 1.22 atau yang lebih baru (lihat versi minimal yang didukung untuk [Gremlin Go](https://pkg.go.dev/github.com/apache/tinkerpop/gremlin-go/v3/driver) dan [SDK for AWS Go v2](https://pkg.go.dev/github.com/aws/aws-sdk-go-v2)).
+ AWS kredensil yang dikonfigurasi (melalui variabel lingkungan, file kredensial bersama, atau peran IAM)
## Buat koneksi dasar
Gunakan contoh kode berikut sebagai panduan tentang cara membuat koneksi dasar dengan otentikasi IAM menggunakan driver Gremlin Go.
```
package main
import (
"context"
"fmt"
"github.com/aws/aws-sdk-go-v2/config"
"net/http"
"strings"
"time"
gremlingo "github.com/apache/tinkerpop/gremlin-go/v3/driver"
v4 "github.com/aws/aws-sdk-go-v2/aws/signer/v4"
)
const emptyStringSHA256 = `e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855`
func main() {
neptuneEndpoint := "you.cluster.endpoint.neptune.amazonaws.com"
connString := "wss://" + neptuneEndpoint + ":8182/gremlin"
service := "neptune-db"
defaultRegion := "us-east-1"
// Create request to sign
req, err := http.NewRequest(http.MethodGet, connString, strings.NewReader(""))
if err != nil {
fmt.Println(err)
return
}
// Loads the default config with default credentials provider
// See https://github.com/aws/aws-sdk-go-v2 for additional docs on API usage
cfg, err := config.LoadDefaultConfig(context.TODO())
if err != nil {
fmt.Println(err)
return
}
// Retrieve loaded credentials
cr, err := cfg.Credentials.Retrieve(context.TODO())
if err != nil {
fmt.Println(err)
return
}
region := defaultRegion
if cfg.Region != "" {
// region set inside config profile, or via AWS_REGION or AWS_DEFAULT_REGION environment variable will be loaded
region = cfg.Region
}
signer := v4.NewSigner()
// Sign request
err = signer.SignHTTP(context.TODO(), cr, req, emptyStringSHA256, service, "us-east-2", time.Now())
if err != nil {
fmt.Println(err)
return
}
// Pass the signed request header into gremlingo.HeaderAuthInfo()
driverRemoteConnection, err := gremlingo.NewDriverRemoteConnection(connString,
func(settings *gremlingo.DriverRemoteConnectionSettings) {
settings.TraversalSource = "g"
settings.AuthInfo = gremlingo.HeaderAuthInfo(req.Header)
// settings.TlsConfig = &tls.Config{InsecureSkipVerify: true} // Use this only if you're on a Mac running Go 1.18+ doing local dev. See https://github.com/golang/go/issues/51991
})
if err != nil {
fmt.Println(err)
return
}
// Cleanup
defer driverRemoteConnection.Close()
// Creating graph traversal
g := gremlingo.Traversal_().WithRemote(driverRemoteConnection)
// Query execution
count, err := g.V().Limit(5).Count().Next()
if err != nil {
fmt.Println(err)
return
}
fmt.Println("Vertex count:", *count)
}
```
## Penyegaran Kredensi Dinamis Gremlin Go
Gremlin Go memiliki DynamicAuth yang memungkinkan injeksi pointer fungsi untuk mengambil kredensil dan menghasilkan header, yang mencegah kedaluwarsa header dengan koneksi yang berjalan lama.
```
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)
}
```
# Menghubungkan ke database Amazon Neptunus menggunakan otentikasi IAM dengan Gremlin.NET
## Ikhtisar
Panduan ini menunjukkan cara menghubungkan ke database Amazon Neptunus dengan autentikasi IAM diaktifkan menggunakan driver Gremlin.NET, dengan otentikasi Signature Version 4 dan SDK for .NET v3. AWS
## Buat koneksi dasar
[Untuk terhubung dengan Gremlin.NET, gunakan file `SigV4RequestSigner` sumber dari pustaka https://github.com/aws/ amazon-neptune-gremlin-dotnet kustom -sigv4.](https://github.com/aws/amazon-neptune-gremlin-dotnet-sigv4) Contoh pengaturan proyek terletak di [ https://github.com/aws/amazon-neptune-gremlin-dotnet-sigv4/ tree/main/example](https://github.com/aws/amazon-neptune-gremlin-dotnet-sigv4/tree/main/example), dan tercermin di bawah ini.
File Proyek:
```
Exe
netcoreapp8.0
```
Contoh Program:
```
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);
}
}
}
}
```