Richten Sie ein IAM Richten Sie ein VPC Ändern Sie den DAX Client, um kontoübergreifenden Zugriff zu ermöglichen

DAX AWS Kontenübergreifender Zugriff

Stellen Sie sich vor, Sie haben einen DynamoDB Accelerator (DAX) -Cluster, der in einem AWS Konto (Konto A) läuft und der DAX Cluster muss von einer Amazon Elastic Compute Cloud (AmazonEC2) -Instance in einem anderen AWS Konto (Konto B) aus zugänglich sein. In diesem Tutorial starten Sie dazu eine EC2 Instance in Konto B mit einer IAM Rolle von Konto B. Anschließend verwenden Sie temporäre Sicherheitsanmeldedaten von der EC2 Instance, um eine IAM Rolle von Konto A anzunehmen. Schließlich verwenden Sie die temporären Sicherheitsanmeldedaten von der Übernahme der IAM Rolle in Konto A, um Anwendungsaufrufe über eine VPC Amazon-Peering-Verbindung zum DAX Cluster in Konto A durchzuführen. Um diese Aufgaben ausführen zu können, benötigen Sie Administratorzugriff für beide AWS Konten.

Wichtig

Es ist nicht möglich, dass ein DAX Cluster von einem anderen Konto aus auf eine DynamoDB-Tabelle zugreift.

Themen

Richten Sie ein IAM
Richten Sie ein VPC
Ändern Sie den DAX Client, um kontoübergreifenden Zugriff zu ermöglichen

Richten Sie ein IAM

Erstellen Sie eine Textdatei AssumeDaxRoleTrust.json mit dem folgenden Inhalt, die es Amazon ermöglicht, in Ihrem Namen EC2 zu arbeiten.


{
    "Version": "2012-10-17",
    "Statement": [
        {
            "Effect": "Allow",
            "Principal": {
                "Service": "ec2.amazonaws.com"
            },
            "Action": "sts:AssumeRole"
        }
    ]
}

Erstellen Sie in Konto B eine Rolle, die Amazon beim Starten von Instances verwenden EC2 kann.


aws iam create-role \
    --role-name AssumeDaxRole \
    --assume-role-policy-document file://AssumeDaxRoleTrust.json

Erstellen Sie eine Textdatei AssumeDaxRolePolicy.json mit dem folgenden Inhalt, die es Code ermöglicht, der auf der EC2 Instance in Konto B ausgeführt wird, eine IAM Rolle in Konto A anzunehmen. Ersetzen accountA mit der tatsächlichen ID von Konto A.
```
{
    "Version": "2012-10-17",
    "Statement": [
        {
            "Effect": "Allow",
            "Action": "sts:AssumeRole",
            "Resource": "arn:aws:iam::accountA:role/DaxCrossAccountRole"
        }
    ]
}
```

Fügen Sie diese Richtlinie der gerade erstellten Rolle hinzu.


aws iam put-role-policy \
    --role-name AssumeDaxRole \
    --policy-name AssumeDaxRolePolicy \
    --policy-document file://AssumeDaxRolePolicy.json

Erstellen Sie ein Instance-Profil, damit Instances die Rolle verwenden können.


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

Ordnen Sie die Rolle dem Instance-Profil zu.


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

Erstellen Sie die Textdatei DaxCrossAccountRoleTrust.json mit dem folgenden Inhalt, der es Konto B gestattet, eine Rolle von Kontos A zu übernehmen. Ersetzen accountB mit der tatsächlichen ID von Konto B.


{
    "Version": "2012-10-17",
    "Statement": [
        {
            "Effect": "Allow",
            "Principal": {
                "AWS": "arn:aws:iam::accountB:role/AssumeDaxRole"
            },
            "Action": "sts:AssumeRole"
        }
    ]
}

Erstellen Sie in Konto A die Rolle, die Konto B übernehmen kann.


aws iam create-role \
    --role-name DaxCrossAccountRole \
    --assume-role-policy-document file://DaxCrossAccountRoleTrust.json

