Configurazione di IAM Configurazione di un VPC Modifica del client DAX per consentire l'accesso multi-account

Accesso a DAX su più account AWS

Immagina di avere un cluster DynamoDB Accelerator (DAX) in esecuzione in AWS un account (account A) e che il cluster DAX debba essere accessibile da un'istanza Amazon Elastic Compute Cloud (Amazon EC2) in un altro account (account B). AWS In questo tutorial puoi eseguire questa operazione avviando un'istanza EC2 nell'account B con un ruolo dall'account B. Quindi puoi utilizzare le credenziali di sicurezza temporanee dell'istanza EC2 per assumere un ruolo IAM dall'account A. Infine, utilizzi le credenziali di sicurezza temporanee per assumere il ruolo IAM nell'account A per effettuare chiamate all'applicazione tramite una connessione peering di Amazon VPC al cluster DAX nell'account A. Per eseguire queste attività è necessario l'accesso amministrativo in entrambi gli account AWS .

Importante

Non è possibile fare in modo che un cluster DAX acceda a una tabella DynamoDB da un account diverso.

Argomenti

Configurazione di IAM
Configurazione di un VPC
Modifica del client DAX per consentire l'accesso multi-account

Configurazione di IAM

Crea un file di testo denominato AssumeDaxRoleTrust.json con il seguente contenuto che consente a Amazon EC2 di lavorare per conto tuo.

Nell'account B, creare un ruolo che Amazon EC2 può utilizzare durante l'avvio delle istanze.


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

Crea un file di testo denominato AssumeDaxRolePolicy.json con il seguente contenuto, che consente al codice in esecuzione sull'istanza EC2 nell'account B di assumere un ruolo IAM nell'account A. Sostituiscilo con l'ID effettivo dell'account A. accountA

Aggiungi la policy al ruolo appena creato.


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

Crea un profilo di istanza per consentire alle istanze di utilizzare il ruolo.


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

Associa il ruolo al profilo di istanza.


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

Crea un file di testo denominato DaxCrossAccountRoleTrust.json con il contenuto seguente che consente all'account B di assumere un ruolo dell'account A. Sostituisci accountB con l'ID effettivo dell'account B.

Nell'account A, crea il ruolo che l'account B può assumere.


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

Crea un file di testo denominato DaxCrossAccountPolicy.json che consente l'accesso al cluster DAX. Sostituiscilo dax-cluster-arn con l'Amazon Resource Name (ARN) corretto del tuo cluster DAX.

Nell'account A, aggiungi la policy al ruolo.


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

Configurazione di un VPC

Individuare il gruppo di sottoreti del cluster DAX dell'account A. Sostituiscilo cluster-name con il nome del cluster DAX a cui deve accedere l'account B.
```
aws dax describe-clusters \
    --cluster-name cluster-name
    --query 'Clusters[0].SubnetGroup'
```

Usandolosubnet-group, trova il VPC del cluster.


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

Usandolovpc-id, trova il CIDR del VPC.


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

