Esempi di utilizzo dell’ABAC con tabelle e indici DynamoDB - Amazon DynamoDB
Esempio 1: consenti un'azione utilizzando aws: ResourceTagEsempio 2: consenti un'azione utilizzando aws: RequestTagEsempio 3: Negare un'azione utilizzando aws: TagKeys

Le traduzioni sono generate tramite traduzione automatica. In caso di conflitto tra il contenuto di una traduzione e la versione originale in Inglese, quest'ultima prevarrà.

Esempi di utilizzo dell’ABAC con tabelle e indici DynamoDB

Gli esempi seguenti illustrano alcuni casi d’uso per implementare condizioni basate su attributi utilizzando i tag.

Esempio 1: consenti un'azione utilizzando aws: ResourceTag

Utilizzando la chiave di condizione aws:ResourceTag/tag-key è possibile confrontare la coppia chiave-valore del tag specificata in una policy IAM con la coppia chiave-valore collegata in una tabella DynamoDB. Ad esempio, puoi consentire un'azione specifica, ad esempio se le condizioni del tag corrispondono in una politica IAM e in una tabella. PutItem A tal fine, segui questa procedura:

Using the AWS CLI

  1. Creare una tabella . L'esempio seguente utilizza il AWS CLI comando create-table per creare una tabella denominata. myMusicTable

    aws dynamodb create-table \
  --table-name myMusicTable \
  --attribute-definitions AttributeName=id,AttributeType=S \
  --key-schema AttributeName=id,KeyType=HASH \
  --provisioned-throughput ReadCapacityUnits=5,WriteCapacityUnits=5 \
  --region us-east-1

  2. Aggiungi un tag a questa tabella. Il seguente esempio di AWS CLI comando tag-resource aggiunge la coppia chiave-valore del tag a. Title: ProductManager myMusicTable

    aws dynamodb tag-resource --region us-east-1 --resource-arn arn:aws:dynamodb:us-east-1:123456789012:table/myMusicTable --tags Key=Title,Value=ProductManager

  3. Create una policy in linea e aggiungetela a un ruolo a cui è associata la policy AmazonDynamoDBReadOnlyAccess AWS gestita, come illustrato nell'esempio seguente.

    JSON
    JSON
    {
  "Version":"2012-10-17",		 	 	 
  "Statement": [
    {
      "Effect": "Allow",
      "Action": "dynamodb:PutItem",
      "Resource": "arn:aws:dynamodb:*:*:table/*",
      "Condition": {
        "StringEquals": {
          "aws:ResourceTag/Title": "ProductManager"
        }
      }
    }
  ]
}

    Questa policy consente l’azione PutItem sulla tabella quando la chiave e il valore del tag associati alla tabella corrispondono ai tag specificati nella policy.

  4. Assumi il ruolo con le policy descritte nella Fase 3.

  5. Usa il AWS CLI comando put-item per inserire un elemento in. myMusicTable

    aws dynamodb put-item \
    --table-name myMusicTable --region us-east-1 \
    --item '{
        "id": {"S": "2023"},
        "title": {"S": "Happy Day"},
        "info": {"M": {
            "rating": {"N": "9"},
            "Artists": {"L": [{"S": "Acme Band"}, {"S": "No One You Know"}]},
            "release_date": {"S": "2023-07-21"}
        }}
    }'

  6. Scansiona la tabella per verificare se l’elemento è stato aggiunto alla tabella.

    aws dynamodb scan --table-name myMusicTable  --region us-east-1
Using the AWS SDK for Java 2.x

  1. Creare una tabella . L'esempio seguente utilizza l'CreateTableAPI per creare una tabella denominata. myMusicTable

    DynamoDbClient dynamoDB = DynamoDbClient.builder().region(region).build();
CreateTableRequest createTableRequest = CreateTableRequest.builder()
    .attributeDefinitions(
        Arrays.asList(
            AttributeDefinition.builder()
            .attributeName("id")
            .attributeType(ScalarAttributeType.S)
            .build()
        )
    )
    .keySchema(
        Arrays.asList(
            KeySchemaElement.builder()
            .attributeName("id")
            .keyType(KeyType.HASH)
            .build()
        )
    )
    .provisionedThroughput(ProvisionedThroughput.builder()
        .readCapacityUnits(5L)
        .writeCapacityUnits(5L)
        .build()
    )
    .tableName("myMusicTable")
    .build();

