Terjemahan disediakan oleh mesin penerjemah. Jika konten terjemahan yang diberikan bertentangan dengan versi bahasa Inggris aslinya, utamakan versi bahasa Inggris.
# Mengakses DAX di seluruh akun AWS
Bayangkan Anda memiliki klaster DynamoDB Accelerator (DAX) yang berjalan di AWS satu akun (akun A), dan kluster DAX harus dapat diakses dari instans Amazon Elastic Compute Cloud (Amazon EC2) di akun lain (akun B). AWS Dalam tutorial ini, Anda mencapai hal ini dengan meluncurkan instans EC2 di akun B dengan peran IAM dari akun B. Lalu, Anda menggunakan kredensial keamanan sementara dari instans EC2 untuk mengambil peran IAM dari akun A. Terakhir, Anda menggunakan kredensial keamanan sementara dari pengambilan peran IAM di akun A untuk membuat panggilan aplikasi melalui koneksi peering Amazon VPC ke klaster DAX di akun A. Untuk melakukan tugas-tugas ini, Anda akan memerlukan akses administratif di kedua akun AWS .
**penting**
Klaster DAX tidak dapat mengakses tabel DynamoDB dari akun yang berbeda.
**Topics**
+ [Menyiapkan IAM](#DAX.cross-account-access.iam-setup)
+ [Menyiapkan VPC](#DAX.cross-account-access.vpc-setup)
+ [Mengubah klien DAX untuk mengizinkan akses lintas akun](#DAX.cross-account-access.modify-client)
## Menyiapkan IAM
1. Buat file teks bernama `AssumeDaxRoleTrust.json` berisi konten berikut, yang mengizinkan Amazon EC2 untuk bekerja atas nama Anda.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Principal": {
"Service": "ec2.amazonaws.com"
},
"Action": "sts:AssumeRole"
}
]
}
```
------
1. Di akun B, buat peran yang dapat digunakan oleh Amazon EC2 saat meluncurkan instans.
```
aws iam create-role \
--role-name AssumeDaxRole \
--assume-role-policy-document file://AssumeDaxRoleTrust.json
```
1. Buat file teks bernama `AssumeDaxRolePolicy.json` dengan konten berikut, yang memungkinkan kode berjalan pada instans EC2 di akun B untuk mengambil peran IAM di akun A. Ganti *accountA* dengan ID aktual akun A.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": "sts:AssumeRole",
"Resource": "arn:aws:iam::111122223333:role/DaxCrossAccountRole"
}
]
}
```
------
1. Tambahkan kebijakan tersebut ke peran yang baru Anda buat.
```
aws iam put-role-policy \
--role-name AssumeDaxRole \
--policy-name AssumeDaxRolePolicy \
--policy-document file://AssumeDaxRolePolicy.json
```
1. Buat profil instans untuk mengizinkan instans menggunakan peran.
```
aws iam create-instance-profile \
--instance-profile-name AssumeDaxInstanceProfile
```
1. Kaitkan peran dengan profil instans.
```
aws iam add-role-to-instance-profile \
--instance-profile-name AssumeDaxInstanceProfile \
--role-name AssumeDaxRole
```
1. Buat file teks bernama `DaxCrossAccountRoleTrust.json` berisi konten berikut, yang mengizinkan akun B mengambil peran akun A. Ganti *accountB* dengan ID aktual akun B.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Principal": {
"AWS": "arn:aws:iam::111122223333:role/AssumeDaxRole"
},
"Action": "sts:AssumeRole"
}
]
}
```
------
1. Di akun A, buat peran yang dapat diambil oleh akun B.
```
aws iam create-role \
--role-name DaxCrossAccountRole \
--assume-role-policy-document file://DaxCrossAccountRoleTrust.json
```
1. Buat file teks bernama `DaxCrossAccountPolicy.json` yang mengizinkan akses ke klaster DAX. Ganti *dax-cluster-arn* dengan Nama Sumber Daya Amazon (ARN) yang benar dari cluster DAX Anda.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"dax:GetItem",
"dax:BatchGetItem",
"dax:Query",
"dax:Scan",
"dax:PutItem",
"dax:UpdateItem",
"dax:DeleteItem",
"dax:BatchWriteItem",
"dax:ConditionCheckItem"
],
"Resource": "arn:aws:dax:us-east-1:111122223333:cache/dax-cluster-name"
}
]
}
```
------
1. Di akun A, tambahkan kebijakan ke peran tersebut.
```
aws iam put-role-policy \
--role-name DaxCrossAccountRole \
--policy-name DaxCrossAccountPolicy \
--policy-document file://DaxCrossAccountPolicy.json
```
## Menyiapkan VPC
1. Temukan grup subnet klaster DAX akun A. Ganti *cluster-name* dengan nama cluster DAX yang harus diakses akun B.
```
aws dax describe-clusters \
--cluster-name cluster-name
--query 'Clusters[0].SubnetGroup'
```
1. Dengan menggunakan itu*subnet-group*, temukan VPC cluster.
```
aws dax describe-subnet-groups \
--subnet-group-name subnet-group \
--query 'SubnetGroups[0].VpcId'
```
1. Dengan menggunakan itu*vpc-id*, temukan CIDR VPC.
```
aws ec2 describe-vpcs \
--vpc vpc-id \
--query 'Vpcs[0].CidrBlock'
```
1. Dari akun B, buat VPC menggunakan CIDR yang berbeda dan tidak tumpang tindih dari yang ditemukan di langkah sebelumnya. Kemudian, buat setidaknya satu subnet. Anda dapat menggunakan [wizard pembuatan VPC](https://docs.aws.amazon.com/vpc/latest/userguide/getting-started-ipv4.html#getting-started-create-vpc) di Konsol Manajemen AWS atau. [AWS CLI](https://docs.aws.amazon.com/cli/latest/reference/ec2/create-vpc.html)
1. Dari akun B, minta koneksi peering ke VPC akun A seperti yang dijelaskan di [Membuat dan menerima koneksi peering VPC](https://docs.aws.amazon.com/vpc/latest/peering/create-vpc-peering-connection.html). Dari akun A, terima koneksi.
1. Dari akun B, temukan tabel perutean VPC baru. Ganti *vpc-id* dengan ID VPC yang Anda buat di akun B.
```
aws ec2 describe-route-tables \
--filters 'Name=vpc-id,Values=vpc-id' \
--query 'RouteTables[0].RouteTableId'
```
1. Tambahkan rute untuk mengirim lalu lintas yang dibuat untuk CIDR akun A ke koneksi peering VPC. Ingatlah untuk mengganti masing-masing *user input placeholder* dengan nilai yang benar untuk akun Anda.
```
aws ec2 create-route \
--route-table-id accountB-route-table-id \
--destination-cidr accountA-vpc-cidr \
--vpc-peering-connection-id peering-connection-id
```
1. Dari akun A, temukan tabel rute cluster DAX menggunakan tabel yang *vpc-id* Anda temukan sebelumnya.
```
aws ec2 describe-route-tables \
--filters 'Name=vpc-id, Values=accountA-vpc-id' \
--query 'RouteTables[0].RouteTableId'
```
1. Dari akun A, tambahkan rute untuk mengirim lalu lintas yang dibuat untuk CIDR akun B ke koneksi peering VPC. Ganti masing-masing *user input placeholder* dengan nilai yang benar untuk akun Anda.
```
aws ec2 create-route \
--route-table-id accountA-route-table-id \
--destination-cidr accountB-vpc-cidr \
--vpc-peering-connection-id peering-connection-id
```
1. Dari akun B, luncurkan instans EC2 di VPC yang Anda buat sebelumnya. Berikan `AssumeDaxInstanceProfile`. Anda dapat menggunakan [wizard peluncuran](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/launching-instance.html) di Konsol Manajemen AWS atau [AWS CLI](https://docs.aws.amazon.com/cli/latest/reference/ec2/run-instances.html). Perhatikan grup keamanan instans.
1. Dari akun A, temukan grup keamanan yang digunakan oleh klaster DAX. Ingatlah untuk mengganti *cluster-name* dengan nama cluster DAX Anda.
```
aws dax describe-clusters \
--cluster-name cluster-name \
--query 'Clusters[0].SecurityGroups[0].SecurityGroupIdentifier'
```
1. Perbarui grup keamanan klaster DAX untuk mengizinkan lalu lintas masuk dari grup keamanan instans EC2 yang Anda buat di akun B. Ingatlah untuk mengganti *user input placeholders* dengan nilai yang benar untuk akun Anda.
```
aws ec2 authorize-security-group-ingress \
--group-id accountA-security-group-id \
--protocol tcp \
--port 8111 \
--source-group accountB-security-group-id \
--group-owner accountB-id
```
Pada titik ini, aplikasi pada instans EC2 akun B dapat menggunakan profil instans untuk mengasumsikan peran `arn:aws:iam::accountA-id:role/DaxCrossAccountRole` dan menggunakan klaster DAX.
## Mengubah klien DAX untuk mengizinkan akses lintas akun
**catatan**
AWS Security Token Service (AWS STS) kredensial adalah kredensial sementara. Beberapa klien menangani pembaruan secara otomatis, sementara klien lain memerlukan logika tambahan untuk memperbarui kredensialnya. Sebaiknya Anda mengikuti panduan dokumentasi yang sesuai.
------
#### [ Java ]
Bagian ini membantu Anda mengubah kode klien DAX yang ada untuk mengizinkan akses DAX lintas akun. Jika belum memiliki kode klien DAX, Anda dapat menemukan contoh kode yang berfungsi di tutorial [Java dan DAX](DAX.client.run-application-java.md).
1. Tambahkan impor berikut.
```
import com.amazonaws.auth.STSAssumeRoleSessionCredentialsProvider;
import com.amazonaws.services.securitytoken.AWSSecurityTokenService;
import com.amazonaws.services.securitytoken.AWSSecurityTokenServiceClientBuilder;
```
1. Dapatkan penyedia kredensial dari AWS STS dan buat objek klien DAX. Ingatlah untuk mengganti masing-masing *user input placeholder* dengan nilai yang benar untuk akun Anda.
```
AWSSecurityTokenService awsSecurityTokenService = AWSSecurityTokenServiceClientBuilder
.standard()
.withRegion(region)
.build();
STSAssumeRoleSessionCredentialsProvider credentials = new STSAssumeRoleSessionCredentialsProvider.Builder("arn:aws:iam::accountA:role/RoleName", "TryDax")
.withStsClient(awsSecurityTokenService)
.build();
DynamoDB client = AmazonDaxClientBuilder.standard()
.withRegion(region)
.withEndpointConfiguration(dax_endpoint)
.withCredentials(credentials)
.build();
```
------
#### [ .NET ]
Bagian ini membantu Anda mengubah kode klien DAX yang ada untuk mengizinkan akses DAX lintas akun. Jika belum memiliki kode klien DAX, Anda dapat menemukan contoh kode yang berfungsi di tutorial [.NET dan DAX](DAX.client.run-application-dotnet.md).
1. Tambahkan [AWSSDK. SecurityToken](https://www.nuget.org/packages/AWSSDK.SecurityToken) NuGet paket untuk solusinya.
```
```
1. Gunakan paket `SecurityToken` dan `SecurityToken.Model`.
```
using Amazon.SecurityToken;
using Amazon.SecurityToken.Model;
```
1. Dapatkan kredensial sementara dari `AmazonSimpleTokenService` dan buat objek `ClusterDaxClient`. Ingatlah untuk mengganti masing-masing *user input placeholder* dengan nilai yang benar untuk akun Anda.
```
IAmazonSecurityTokenService sts = new AmazonSecurityTokenServiceClient();
var assumeRoleResponse = sts.AssumeRole(new AssumeRoleRequest
{
RoleArn = "arn:aws:iam::accountA:role/RoleName",
RoleSessionName = "TryDax"
});
Credentials credentials = assumeRoleResponse.Credentials;
var clientConfig = new DaxClientConfig(dax_endpoint, port)
{
AwsCredentials = assumeRoleResponse.Credentials
};
var client = new ClusterDaxClient(clientConfig);
```
------
#### [ Go ]
Bagian ini membantu Anda mengubah kode klien DAX yang ada untuk mengizinkan akses DAX lintas akun. Jika Anda belum memiliki kode klien DAX, Anda dapat menemukan [contoh kode yang berfungsi](https://github.com/aws-samples/aws-dax-go-sample/blob/master/try_dax.go). GitHub
1. Impor paket AWS STS dan sesi.
```
import (
"github.com/aws/aws-sdk-go/aws/session"
"github.com/aws/aws-sdk-go/service/sts"
"github.com/aws/aws-sdk-go/aws/credentials/stscreds"
)
```
1. Dapatkan kredensial sementara dari `AmazonSimpleTokenService` dan buat objek klien DAX. Ingatlah untuk mengganti masing-masing *user input placeholder* dengan nilai yang benar untuk akun Anda.
```
sess, err := session.NewSession(&aws.Config{
Region: aws.String(region)},
)
if err != nil {
return nil, err
}
stsClient := sts.New(sess)
arp := &stscreds.AssumeRoleProvider{
Duration: 900 * time.Second,
ExpiryWindow: 10 * time.Second,
RoleARN: "arn:aws:iam::accountA:role/role_name",
Client: stsClient,
RoleSessionName: "session_name",
}cfg := dax.DefaultConfig()
cfg.HostPorts = []string{dax_endpoint}
cfg.Region = region
cfg.Credentials = credentials.NewCredentials(arp)
daxClient := dax.New(cfg)
```
------
#### [ Python ]
Bagian ini membantu Anda mengubah kode klien DAX yang ada untuk mengizinkan akses DAX lintas akun. Jika belum memiliki kode klien DAX, Anda dapat menemukan contoh kode yang berfungsi di tutorial [Python dan DAX](DAX.client.run-application-python.md).
1. Impor `boto3`.
```
import boto3
```
1. Dapatkan kredensial sementara dari `sts` dan buat objek `AmazonDaxClient`. Ingatlah untuk mengganti masing-masing *user input placeholder* dengan nilai yang benar untuk akun Anda.
```
sts = boto3.client('sts')
stsresponse = sts.assume_role(RoleArn='arn:aws:iam::accountA:role/RoleName',RoleSessionName='tryDax')
credentials = botocore.session.get_session()['Credentials']
dax = amazondax.AmazonDaxClient(session, region_name=region, endpoints=[dax_endpoint], aws_access_key_id=credentials['AccessKeyId'], aws_secret_access_key=credentials['SecretAccessKey'], aws_session_token=credentials['SessionToken'])
client = dax
```
------
#### [ Node.js ]
Bagian ini membantu Anda mengubah kode klien DAX yang ada untuk mengizinkan akses DAX lintas akun. Jika belum memiliki kode klien DAX, Anda dapat menemukan contoh kode yang berfungsi di tutorial [Node.js dan DAX](DAX.client.run-application-nodejs.md). Ingatlah untuk mengganti masing-masing *user input placeholder* dengan nilai yang benar untuk akun Anda.
```
const AmazonDaxClient = require('amazon-dax-client');
const AWS = require('aws-sdk');
const region = 'region';
const endpoints = [daxEndpoint1, ...];
const getCredentials = async() => {
return new Promise((resolve, reject) => {
const sts = new AWS.STS();
const roleParams = {
RoleArn: 'arn:aws:iam::accountA:role/RoleName',
RoleSessionName: 'tryDax',
};
sts.assumeRole(roleParams, (err, session) => {
if(err) {
reject(err);
} else {
resolve({
accessKeyId: session.Credentials.AccessKeyId,
secretAccessKey: session.Credentials.SecretAccessKey,
sessionToken: session.Credentials.SessionToken,
});
}
});
});
};
const createDaxClient = async() => {
const credentials = await getCredentials();
const daxClient = new AmazonDaxClient({endpoints: endpoints, region: region, accessKeyId: credentials.accessKeyId, secretAccessKey: credentials.secretAccessKey, sessionToken: credentials.sessionToken});
return new AWS.DynamoDB.DocumentClient({service: daxClient});
};
createDaxClient().then((client) => {
client.get(...);
...
}).catch((error) => {
console.log('Caught an error: ' + error);
});
```
------