Dall'account B, crea un VPC utilizzando un CIDR diverso, non sovrapposto rispetto a quello trovato nel passaggio precedente. Quindi, crea almeno una subnet. È possibile utilizzare la procedura guidata per la creazione di VPC in o in. AWS Management Console AWS CLI
Dall'account B, richiedi una connessione peering al VPC dell'account A come descritto in Creazione e accettazione di una connessione peering VPC. Dall'account A, accetta la connessione.
Dall'account B, trova la tabella di routing del nuovo VPC. Sostituisci vpc-id con l'ID del VPC che hai creato nell'account B.
```
aws ec2 describe-route-tables \
    --filters 'Name=vpc-id,Values=vpc-id' \
    --query 'RouteTables[0].RouteTableId'
```
Aggiungi un percorso per inviare il traffico destinato al CIDR dell'account A alla connessione peering VPC. Ricordati di sostituirli user input placeholder con i valori corretti per i tuoi account.
```
aws ec2 create-route \
    --route-table-id accountB-route-table-id \
    --destination-cidr accountA-vpc-cidr \
    --vpc-peering-connection-id peering-connection-id
```
Dall'account A, trova la tabella di routing del cluster DAX utilizzando la tabella di routing vpc-id che hai trovato in precedenza.
```
aws ec2 describe-route-tables \
    --filters 'Name=vpc-id, Values=accountA-vpc-id' \
    --query 'RouteTables[0].RouteTableId'
```
Dall'account A, aggiungi un percorso per inviare il traffico destinato al CIDR dell'account B alla connessione peering VPC. Sostituisci user input placeholder ognuna con i valori corretti per i tuoi account.
```
aws ec2 create-route \
    --route-table-id accountA-route-table-id \
    --destination-cidr accountB-vpc-cidr \
    --vpc-peering-connection-id peering-connection-id
```
Dall'account B, avvia un'istanza EC2 nel VPC creato in precedenza. Assegnarle il nome AssumeDaxInstanceProfile. È possibile utilizzare la procedura guidata di avvio in AWS Management Console o in. AWS CLI Prendi nota del gruppo di sicurezza dell'istanza.
Dall'account A, individua il gruppo di sicurezza utilizzato dal cluster DAX. Ricordarsi di sostituirlo cluster-name con il nome del cluster DAX.
```
aws dax describe-clusters \
    --cluster-name cluster-name \
    --query 'Clusters[0].SecurityGroups[0].SecurityGroupIdentifier'
```
Aggiorna il gruppo di sicurezza del cluster DAX per consentire il traffico in entrata dal gruppo di sicurezza dell'istanza EC2 che hai creato nell'account B. Ricordati di sostituirlo user input placeholders con i valori corretti per i tuoi account.
```
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
```

A questo punto, un'applicazione nell'istanza EC2 dell'account B è in grado di utilizzare il profilo dell'istanza per assumere il ruolo arn:aws:iam::accountA-id:role/DaxCrossAccountRole e utilizzare il cluster DAX.

Modifica del client DAX per consentire l'accesso multi-account

Nota

AWS Security Token Service (AWS STS) le credenziali sono credenziali temporanee. Alcuni client gestiscono automaticamente l'aggiornamento, mentre altri richiedono una logica aggiuntiva per aggiornare le credenziali. Consigliamo di seguire le indicazioni della documentazione appropriata.

Java

Aggiungi le seguenti importazioni:


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

Ottieni un provider di credenziali da AWS STS e crea un oggetto client DAX. Ricordati di sostituirli user input placeholder con i valori corretti per i tuoi account.


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

Aggiungi il AWSSDK. SecurityToken NuGet pacchetto alla soluzione.


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

Usa i pacchetti SecurityToken.Model e SecurityToken.


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

Ottieni le credenziali temporanee da AmazonSimpleTokenService e crea un oggetto ClusterDaxClient. Ricordati di sostituirli user input placeholder con i valori corretti per i tuoi account.


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

Questa sezione consente di modificare il codice client DAX esistente per consentire l'accesso DAX tra account. Se non disponi già del codice client DAX, puoi trovare esempi di codice funzionanti su GitHub.

Importa i pacchetti AWS STS e le sessioni.


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

Ottenere le credenziali temporanee da AmazonSimpleTokenService e creare un oggetto client DAX. Ricordati di sostituirli user input placeholder con i valori corretti per i tuoi account.


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

Questa sezione consente di modificare il codice client DAX esistente per consentire l'accesso DAX tra account. Se non hai già un codice client DAX, puoi trovare esempi di codice funzionanti nel tutorial Python e DAX.

Importa boto3.
```
import boto3
```

Ottieni credenziali temporanee da sts e crea un oggetto AmazonDaxClient. Ricordati di sostituirli user input placeholder con i valori corretti per i tuoi account.


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


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

Avvertimento JavaScript è disabilitato o non è disponibile nel tuo browser.

Per usare la documentazione AWS, JavaScript deve essere abilitato. Consulta le pagine della guida del browser per le istruzioni.

Convenzioni dei documenti

Utilizzo di ruoli collegati ai servizi per DAX

Guida alle dimensioni del cluster DAX