Erstellen Sie eine Textdatei mit dem NamenDaxCrossAccountPolicy.json, die den Zugriff auf den DAX Cluster ermöglicht. Ersetzen dax-cluster-arn mit dem richtigen Amazon-Ressourcennamen (ARN) Ihres DAX Clusters.


{
    "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": "dax-cluster-arn"
        }
    ]
}

Fügen Sie in Konto A die Richtlinie zur Rolle hinzu.


aws iam put-role-policy \
    --role-name DaxCrossAccountRole \
    --policy-name DaxCrossAccountPolicy \
    --policy-document file://DaxCrossAccountPolicy.json

Richten Sie ein VPC

Suchen Sie die Subnetzgruppe des DAX Clusters von Konto A. Ersetzen cluster-name mit dem Namen des DAX Clusters, auf den Konto B zugreifen muss.
```
aws dax describe-clusters \
    --cluster-name cluster-name
    --query 'Clusters[0].SubnetGroup'
```

Benutze das subnet-group, finde die des ClustersVPC.


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

Benutze das vpc-id, finde VPC dieCIDR.


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

Erstellen Sie aus Konto B ein und VPC verwenden Sie dabei ein anderes, sich nicht überschneidendes CIDR als das im vorherigen Schritt gefundene Konto. Erstellen Sie dann mindestens ein Subnetz. Sie können entweder den VPCErstellungsassistenten im AWS Management Console oder im verwenden. AWS CLI
Fordern Sie von Konto B aus eine Peering-Verbindung zu Konto A an, VPC wie unter Eine VPC Peering-Verbindung erstellen und annehmen beschrieben. Akzeptieren Sie die Verbindung in Konto A.
Suchen Sie von Konto B aus nach der Routingtabelle VPC des neuen Benutzers. Ersetzen vpc-id mit der ID, die VPC Sie in Konto B erstellt haben.
```
aws ec2 describe-route-tables \
    --filters 'Name=vpc-id,Values=vpc-id' \
    --query 'RouteTables[0].RouteTableId'
```
Fügen Sie eine Route hinzu, um Datenverkehr, der für Konto A bestimmt ist, CIDR an die VPC Peering-Verbindung weiterzuleiten. Denken Sie daran, jeden zu ersetzen user input placeholder mit den richtigen Werten für Ihre Konten.
```
aws ec2 create-route \
    --route-table-id accountB-route-table-id \
    --destination-cidr accountA-vpc-cidr \
    --vpc-peering-connection-id peering-connection-id
```

Suchen Sie von Konto A aus die Routing-Tabelle des DAX Clusters mithilfe der vpc-id Sie haben es zuvor gefunden.


aws ec2 describe-route-tables \
    --filters 'Name=vpc-id, Values=accountA-vpc-id' \
    --query 'RouteTables[0].RouteTableId'

Fügen Sie von Konto A aus eine Route hinzu, um Traffic, der für Konto B bestimmt ist, an die VPC Peering-Verbindung CIDR weiterzuleiten. Ersetze jedes user input placeholder mit den richtigen Werten für Ihre Konten.
```
aws ec2 create-route \
    --route-table-id accountA-route-table-id \
    --destination-cidr accountB-vpc-cidr \
    --vpc-peering-connection-id peering-connection-id
```
Starten Sie von Konto B aus eine EC2 Instanz in demVPC, das Sie zuvor erstellt haben. Ordnen Sie ihr das AssumeDaxInstanceProfile zu. Sie können entweder den Startassistenten im AWS Management Console oder im verwenden AWS CLI. Notieren Sie sich die Sicherheitsgruppe der Instance.
Suchen Sie von Konto A aus nach der Sicherheitsgruppe, die vom DAX Cluster verwendet wird. Denken Sie daran, es zu ersetzen cluster-name mit dem Namen Ihres DAX Clusters.
```
aws dax describe-clusters \
    --cluster-name cluster-name \
    --query 'Clusters[0].SecurityGroups[0].SecurityGroupIdentifier'
```
Aktualisieren Sie die Sicherheitsgruppe des DAX Clusters, um eingehenden Datenverkehr von der Sicherheitsgruppe der EC2 Instance zuzulassen, die Sie in Konto B erstellt haben. Denken Sie daran, die user input placeholders mit den richtigen Werten für Ihre Konten.
```
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
```