CreateTableResponse createTableResponse = dynamoDB.createTable(createTableRequest);
String tableArn = createTableResponse.tableDescription().tableArn();
String tableName = createTableResponse.tableDescription().tableName();

  2. Aggiungi un tag a questa tabella. L'TagResourceAPI nell'esempio seguente aggiunge la coppia chiave-valore del tag Title: ProductManager a. myMusicTable

    TagResourceRequest tagResourceRequest = TagResourceRequest.builder()
    .resourceArn(tableArn)
    .tags(
        Arrays.asList(
            Tag.builder()
            .key("Title")
            .value("ProductManager")
            .build()
        )
    )
    .build();
dynamoDB.tagResource(tagResourceRequest);

  3. Create una policy in linea e aggiungetela a un ruolo a cui è associata la policy AmazonDynamoDBReadOnlyAccess AWS gestita, come illustrato nell'esempio seguente.

    JSON
    JSON
    {
  "Version":"2012-10-17",		 	 	 
  "Statement": [
    {
      "Effect": "Allow",
      "Action": "dynamodb:PutItem",
      "Resource": "arn:aws:dynamodb:*:*:table/*",
      "Condition": {
        "StringEquals": {
          "aws:ResourceTag/Title": "ProductManager"
        }
      }
    }
  ]
}

    Questa policy consente l’azione PutItem sulla tabella quando la chiave e il valore del tag associati alla tabella corrispondono ai tag specificati nella policy.

  4. Assumi il ruolo con le policy descritte nella Fase 3.

  5. Usa l'PutItemAPI per inserire un elemento in. myMusicTable

    HashMap<String, AttributeValue> info = new HashMap<>();
