Configurazione di IAM Configura un VPC Modifica il DAX client per consentire l'accesso a più account

Accesso a DAX più AWS account

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

Importante

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

Argomenti

Configurazione di IAM
Configura un VPC
Modifica il DAX client per consentire l'accesso a più account

Configurazione di IAM

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


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

Nell'account B, crea un ruolo che Amazon EC2 può utilizzare per 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 consenta al codice in esecuzione sull'EC2istanza dell'account B di assumere un IAM ruolo nell'account A. Sostituiscilo accountA con l'ID effettivo dell'account A.


{
    "Version": "2012-10-17",
    "Statement": [
        {
            "Effect": "Allow",
            "Action": "sts:AssumeRole",
            "Resource": "arn:aws:iam::accountA:role/DaxCrossAccountRole"
        }
    ]
}

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.


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

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


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

Nell'account A, aggiungi la policy al ruolo.


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

Configura un VPC

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

Usandolosubnet-group, trova quello del clusterVPC.


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

vpc-idUsandolo, trova VPC iCIDR.


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

Dall'account B, crea un VPC utilizzando un account diverso e non sovrapposto CIDR rispetto a quello trovato nel passaggio precedente. Quindi, crea almeno una subnet. È possibile utilizzare la procedura guidata VPC di creazione in o in. AWS Management Console AWS CLI
Dall'account B, richiedi una connessione peering all'account A VPC come descritto in Creazione e accettazione di una connessione VPC peering. Dall'account A, accetta la connessione.

Dall'account B, trova la nuova tabella VPC di routing. Sostituisci vpc-id con l'ID 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 all'account A CIDR alla connessione VPC peering. 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 DAX cluster utilizzando quella 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 all'account B CIDR alla connessione VPC peering. Sostituiscili user input placeholder 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'EC2istanza nell'account VPC che hai 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. Ricordati di sostituirlo cluster-name con il nome del tuo DAX cluster.
```
aws dax describe-clusters \
    --cluster-name cluster-name \
    --query 'Clusters[0].SecurityGroups[0].SecurityGroupIdentifier'
```
Aggiorna il gruppo di sicurezza del DAX cluster per consentire il traffico in entrata dal gruppo di sicurezza dell'EC2istanza che hai creato nell'account B. Ricorda 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 sull'EC2istanza dell'account B è in grado di utilizzare il profilo dell'istanza per assumere il arn:aws:iam::accountA-id:role/DaxCrossAccountRole ruolo e utilizzare il DAX cluster.

Modifica il DAX client per consentire l'accesso a più 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 fornitore di credenziali AWS STS e crea un DAX oggetto client. 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à di un codice DAX cliente, 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"
)

Ottieni le credenziali temporanee da AmazonSimpleTokenService e crea 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à di 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

DAXguida al dimensionamento dei cluster