Zu diesem Zeitpunkt kann eine Anwendung auf der EC2 Instanz von Konto B das Instanzprofil verwenden, um die arn:aws:iam::accountA-id:role/DaxCrossAccountRole Rolle zu übernehmen und den DAX Cluster zu verwenden.

Ändern Sie den DAX Client, um kontoübergreifenden Zugriff zu ermöglichen

Anmerkung

AWS Security Token Service (AWS STS) Anmeldeinformationen sind temporäre Anmeldeinformationen. Einige Clients nehmen automatisch Aktualisierungen vor, während andere zusätzliche Logik benötigen, um die Anmeldeinformationen zu aktualisieren. Wir empfehlen Ihnen, die Anleitung der entsprechenden Dokumentation zu befolgen.

Java

In diesem Abschnitt können Sie Ihren bestehenden DAX Kundencode ändern, um kontoübergreifenden DAX Zugriff zu ermöglichen. Falls Sie noch keinen DAX Kundencode haben, finden Sie im Java und DAX Tutorial funktionierende Codebeispiele.

Fügen Sie die folgenden Importe hinzu.


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

Rufen Sie einen Anbieter für Anmeldeinformationen von ab AWS STS und erstellen Sie ein DAX Client-Objekt. Denken Sie daran, jedes zu ersetzen user input placeholder mit den richtigen Werten für Ihre Konten.


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

Füge das hinzu AWSSDK. SecurityToken NuGet Paket zur Lösung.


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

Verwenden Sie die Pakete SecurityToken und SecurityToken.Model.


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

Fordern Sie temporäre Anmeldeinformationen von AmazonSimpleTokenService an und erstellen Sie ein ClusterDaxClient-Objekt. Denken Sie daran, jedes zu ersetzen user input placeholder mit den richtigen Werten für Ihre Konten.


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

Importieren Sie die Pakete AWS STS und die Session-Pakete.


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

Holen Sie sich temporäre Anmeldeinformationen von AmazonSimpleTokenService und erstellen Sie ein DAX Client-Objekt. Denken Sie daran, jedes zu ersetzen user input placeholder mit den richtigen Werten für Ihre Konten.


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

In diesem Abschnitt können Sie Ihren bestehenden DAX Kundencode ändern, um einen kontoübergreifenden DAX Zugriff zu ermöglichen. Falls Sie noch keinen DAX Kundencode haben, finden Sie im Python und DAX Tutorial funktionierende Codebeispiele.

Importieren Sie boto3.
```
import boto3
```

Fordern Sie temporäre Anmeldeinformationen von sts an und erstellen Sie ein AmazonDaxClient-Objekt. Denken Sie daran, jeden zu ersetzen user input placeholder mit den richtigen Werten für Ihre Konten.


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

In diesem Abschnitt können Sie Ihren bestehenden DAX Kundencode ändern, um einen kontoübergreifenden DAX Zugriff zu ermöglichen. Falls Sie noch keinen DAX Kundencode haben, finden Sie im Node.js und DAX Tutorial funktionierende Codebeispiele. Denken Sie daran, jeden zu ersetzen user input placeholder mit den richtigen Werten für Ihre Konten.


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

Warnung JavaScript ist in Ihrem Browser nicht verfügbar oder deaktiviert.

Zur Nutzung der AWS-Dokumentation muss JavaScript aktiviert sein. Weitere Informationen finden auf den Hilfe-Seiten Ihres Browsers.

Dokumentkonventionen

Verwenden von serviceverknüpften Rollen für DAX

DAX-Clustergrößenleitfaden