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à.
# Utilizzo del controllo degli accessi basato su attributi con DynamoDB
Il [controllo degli accessi basato sugli attributi (ABAC)](https://docs.aws.amazon.com/IAM/latest/UserGuide/introduction_attribute-based-access-control.html) è una strategia di autorizzazione che definisce le autorizzazioni di accesso in base alle [condizioni dei tag](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Tagging.html) nelle politiche basate sull'identità o in altre politiche, come le politiche basate sulle risorse e le politiche IAM dell'organizzazione. AWS È possibile associare tag alle tabelle DynamoDB, che vengono poi valutate in base alle condizioni basate sui tag. Gli indici associati a una tabella ereditano i tag aggiunti alla tabella. È possibile aggiungere fino a 50 tag per ogni tabella DynamoDB. La dimensione massima supportata per tutti i tag in una tabella è 10 KB. Per ulteriori informazioni sull’assegnazione di tag alle risorse DynamoDB e sulle restrizioni relative ai tag, consulta [Assegnazione di tag alle risorse in DynamoDB](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Tagging.Operations.html) e [Limitazioni dell'assegnazione di tag in DynamoDB](Tagging.md#TaggingRestrictions).
Per ulteriori informazioni sull'utilizzo dei tag per controllare l'accesso alle AWS risorse, consulta i seguenti argomenti nella Guida per l'utente IAM:
+ [A cosa serve ABAC AWS](https://docs.aws.amazon.com/IAM/latest/UserGuide/introduction_attribute-based-access-control.html)
+ [Controllo dell'accesso alle AWS risorse tramite tag](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_tags.html)
Utilizzando l’ABAC è possibile applicare diversi livelli di accesso per i propri team e le proprie applicazioni per eseguire azioni sulle tabelle DynamoDB utilizzando un minor numero di policy. Per controllare gli accessi alle tabelle o agli indici DynamoDB è invece possibile specificare un tag nell’[elemento Condition](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_elements_condition.html) di una policy IAM. Queste condizioni determinano il livello di accesso di un principale, un utente o un ruolo IAM alle tabelle e agli indici DynamoDB. Quando un principale IAM effettua una richiesta di accesso a DynamoDB, i tag della risorsa e dell’identità vengono valutati in base alle condizioni dei tag nella policy IAM. Successivamente, la policy diventa effettiva solo se vengono soddisfatte le condizioni dei tag. Ciò consente di creare una policy IAM che risponda efficacemente a una delle seguenti condizioni:
+ *Consentire all’utente di gestire solo le risorse che hanno un tag con una chiave `X` e un valore `Y`*.
+ *Negare l’accesso a tutti gli utenti alle risorse contrassegnate con una chiave `X`*.
Ad esempio, è possibile creare una policy che consenta agli utenti di aggiornare una tabella solo se presenta la coppia chiave-valore del tag: `"environment": "staging"`. Puoi usare la chiave [aws: ResourceTag](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_condition-keys.html#condition-keys-resourcetag) condition per consentire o negare l'accesso a una tabella in base ai tag allegati a quella tabella.
Puoi includere condizioni basate sugli attributi durante la creazione della policy o in un secondo momento utilizzando Console di gestione AWS, AWS API, AWS Command Line Interface (AWS CLI), AWS SDK o. AWS CloudFormation
L'esempio seguente consente l'[UpdateItem](https://docs.aws.amazon.com/amazondynamodb/latest/APIReference/API_UpdateItem.html)azione su una tabella denominata `MusicTable` se include una chiave di tag con il nome e il valore. `environment` `production`
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"dynamodb:UpdateItem"
],
"Resource": "arn:aws:dynamodb:*:*:table/MusicTable",
"Condition": {
"StringEquals": {
"aws:ResourceTag/environment": "production"
}
}
}
]
}
```
------
**Topics**
+ [Qual è il vantaggio di utilizzare l’ABAC?](#why-use-abac)
+ [Chiavi di condizione per implementare l’ABAC con DynamoDB](#condition-keys-implement-abac)
+ [Considerazioni sull’utilizzo dell’ABAC con DynamoDB](#abac-considerations)
+ [Abilitazione dell’ABAC in DynamoDB](abac-enable-ddb.md)
+ [Utilizzo dell’ABAC con tabelle e indici DynamoDB](abac-implementation-ddb-tables.md)
+ [Esempi di utilizzo dell’ABAC con tabelle e indici DynamoDB](abac-example-use-cases.md)
+ [Risoluzione dei problemi più comuni dell’ABAC per le tabelle e gli indici DynamoDB](abac-troubleshooting.md)
## Qual è il vantaggio di utilizzare l’ABAC?
+ **Gestione delle policy più semplice:** si utilizza un minor numero di policy perché non è necessario creare policy diverse per definire il livello di accesso per ogni principale IAM.
+ **Controllo scalabile degli accessi:** scalare il controllo degli accessi è più facile con l’ABAC perché non è necessario aggiornare le policy IAM quando vengono create nuove risorse. È possibile utilizzare i tag per autorizzare l’accesso ai principali IAM che contengono tag corrispondenti ai tag della risorsa. È possibile integrare nuovi principali IAM o risorse DynamoDB e applicare i tag appropriati per concedere automaticamente le autorizzazioni necessarie senza dover apportare modifiche alle policy.
+ **Gestione granulare delle autorizzazioni**: è una best practice [concedere il privilegio minimo](https://docs.aws.amazon.com/IAM/latest/UserGuide/best-practices.html#grant-least-privilege) quando si creano le policy. Utilizzando l’ABAC è possibile creare tag per il principale IAM e utilizzarli per concedere l’accesso ad azioni e risorse specifiche che corrispondono ai tag sul principale IAM.
+ **Allineamento con la directory aziendale:** è possibile mappare i tag con gli attributi dei dipendenti esistenti presenti nella directory aziendale per allineare le policy di controllo degli accessi alla struttura organizzativa.
## Chiavi di condizione per implementare l’ABAC con DynamoDB
È possibile utilizzare le seguenti chiavi di condizione nelle AWS policy per controllare il livello di accesso alle tabelle e agli indici DynamoDB:
+ [aws: ResourceTag /tag-key](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_condition-keys.html#condition-keys-resourcetag): Controlla l'accesso in base al fatto che la coppia chiave-valore del tag su una tabella o un indice DynamoDB corrisponda o meno alla chiave e al valore del tag in una policy. Questa chiave condizionale è rilevante per tutto ciò APIs che opera su una tabella o un indice esistente.
Le condizioni `dynamodb:ResourceTag` vengono valutate come se non fosse stato assegnato alcun tag a una risorsa.
+ [aws: RequestTag /tag-key](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_condition-keys.html#condition-keys-requesttag): consente di confrontare la coppia chiave-valore del tag passata nella richiesta con la coppia di tag specificata nella politica. Questa chiave condizionale è pertinente a APIs quella che contiene tag come parte del payload della richiesta. Questi APIs includono [CreateTable](https://docs.aws.amazon.com/amazondynamodb/latest/APIReference/API_CreateTable.html)e. [TagResource](https://docs.aws.amazon.com/amazondynamodb/latest/APIReference/API_TagResource.html)
+ [aws: TagKeys](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_condition-keys.html#condition-keys-tagkeys): Confronta le chiavi dei tag in una richiesta con le chiavi specificate nella policy. Questa chiave condizionale è rilevante per APIs quella che contiene tag come parte del payload della richiesta. Questi APIs includono `CreateTable``TagResource`, e`UntagResource`.
## Considerazioni sull’utilizzo dell’ABAC con DynamoDB
Quando si utilizza l’ABAC con tabelle o indici DynamoDB, valgono le seguenti considerazioni:
+ L’assegnazione di tag e l’ABAC non sono supportati per i flussi DynamoDB.
+ L’assegnazione di tag e l’ABAC non sono supportati per i backup DynamoDB. Per utilizzare l’ABAC con i backup, si consiglia di utilizzare [AWS Backup](https://docs.aws.amazon.com/aws-backup/latest/devguide/whatisbackup.html).
+ I tag non vengono conservati nelle tabelle ripristinate. È necessario aggiungere tag alle tabelle ripristinate prima di poter utilizzare le condizioni basate sui tag nelle policy.
# Abilitazione dell’ABAC in DynamoDB
Per la maggior parte dei casi Account AWS, ABAC è abilitato per impostazione predefinita. Utilizzando la console [DynamoDB](https://console.aws.amazon.com/dynamodb/) è possibile confermare se l’ABAC è abilitato per il proprio account. [Per fare ciò, assicurati di aprire la console DynamoDB con un ruolo con autorizzazione dynamodb:. GetAbacStatus](#required-permissions-abac) Quindi, apri la pagina **Impostazioni** della console DynamoDB.
Se non vedi la scheda **Controllo degli accessi basato sugli attributi** o se la scheda mostra lo stato **Attivo**, significa che l’ABAC è abilitato per l’account. Tuttavia, se vedi la scheda **Controllo degli accessi basato sugli attributi** con lo stato **Non attivo**, come mostrato nell’immagine seguente, l’ABAC non è abilitato per l’account.
## Controllo degli accessi basato su attributi – non abilitato
![\[Pagina Impostazioni sulla console DynamoDB che mostra la scheda di Controllo degli accessi basato sugli attributi.\]](http://docs.aws.amazon.com/it_it/amazondynamodb/latest/developerguide/images/ddb-console-settings-page.png)
ABAC non è abilitato Account AWS per cui le condizioni basate sui tag specificate nelle loro politiche basate sull'identità o altre politiche devono ancora essere verificate. Se l’ABAC non è abilitato per il proprio account, le condizioni basate sui tag nelle policy destinate ad agire sulle tabelle o sugli indici DynamoDB vengono valutate come se non fossero presenti tag per le proprie risorse o richieste API. Quando l’ABAC è abilitato per il proprio account, le condizioni basate sui tag nelle policy dell’account vengono valutate considerando i tag allegati alle proprie tabelle o richieste API.
Per abilitare l’ABAC per il proprio account, si consiglia innanzitutto di sottoporre ad audit le policy come descritto nella sezione [Audit delle policy](#policy-audit-for-abac). Quindi, si consiglia di includere le [autorizzazioni richieste per l’ABAC](#required-permissions-abac) nella policy IAM. Infine, si consiglia di eseguire le operazioni descritte in [Abilitazione dell’ABAC nella console](#abac-enable-console) per abilitare l’ABAC per l’account nella Regione corrente. Dopo aver abilitato l’ABAC, è possibile disattivarlo entro i successivi sette giorni di calendario dall’attivazione.
**Topics**
+ [Esecuzione di audit sulle policy prima dell’abilitazione dell’ABAC](#policy-audit-for-abac)
+ [Autorizzazioni IAM necessarie per abilitare l’ABAC](#required-permissions-abac)
+ [Abilitazione dell’ABAC nella console](#abac-enable-console)
## Esecuzione di audit sulle policy prima dell’abilitazione dell’ABAC
Prima di abilitare l’ABAC per l’account, sottoponi ad audit le policy per verificare che le condizioni basate sui tag che potrebbero esistere nelle policy dell’account siano configurate come previsto. L’audit delle policy aiuterà a evitare imprevisti dovuti alle modifiche delle autorizzazioni con i flussi di lavoro DynamoDB dopo l’abilitazione dell’ABAC. Per visualizzare esempi di utilizzo di condizioni basate su attributi con i tag e il comportamento prima e dopo l’implementazione dell’ABAC, consulta [Esempi di utilizzo dell’ABAC con tabelle e indici DynamoDBCasi d'uso di esempio](abac-example-use-cases.md).
## Autorizzazioni IAM necessarie per abilitare l’ABAC
È necessaria l’autorizzazione `dynamodb:UpdateAbacStatus` per abilitare l’ABAC per l’account nella Regione corrente. Per verificare se l’ABAC è abilitato per l’account, è necessario anche disporre dell’autorizzazione `dynamodb:GetAbacStatus`. Con questa autorizzazione è possibile visualizzare lo stato dell’ABAC di un account in qualsiasi Regione. Queste autorizzazioni si aggiungono a quelle necessarie per accedere alla console DynamoDB e visualizzare le tabelle.
La seguente policy IAM concede l’autorizzazione per abilitare l’ABAC e visualizzarne lo stato per un account nella Regione corrente.
```
{
"version": "2012-10-17", &TCX5-2025-waiver;
"Statement": [
{
"Effect": "Allow",
"Action": [
"dynamodb:UpdateAbacStatus",
"dynamodb:GetAbacStatus"
],
"Resource": "*"
}
]
}
```
## Abilitazione dell’ABAC nella console
1. Accedi Console di gestione AWS e apri la console DynamoDB all'indirizzo. [https://console.aws.amazon.com/dynamodb/](https://console.aws.amazon.com/dynamodb/)
1. Dal riquadro di navigazione in alto, seleziona la Regione per la quale desideri abilitare l’ABAC.
1. Nel riquadro di navigazione a sinistra, scegli **Impostazioni**.
1. Nella pagina **Settings (Impostazioni)**, eseguire le operazioni descritte di seguito.
1. Nella scheda **Controllo degli accessi basato sugli attributi**, seleziona **Abilita**.
1. Nella casella **Conferma l’impostazione del controllo degli accesso basato su attributi**, seleziona **Abilita** per confermare la scelta.
Questa operazione abilita l’ABAC per la Regione corrente e la scheda **Controllo degli accessi basato sugli attributi** mostra lo stato **Attivo**.
Dopo aver abilitato l’ABAC, è possibile disattivarlo entro i successivi sette giorni di calendario dall’attivazione. Per disattivarlo, seleziona **Disabilita** nella scheda **Controllo degli accessi basato sugli attributi** nella pagina **Impostazioni**.
**Nota**
L’aggiornamento dello stato dell’ABAC è un’operazione asincrona. Se i tag delle policy non vengono valutati immediatamente, potrebbe essere necessario attendere qualche istante perché l’applicazione delle modifiche presenti coerenza finale.
# Utilizzo dell’ABAC con tabelle e indici DynamoDB
La seguente procedura mostra come impostare le autorizzazioni attraverso l’ABAC. In questo scenario di esempio verranno aggiunti tag a una tabella DynamoDB e verrà creato un ruolo IAM con una policy che include condizioni basate su tag. Quindi, verranno testate le autorizzazioni consentite sulla tabella DynamoDB soddisfacendo le condizioni dei tag.
**Topics**
+ [Fase 1: aggiungere tag a una tabella DynamoDB](#abac-add-table-tags)
+ [Fase 2: creare un ruolo IAM con una policy che include condizioni basate su tag](#abac-create-iam-role)
+ [Fase 3: testare le autorizzazioni concesse](#abac-test-permissions)
## Fase 1: aggiungere tag a una tabella DynamoDB
Puoi aggiungere tag a tabelle DynamoDB nuove o esistenti utilizzando Console di gestione AWS AWS , API,AWS CLI() AWS Command Line Interface AWS , SDK o. AWS CloudFormation Ad esempio, il seguente comando della CLI [tag-resource](https://docs.aws.amazon.com/cli/latest/reference/dynamodb/tag-resource.html) aggiunge un tag a una tabella denominata `MusicTable`.
```
aws dynamodb tag-resource —resource-arn arn:aws:dynamodb:us-east-1:123456789012:table/MusicTable —tags Key=environment,Value=staging
```
## Fase 2: creare un ruolo IAM con una policy che include condizioni basate su tag
[Crea una policy IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_create-console.html#access_policies_create-json-editor) utilizzando la chiave di condizione [aws: ResourceTag /tag-key](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_condition-keys.html#condition-keys-resourcetag) per confrontare la coppia chiave-valore del tag specificata nella policy IAM con la coppia chiave-valore allegata alla tabella. La seguente policy di esempio consente agli utenti di inserire o aggiornare elementi nelle tabelle se queste tabelle contengono la coppia chiave-valore del tag: `"environment": "staging"`. Se una tabella non ha la coppia chiave-valore del tag specificata, queste azioni vengono negate.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"dynamodb:PutItem",
"dynamodb:UpdateItem"
],
"Resource": "arn:aws:dynamodb:*:*:table/*",
"Condition": {
"StringEquals": {
"aws:ResourceTag/environment": "staging"
}
}
}
]
}
```
------
## Fase 3: testare le autorizzazioni concesse
1. Collega la policy IAM a un utente o a un ruolo di prova nell’ Account AWS. Assicurati che il principale IAM che utilizzi non abbia già accesso alla tabella DynamoDB tramite una policy diversa.
1. Assicurati che la tabella DynamoDB contenga la chiave del tag `"environment"` con un valore di `"staging"`.
1. Esegui le azioni `dynamodb:PutItem` e `dynamodb:UpdateItem` sulla tabella con tag. Queste azioni dovrebbero andare a buon fine se è presente la coppia chiave-valore del tag `"environment": "staging"`.
Se si eseguono queste azioni su una tabella che non ha la coppia chiave-valore del tag `"environment": "staging"`, la richiesta avrà esito negativo restituendo una `AccessDeniedException`.
È anche possibile esaminare gli altri [casi d’uso di esempio](abac-example-use-cases.md) descritti nella sezione seguente per implementare l’ABAC ed eseguire altri test.
# 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.
**Topics**
+ [Esempio 1: consenti un'azione utilizzando aws: ResourceTag](#abac-allow-example-resource-tag)
+ [Esempio 2: consenti un'azione utilizzando aws: RequestTag](#abac-allow-example-request-tag)
+ [Esempio 3: Negare un'azione utilizzando aws: TagKeys](#abac-deny-example-tag-key)
## 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](https://docs.aws.amazon.com/amazondynamodb/latest/APIReference/API_PutItem.html) A tal fine, segui questa procedura:
------
#### [ Using the AWS CLI ]
1. Creare una tabella. L'esempio seguente utilizza il AWS CLI comando [create-table](https://docs.aws.amazon.com/cli/latest/reference/dynamodb/create-table.html) 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
```
1. Aggiungi un tag a questa tabella. Il seguente esempio di AWS CLI comando [tag-resource](https://docs.aws.amazon.com/cli/latest/reference/dynamodb/tag-resource.html) 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
```
1. Create una [policy in linea](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_managed-vs-inline.html#inline-policies) e aggiungetela a un ruolo a cui è associata la policy [AmazonDynamoDBReadOnlyAccess](https://docs.aws.amazon.com/aws-managed-policy/latest/reference/AmazonDynamoDBReadOnlyAccess.html) AWS gestita, come illustrato nell'esempio seguente.
------
#### [ 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.
1. Assumi il ruolo con le policy descritte nella Fase 3.
1. Usa il AWS CLI comando [put-item](https://docs.aws.amazon.com/cli/latest/reference/dynamodb/put-item.html) 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"}
}}
}'
```
1. 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'[CreateTable](https://docs.aws.amazon.com/amazondynamodb/latest/APIReference/API_CreateTable.html)API 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();
```
1. Aggiungi un tag a questa tabella. L'[TagResource](https://docs.aws.amazon.com/amazondynamodb/latest/APIReference/API_TagResource.html)API 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);
```
1. Create una [policy in linea](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_managed-vs-inline.html#inline-policies) e aggiungetela a un ruolo a cui è associata la policy [AmazonDynamoDBReadOnlyAccess](https://docs.aws.amazon.com/aws-managed-policy/latest/reference/AmazonDynamoDBReadOnlyAccess.html) AWS gestita, come illustrato nell'esempio seguente.
------
#### [ 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.
1. Assumi il ruolo con le policy descritte nella Fase 3.
1. Usa l'[PutItem](https://docs.aws.amazon.com/amazondynamodb/latest/APIReference/API_PutItem.html)API per inserire un elemento in. `myMusicTable`
```
HashMap 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 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);
```
1. 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'[CreateTable](https://docs.aws.amazon.com/amazondynamodb/latest/APIReference/API_CreateTable.html)API per creare una tabella denominata`myMusicTable`.
```
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']
```
1. Aggiungi un tag a questa tabella. L'[TagResource](https://docs.aws.amazon.com/amazondynamodb/latest/APIReference/API_TagResource.html)API 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'
},
]
)
```
1. Create una [policy in linea](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_managed-vs-inline.html#inline-policies) e aggiungetela a un ruolo a cui è associata la policy [AmazonDynamoDBReadOnlyAccess](https://docs.aws.amazon.com/aws-managed-policy/latest/reference/AmazonDynamoDBReadOnlyAccess.html) AWS gestita, come illustrato nell'esempio seguente.
------
#### [ 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.
1. Assumi il ruolo con le policy descritte nella Fase 3.
1. Usa l'[PutItem](https://docs.aws.amazon.com/amazondynamodb/latest/APIReference/API_PutItem.html)API 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'
}
}
)
```
1. 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-item`azione 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](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_condition-keys.html#condition-keys-requesttag), 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](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_managed-vs-inline.html#inline-policies) e aggiungila a un ruolo a cui è associata la policy [AmazonDynamoDBReadOnlyAccess](https://docs.aws.amazon.com/aws-managed-policy/latest/reference/ReadOnlyAccess.html) AWS gestita, come mostrato nell'esempio seguente.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"dynamodb:CreateTable",
"dynamodb:TagResource"
],
"Resource": "arn:aws:dynamodb:*:*:table/*",
"Condition": {
"StringEquals": {
"aws:RequestTag/Owner": "John"
}
}
}
]
}
```
------
1. 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](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_managed-vs-inline.html#inline-policies) e aggiungetela a un ruolo a cui è associata la policy [AmazonDynamoDBReadOnlyAccess](https://docs.aws.amazon.com/aws-managed-policy/latest/reference/AmazonDynamoDBReadOnlyAccess.html) AWS gestita, come illustrato nell'esempio seguente.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"dynamodb:CreateTable",
"dynamodb:TagResource"
],
"Resource": "arn:aws:dynamodb:*:*:table/*",
"Condition": {
"StringEquals": {
"aws:RequestTag/Owner": "John"
}
}
}
]
}
```
------
1. 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](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_condition-keys.html#condition-keys-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](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_managed-vs-inline.html#customer-managed-policies) a un ruolo a cui è associata la policy AWS gestita di [AmazonDynamoDBFullAccess](https://docs.aws.amazon.com/aws-managed-policy/latest/reference/AmazonDynamoDBFullAccess.html), come illustrato nell'esempio seguente.
------
#### [ 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"
}
}
}
]
}
```
------
1. 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](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_managed-vs-inline.html#customer-managed-policies) a un ruolo a cui è associata la politica di AWS gestione degli [AmazonDynamoDBFullaccessi](https://docs.aws.amazon.com/aws-managed-policy/latest/reference/AmazonDynamoDBFullAccess.html), come illustrato nell'esempio seguente.
------
#### [ 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"
}
}
}
]
}
```
------
1. 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.
```
# Risoluzione dei problemi più comuni dell’ABAC per le tabelle e gli indici DynamoDB
Questo argomento fornisce consigli per la risoluzione dei problemi relativi a errori e problemi comuni che potrebbero verificarsi durante l’implementazione dell’ABAC nelle tabelle o negli indici DynamoDB.
## Le chiavi di condizione specifiche del servizio nelle policy generano un errore
Le chiavi di condizione specifiche del servizio non sono considerate chiavi di condizione valide. Se sono state utilizzate tali chiavi nelle policy, si verificherà un errore. Per risolvere questo problema, è necessario sostituire le chiavi di condizione specifiche del servizio con una [chiave di condizione appropriata per implementare l’ABAC](attribute-based-access-control.md#condition-keys-implement-abac) in DynamoDB.
Ad esempio, supponiamo di aver utilizzato la chiave `dynamodb:ResourceTag` condition in una [policy in linea](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_managed-vs-inline.html#inline-policies) che esegue la richiesta. [PutItem](https://docs.aws.amazon.com/amazondynamodb/latest/APIReference/API_PutItem.html) Si immagini che la richiesta abbia esito negativo con una `AccessDeniedException`. Nell’esempio seguente viene illustrata la policy in linea errata con la chiave di condizione `dynamodb:ResourceTag`.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"dynamodb:PutItem"
],
"Resource": "arn:aws:dynamodb:*:*:table/*",
"Condition": {
"StringEquals": {
"dynamodb:ResourceTag/Owner": "John"
}
}
}
]
}
```
------
Per risolvere questo problema, sostituisci la chiave di condizione `dynamodb:ResourceTag` con `aws:ResourceTag`, come illustrato nell’esempio seguente.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"dynamodb:PutItem"
],
"Resource": "arn:aws:dynamodb:*:*:table/*",
"Condition": {
"StringEquals": {
"aws:ResourceTag/Owner": "John"
}
}
}
]
}
```
------
## Impossibile disattivare l’ABAC
Se ABAC è stato abilitato per il tuo account tramite Supporto, non potrai disattivare ABAC tramite la console DynamoDB. Per disattivarlo, contatta il [Supporto](https://console.aws.amazon.com/support).
È possibile disattivare personalmente l’ABAC *solo* alle seguenti condizioni:
+ È stata utilizzata la modalità self-service di [adesione tramite la console DynamoDB](abac-enable-ddb.md#abac-enable-console).
+ La disattivazione avviene entro sette giorni di calendario dall’adesione.