Mengakses DAX di seluruh akun AWS - Amazon DynamoDB
Menyiapkan IAMMenyiapkan VPCMengubah klien DAX untuk mengizinkan akses lintas akun

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.

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"
        }
    ]
}

  2. 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

  3. 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"
        }
    ]
}

  4. 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

  5. Buat profil instans untuk mengizinkan instans menggunakan peran.

    aws iam create-instance-profile \
    --instance-profile-name AssumeDaxInstanceProfile

  6. Kaitkan peran dengan profil instans.

    aws iam add-role-to-instance-profile \
    --instance-profile-name AssumeDaxInstanceProfile \
    --role-name AssumeDaxRole

  7. 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"
        }
    ]
}

  8. 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

  9. 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"
        }
    ]
}

  10. 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'

  2. Dengan menggunakan itusubnet-group, temukan VPC cluster.

    aws dax describe-subnet-groups \
    --subnet-group-name subnet-group \
    --query 'SubnetGroups[0].VpcId'

  3. Dengan menggunakan ituvpc-id, temukan CIDR VPC.

    aws ec2 describe-vpcs \
    --vpc vpc-id \
    --query 'Vpcs[0].CidrBlock'

  4. 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 di Konsol Manajemen AWS atau. AWS CLI

  5. Dari akun B, minta koneksi peering ke VPC akun A seperti yang dijelaskan di Membuat dan menerima koneksi peering VPC. Dari akun A, terima koneksi.

  6. 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'

  7. 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

  8. 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'

  9. 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

  10. Dari akun B, luncurkan instans EC2 di VPC yang Anda buat sebelumnya. Berikan AssumeDaxInstanceProfile. Anda dapat menggunakan wizard peluncuran di Konsol Manajemen AWS atau AWS CLI. Perhatikan grup keamanan instans.

  11. 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'

  12. 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) kredensil adalah kredensil 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.

  1. Tambahkan impor berikut.

    import com.amazonaws.auth.STSAssumeRoleSessionCredentialsProvider;
import com.amazonaws.services.securitytoken.AWSSecurityTokenService;
import com.amazonaws.services.securitytoken.AWSSecurityTokenServiceClientBuilder;

  2. Dapatkan penyedia kredensional 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.

  1. Tambahkan AWSSDK. SecurityToken NuGet paket untuk solusinya.

    <PackageReference Include="AWSSDK.SecurityToken" Version="latest version" />

  2. Gunakan paket SecurityToken dan SecurityToken.Model.

    using Amazon.SecurityToken;
using Amazon.SecurityToken.Model;

  3. 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. 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"
)

  2. 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.

  1. Impor boto3.

    import boto3

  2. 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. 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);
});