info.put("rating", AttributeValue.builder().s("9").build());
info.put("artists", AttributeValue.builder().ss(List.of("Acme Band","No One You Know").build());
info.put("release_date", AttributeValue.builder().s("2023-07-21").build());

HashMap<String, AttributeValue> itemValues = new HashMap<>();
itemValues.put("id", AttributeValue.builder().s("2023").build());
itemValues.put("title", AttributeValue.builder().s("Happy Day").build());
itemValues.put("info", AttributeValue.builder().m(info).build());


PutItemRequest putItemRequest = PutItemRequest.builder()
                .tableName(tableName)
                .item(itemValues)
                .build();
dynamoDB.putItem(putItemRequest);

  6. Scansiona la tabella per verificare se l’elemento è stato aggiunto alla tabella.

    ScanRequest scanRequest = ScanRequest.builder()
                .tableName(tableName)
                .build();
                
ScanResponse scanResponse = dynamoDB.scan(scanRequest);
Using the AWS SDK per Python (Boto3)

  1. Creare una tabella . L'esempio seguente utilizza l'CreateTableAPI per creare una tabella denominatamyMusicTable.

    create_table_response = ddb_client.create_table(
    AttributeDefinitions=[
        {
            'AttributeName': 'id',
            'AttributeType': 'S'
        },
    ],
    TableName='myMusicTable',
    KeySchema=[
        {
            'AttributeName': 'id',
            'KeyType': 'HASH'
        },
    ],
        ProvisionedThroughput={
        'ReadCapacityUnits': 5,
        'WriteCapacityUnits': 5
    },
)

table_arn = create_table_response['TableDescription']['TableArn']

  2. Aggiungi un tag a questa tabella. L'TagResourceAPI nell'esempio seguente aggiunge la coppia chiave-valore del tag Title: ProductManager a. myMusicTable

    tag_resouce_response = ddb_client.tag_resource(
    ResourceArn=table_arn,
    Tags=[
        {
            'Key': 'Title',
            'Value': 'ProductManager'
        },
    ]
)

  3. Create una policy in linea e aggiungetela a un ruolo a cui è associata la policy AmazonDynamoDBReadOnlyAccess AWS gestita, come illustrato nell'esempio seguente.

    JSON
    JSON
    {
    "Version":"2012-10-17",		 	 	 
    "Statement": [
        {
        "Effect": "Allow",
        "Action": "dynamodb:PutItem",
        "Resource": "arn:aws:dynamodb:*:*:table/*",
        "Condition": {
            "StringEquals": {
            "aws:ResourceTag/Title": "ProductManager"
            }
        }
        }
    ]
    }

    Questa policy consente l’azione PutItem sulla tabella quando la chiave e il valore del tag associati alla tabella corrispondono ai tag specificati nella policy.

  4. Assumi il ruolo con le policy descritte nella Fase 3.

  5. Usa l'PutItemAPI per inserire un elemento in. myMusicTable

    put_item_response = client.put_item(
    TableName = 'myMusicTable'
    Item = {
        'id': '2023',
        'title': 'Happy Day',
        'info': {
            'rating': '9',
            'artists': ['Acme Band','No One You Know'],
            'release_date': '2023-07-21'
        }
    }
)

  6. Scansiona la tabella per verificare se l’elemento è stato aggiunto alla tabella.

    scan_response = client.scan(
    TableName='myMusicTable'
)
Senza ABAC

Se ABAC non è abilitato per te Account AWS, le condizioni dei tag nella policy IAM e nella tabella DynamoDB non corrispondono. Di conseguenza, l’azione PutItem restituirà una AccessDeniedException a causa dell’effetto della policy AmazonDynamoDBReadOnlyAccess.

An error occurred (AccessDeniedException) when calling the PutItem operation: User: arn:aws:sts::123456789012:assumed-role/DynamoDBReadOnlyAccess/Alice is not authorized to perform: dynamodb:PutItem on resource: arn:aws:dynamodb:us-east-1:123456789012:table/myMusicTable because no identity-based policy allows the dynamodb:PutItem action.
Con ABAC

Se ABAC è abilitato per la tua Account AWS, l'put-itemazione viene completata correttamente e aggiunge un nuovo elemento alla tua tabella. Questo perché la policy in linea sulla tabella consente l’azione PutItem se le condizioni del tag nella policy IAM e nella tabella corrispondono.

Esempio 2: consenti un'azione utilizzando aws: RequestTag

Utilizzando la chiave di condizione aws: RequestTag /tag-key, puoi confrontare la coppia chiave-valore del tag passata nella tua richiesta con la coppia di tag specificata nella policy IAM. Ad esempio, è possibile consentire un’azione specifica, come CreateTable, usando aws:RequestTag se le condizioni del tag non corrispondono. A tal fine, segui questa procedura:

Using the AWS CLI

  1. Crea una policy in linea e aggiungila a un ruolo a cui è associata la policy AmazonDynamoDBReadOnlyAccess AWS gestita, come mostrato nell'esempio seguente.

    JSON
    JSON
    {
    "Version":"2012-10-17",		 	 	 
    "Statement": [
        {
            "Effect": "Allow",
            "Action": [
                "dynamodb:CreateTable",
                "dynamodb:TagResource"
            ],
            "Resource": "arn:aws:dynamodb:*:*:table/*",
            "Condition": {
                "StringEquals": {
                    "aws:RequestTag/Owner": "John"
                }
            }
        }
    ]
}

  2. Crea una tabella che contenga la coppia chiave-valore del tag di "Owner": "John".

    aws dynamodb create-table \
--attribute-definitions AttributeName=ID,AttributeType=S \
--key-schema AttributeName=ID,KeyType=HASH  \
--provisioned-throughput ReadCapacityUnits=1000,WriteCapacityUnits=500 \
--region us-east-1 \
--tags Key=Owner,Value=John \
--table-name myMusicTable
Using the AWS SDK per Python (Boto3)

  1. Create una policy in linea e aggiungetela a un ruolo a cui è associata la policy AmazonDynamoDBReadOnlyAccess AWS gestita, come illustrato nell'esempio seguente.

    JSON
    JSON
    {
    "Version":"2012-10-17",		 	 	 
    "Statement": [
        {
            "Effect": "Allow",
            "Action": [
                "dynamodb:CreateTable",
                "dynamodb:TagResource"
            ],
            "Resource": "arn:aws:dynamodb:*:*:table/*",
            "Condition": {
                "StringEquals": {
                    "aws:RequestTag/Owner": "John"
                }
            }
        }
    ]
}

  2. Crea una tabella che contenga la coppia chiave-valore del tag di "Owner": "John".

    ddb_client = boto3.client('dynamodb')

create_table_response = ddb_client.create_table(
    AttributeDefinitions=[
        {
            'AttributeName': 'id',
            'AttributeType': 'S'
        },
    ],
    TableName='myMusicTable',
    KeySchema=[
        {
            'AttributeName': 'id',
            'KeyType': 'HASH'
        },
    ],
        ProvisionedThroughput={
        'ReadCapacityUnits': 1000,
        'WriteCapacityUnits': 500
    },
    Tags=[
        {
            'Key': 'Owner',
            'Value': 'John'
        },
    ],
)
Senza ABAC

Se ABAC non è abilitato per te Account AWS, le condizioni dei tag nella politica in linea e nella tabella DynamoDB non corrispondono. Di conseguenza, la richiesta CreateTable non andrà a buon fine e la tabella non verrà creata.

An error occurred (AccessDeniedException) when calling the CreateTable operation: User: arn:aws:sts::123456789012:assumed-role/Admin/John is not authorized to perform: dynamodb:CreateTable on resource: arn:aws:dynamodb:us-east-1:123456789012:table/myMusicTable because no identity-based policy allows the dynamodb:CreateTable action.
Con ABAC

Se ABAC è abilitato per la tua Account AWS, la richiesta di creazione della tabella viene completata correttamente. Poiché la coppia chiave-valore del tag "Owner": "John" è presente nella richiesta CreateTable, la policy in linea consente all’utente John di eseguire l’azione CreateTable.

Esempio 3: Negare un'azione utilizzando aws: TagKeys

Utilizzando la chiave aws: TagKeys condition, puoi confrontare le chiavi dei tag in una richiesta con le chiavi specificate nella policy IAM. Ad esempio, è possibile negare un’azione specifica, come CreateTable, utilizzando aws:TagKeys se una chiave di tag specifica non è presente nella richiesta. A tal fine, segui questa procedura:

Using the AWS CLI

  1. Aggiungi una policy gestita dai clienti a un ruolo a cui è associata la policy AWS gestita di AmazonDynamoDBFullAccess, come illustrato nell'esempio seguente.

    JSON
    JSON
    {
    "Version":"2012-10-17",		 	 	 
    "Statement": [
        {
            "Effect": "Deny",
            "Action": [
                "dynamodb:CreateTable",
                "dynamodb:TagResource"
            ],
            "Resource": "arn:aws:dynamodb:*:*:table/*",
            "Condition": {
                "Null": {
                    "aws:TagKeys": "false"
                },
                "ForAllValues:StringNotEquals": {
                    "aws:TagKeys": "CostCenter"
                }
            }
        }
    ]
}

  2. Assumi il ruolo a cui è stata associata la policy e crea una tabella con la chiave del tag Title.

    aws dynamodb create-table \
--attribute-definitions AttributeName=ID,AttributeType=S \
--key-schema AttributeName=ID,KeyType=HASH  \
--provisioned-throughput ReadCapacityUnits=1000,WriteCapacityUnits=500 \
--region us-east-1 \
--tags Key=Title,Value=ProductManager \
--table-name myMusicTable
Using the AWS SDK per Python (Boto3)

  1. Aggiungere una politica gestita dai clienti a un ruolo a cui è associata la politica di AWS gestione degli AmazonDynamoDBFullaccessi, come illustrato nell'esempio seguente.

    JSON
    JSON
    {
    "Version":"2012-10-17",		 	 	 
    "Statement": [
        {
            "Effect": "Deny",
            "Action": [
                "dynamodb:CreateTable",
                "dynamodb:TagResource"
            ],
            "Resource": "arn:aws:dynamodb:*:*:table/*",
            "Condition": {
                "Null": {
                    "aws:TagKeys": "false"
                },
                "ForAllValues:StringNotEquals": {
                    "aws:TagKeys": "CostCenter"
                }
            }
        }
    ]
}

  2. Assumi il ruolo a cui è stata associata la policy e crea una tabella con la chiave del tag Title.

    ddb_client = boto3.client('dynamodb')

create_table_response = ddb_client.create_table(
    AttributeDefinitions=[
        {
            'AttributeName': 'id',
            'AttributeType': 'S'
        },
    ],
    TableName='myMusicTable',
    KeySchema=[
        {
            'AttributeName': 'id',
            'KeyType': 'HASH'
        },
    ],
        ProvisionedThroughput={
        'ReadCapacityUnits': 1000,
        'WriteCapacityUnits': 500
    },
    Tags=[
        {
            'Key': 'Title',
            'Value': 'ProductManager'
        },
    ],
)
Senza ABAC

Se ABAC non è abilitato per il tuo Account AWS, DynamoDB non invia le chiavi dei tag nel create-table comando a IAM. La condizione Null garantisce che la condizione restituisca false in assenza di chiavi di tag nella richiesta. Poiché la policy Deny non corrisponde, il comando create-table verrà completato correttamente.

Con ABAC

Se ABAC è abilitato per il tuo Account AWS, le chiavi dei tag passate nel create-table comando vengono passate a IAM. La chiave del tag Title verrà valutata rispetto alla chiave del tag basata sulla condizione, CostCenter, presente nella policy Deny. La chiave del tag Title non corrisponde alla chiave del tag presente nella policy Deny a causa dell’operatore StringNotEquals. Pertanto, l’azione CreateTable non andrà a buon fine e la tabella non verrà creata. L’esecuzione del comando create-table restituisce una AccessDeniedException.

An error occurred (AccessDeniedException) when calling the CreateTable operation: User: arn:aws:sts::123456789012:assumed-role/DynamoFullAccessRole/ProductManager is not authorized to perform: dynamodb:CreateTable on resource: arn:aws:dynamodb:us-east-1:123456789012:table/myMusicTable with an explicit deny in an identity-based policy.