Einrichten von 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

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

Einrichten von 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. accountA Ersetzen Sie sie durch die tatsächliche 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. accountBDurch die tatsächliche ID von Konto B ersetzen.


{
    "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 Namen DaxCrossAccountPolicy.json, die den Zugriff auf den DAX-Cluster ermöglicht. dax-cluster-arnErsetzen Sie es durch den 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. cluster-nameErsetzen Sie ihn durch den Namen des DAX Clusters, auf den Konto B zugreifen muss.
```
aws dax describe-clusters \
    --cluster-name cluster-name
    --query 'Clusters[0].SubnetGroup'
```

Suchen Sie damit subnet-group nach dem ClusterVPC.


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

Finden Sie damit vpc-id die VPC'sCIDR.


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

Erstellen Sie aus Konto B ein und VPC verwenden Sie dabei ein anderes, nicht überlappendes Konto CIDR als das, das Sie im vorherigen Schritt gefunden haben. 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. vpc-idErsetzen Sie es durch die ID des Kontos, das 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 Wert user input placeholder durch die richtigen Werte für Ihre Konten zu ersetzen.
```
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 nach der Routing-Tabelle des DAX Clusters, indem vpc-id Sie die zuvor gefundene Tabelle verwenden.


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 den für Konto B bestimmten Datenverkehr an die VPC Peering-Verbindung CIDR weiterzuleiten. Ersetzen Sie jeden Wert user input placeholder durch die richtigen Werte 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 in Konto A die Sicherheitsgruppe, die vom DAX-Cluster verwendet wird. Denken Sie daran, es cluster-name durch den Namen Ihres DAX Clusters zu ersetzen.
```
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 durch die richtigen Werte für Ihre Konten zu ersetzen.
```
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

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, jeden Wert user input placeholder durch die richtigen Werte für Ihre Konten zu ersetzen.


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, jeden Wert user input placeholder durch die richtigen Werte für Ihre Konten zu ersetzen.


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

Dieser Abschnitt unterstützt Sie beim Ändern Ihres vorhandenen DAX-Clientcodes, um kontoübergreifenden DAX-Zugriff zu ermöglichen. Falls Sie noch keinen DAX Kundencode haben, finden Sie funktionierende Codebeispiele unter GitHub.

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

Fordern Sie temporäre Anmeldeinformationen von AmazonSimpleTokenService an und erstellen Sie ein DAX-Clientobjekt. Denken Sie daran, jeden Wert user input placeholder durch die richtigen Werte für Ihre Konten zu ersetzen.


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

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

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


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

Dieser Abschnitt unterstützt Sie beim Ändern Ihres vorhandenen DAX-Clientcodes, um kontoübergreifenden DAX-Zugriff zu ermöglichen. Wenn Sie noch keinen DAX-Clientcode haben, finden Sie Beispiele von funktionierendem Code im Tutorial Node.js und DAX. Denken Sie daran, jeden Wert user input placeholder durch die richtigen Werte für Ihre Konten zu ersetzen.


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

DAXLeitfaden zur Clustergröße