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à.
# AWS Esempi di politiche di controllo degli accessi di Glue
Questa sezione contiene esempi di policy di controllo degli accessi basate sull'identità (IAM) e sulle risorse di AWS Glue.
**Contents**
+ [Esempi di policy basate sull'identità per Glue AWS](security_iam_id-based-policy-examples.md)
+ [Best practice per le policy](security_iam_id-based-policy-examples.md#security_iam_service-with-iam-policy-best-practices)
+ [Le autorizzazioni a livello di risorsa si applicano solo agli specifici oggetti di AWS Glue](security_iam_id-based-policy-examples.md#glue-identity-based-policy-limitations)
+ [Utilizzo della console AWS Glue](security_iam_id-based-policy-examples.md#security_iam_id-based-policy-examples-console)
+ [Consentire agli utenti di visualizzare le loro autorizzazioni](security_iam_id-based-policy-examples.md#security_iam_id-based-policy-examples-view-own-permissions)
+ [Concessione di autorizzazioni di sola lettura a una tabella](security_iam_id-based-policy-examples.md#security_iam_id-based-policy-examples-read-only-table-access)
+ [Filtra le tabelle per GetTables autorizzazione](security_iam_id-based-policy-examples.md#security_iam_id-based-policy-examples-filter-tables)
+ [Concessione di accesso completo a una tabella e a tutte le partizioni](security_iam_id-based-policy-examples.md#security_iam_id-based-policy-examples-full-access-tables-partitions)
+ [Controllo degli accessi per nome prefisso e diniego esplicito](security_iam_id-based-policy-examples.md#security_iam_id-based-policy-examples-deny-by-name-prefix)
+ [Autorizzazione dell'accesso utilizzando tag](security_iam_id-based-policy-examples.md#tags-control-access-example-triggers-allow)
+ [Negazione dell'accesso utilizzando tag](security_iam_id-based-policy-examples.md#tags-control-access-example-triggers-deny)
+ [Utilizzo di tag con operazioni API in elenco e in batch](security_iam_id-based-policy-examples.md#tags-control-access-example-triggers-list-batch)
+ [Controllo delle impostazioni utilizzando le chiavi di condizione o di contesto](security_iam_id-based-policy-examples.md#glue-identity-based-policy-condition-keys)
+ [Policy di controllo che controllano le impostazioni utilizzando le chiavi di condizione](security_iam_id-based-policy-examples.md#glue-identity-based-policy-condition-key-vpc)
+ [Policy di controllo che controllano le impostazioni utilizzando le chiavi di contesto](security_iam_id-based-policy-examples.md#glue-identity-based-policy-context-key-glue)
+ [Negare a un'identità la possibilità di creare sessioni di anteprima dei dati](security_iam_id-based-policy-examples.md#deny-data-preview-sessions-per-identity)
+ [Esempi di policy basate sulle risorse per Glue AWS](security_iam_resource-based-policy-examples.md)
+ [Considerazioni sull'utilizzo di politiche basate sulle risorse con Glue AWS](security_iam_resource-based-policy-examples.md#security_iam_resource-based-policy-examples-considerations)
+ [Utilizza una policy della risorsa per controllare gli accessi nello stesso account](security_iam_resource-based-policy-examples.md#glue-policy-resource-policies-example-same-account)
# Esempi di policy basate sull'identità per Glue AWS
Per impostazione predefinita, gli utenti e i ruoli non sono autorizzati a creare o modificare le risorse AWS Glue. Per concedere agli utenti l’autorizzazione a eseguire azioni sulle risorse di cui hanno bisogno, un amministratore IAM può creare policy IAM.
Per informazioni su come creare una policy basata su identità IAM utilizzando questi documenti di policy JSON di esempio, consulta [Creazione di policy IAM (console)](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_create-console.html) nella *Guida per l’utente di IAM*.
Per i dettagli sulle azioni e sui tipi di risorse definiti da AWS Glue, incluso il formato di ARNs per ogni tipo di risorsa, vedere [Azioni, risorse e chiavi di condizione per AWS Glue](https://docs.aws.amazon.com/service-authorization/latest/reference/list_awsglue.html) nel *riferimento di autorizzazione del servizio*.
**Nota**
Gli esempi forniti in questa sezione utilizzano tutti la Regione `us-west-2`. Puoi sostituirlo con la AWS regione che desideri utilizzare.
**Topics**
+ [Best practice per le policy](#security_iam_service-with-iam-policy-best-practices)
+ [Le autorizzazioni a livello di risorsa si applicano solo agli specifici oggetti di AWS Glue](#glue-identity-based-policy-limitations)
+ [Utilizzo della console AWS Glue](#security_iam_id-based-policy-examples-console)
+ [Consentire agli utenti di visualizzare le loro autorizzazioni](#security_iam_id-based-policy-examples-view-own-permissions)
+ [Concessione di autorizzazioni di sola lettura a una tabella](#security_iam_id-based-policy-examples-read-only-table-access)
+ [Filtra le tabelle per GetTables autorizzazione](#security_iam_id-based-policy-examples-filter-tables)
+ [Concessione di accesso completo a una tabella e a tutte le partizioni](#security_iam_id-based-policy-examples-full-access-tables-partitions)
+ [Controllo degli accessi per nome prefisso e diniego esplicito](#security_iam_id-based-policy-examples-deny-by-name-prefix)
+ [Autorizzazione dell'accesso utilizzando tag](#tags-control-access-example-triggers-allow)
+ [Negazione dell'accesso utilizzando tag](#tags-control-access-example-triggers-deny)
+ [Utilizzo di tag con operazioni API in elenco e in batch](#tags-control-access-example-triggers-list-batch)
+ [Controllo delle impostazioni utilizzando le chiavi di condizione o di contesto](#glue-identity-based-policy-condition-keys)
+ [Negare a un'identità la possibilità di creare sessioni di anteprima dei dati](#deny-data-preview-sessions-per-identity)
## Best practice per le policy
Le politiche basate sull'identità determinano se qualcuno può creare, accedere o eliminare le risorse AWS Glue nel tuo account. Queste azioni possono comportare costi aggiuntivi per l’ Account AWS. Quando si creano o modificano policy basate sull’identità, seguire queste linee guida e raccomandazioni:
+ **Inizia con le policy AWS gestite e passa alle autorizzazioni con privilegi minimi: per iniziare a concedere autorizzazioni** *a utenti e carichi di lavoro, utilizza le politiche gestite che concedono le autorizzazioni per molti casi d'uso comuni.AWS * Sono disponibili nel tuo. Account AWS Ti consigliamo di ridurre ulteriormente le autorizzazioni definendo politiche gestite dai AWS clienti specifiche per i tuoi casi d'uso. Per maggiori informazioni, consulta [Policy gestite da AWS](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_managed-vs-inline.html#aws-managed-policies) o [Policy gestite da AWS per le funzioni dei processi](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_job-functions.html) nella *Guida per l’utente di IAM*.
+ **Applicazione delle autorizzazioni con privilegio minimo** - Quando si impostano le autorizzazioni con le policy IAM, concedere solo le autorizzazioni richieste per eseguire un’attività. È possibile farlo definendo le azioni che possono essere intraprese su risorse specifiche in condizioni specifiche, note anche come *autorizzazioni con privilegio minimo*. Per maggiori informazioni sull’utilizzo di IAM per applicare le autorizzazioni, consulta [Policy e autorizzazioni in IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies.html) nella *Guida per l’utente di IAM*.
+ **Condizioni d’uso nelle policy IAM per limitare ulteriormente l’accesso** - Per limitare l’accesso ad azioni e risorse è possibile aggiungere una condizione alle policy. Ad esempio, è possibile scrivere una condizione di policy per specificare che tutte le richieste devono essere inviate utilizzando SSL. Puoi anche utilizzare le condizioni per concedere l'accesso alle azioni del servizio se vengono utilizzate tramite uno specifico Servizio AWS, ad esempio CloudFormation. Per maggiori informazioni, consultare la sezione [Elementi delle policy JSON di IAM: condizione](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_elements_condition.html) nella *Guida per l’utente di IAM*.
+ **Utilizzo dello strumento di analisi degli accessi IAM per convalidare le policy IAM e garantire autorizzazioni sicure e funzionali** - Lo strumento di analisi degli accessi IAM convalida le policy nuove ed esistenti in modo che aderiscano al linguaggio (JSON) della policy IAM e alle best practice di IAM. Lo strumento di analisi degli accessi IAM offre oltre 100 controlli delle policy e consigli utili per creare policy sicure e funzionali. Per maggiori informazioni, consultare [Convalida delle policy per il Sistema di analisi degli accessi IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/access-analyzer-policy-validation.html) nella *Guida per l’utente di IAM*.
+ **Richiedi l'autenticazione a più fattori (MFA**): se hai uno scenario che richiede utenti IAM o un utente root nel Account AWS tuo, attiva l'MFA per una maggiore sicurezza. Per richiedere la MFA quando vengono chiamate le operazioni API, aggiungere le condizioni MFA alle policy. Per maggiori informazioni, consultare [Protezione dell’accesso API con MFA](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_mfa_configure-api-require.html) nella *Guida per l’utente di IAM*.
Per maggiori informazioni sulle best practice in IAM, consulta [Best practice di sicurezza in IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/best-practices.html) nella *Guida per l’utente di IAM*.
## Le autorizzazioni a livello di risorsa si applicano solo agli specifici oggetti di AWS Glue
È possibile definire il controllo granulare solo per specifici oggetti di AWS Glue. Pertanto, devi scrivere la policy IAM del tuo cliente in modo che le operazioni API che consentono Amazon Resource Names (ARNs) per l'`Resource`istruzione non vengano mescolate con le operazioni API che non lo consentono ARNs.
Ad esempio, la seguente policy di IAM consente operazioni delle API per `GetClassifier` e `GetJobRun`. Definisce `Resource` come `*` perché AWS Glue non consente ARNs classificatori ed esecuzioni di job. Perché ARNs sono consentiti per operazioni API specifiche come `GetDatabase` e`GetTable`, ARNs possono essere specificati nella seconda metà della policy.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"glue:GetClassifier*",
"glue:GetJobRun*"
],
"Resource": "*"
},
{
"Effect": "Allow",
"Action": [
"glue:Get*"
],
"Resource": [
"arn:aws:glue:us-east-1:111122223333:catalog",
"arn:aws:glue:us-east-1:111122223333:database/default",
"arn:aws:glue:us-east-1:111122223333:table/default/e*1*",
"arn:aws:glue:us-east-1:111122223333:connection/connection2"
]
}
]
}
```
------
Per un elenco di AWS Glue oggetti che lo consentono ARNs, vedere[AWS GlueSpecificare la risorsa ARNs](glue-specifying-resource-arns.md).
## Utilizzo della console AWS Glue
Per accedere alla console AWS Glue, devi disporre di un set minimo di autorizzazioni. Queste autorizzazioni devono consentirti di elencare e visualizzare i dettagli sulle risorse AWS Glue presenti nel tuo Account AWS. Se crei una policy basata sull’identità più restrittiva rispetto alle autorizzazioni minime richieste, la console non funzionerà nel modo previsto per le entità (utenti o ruoli) associate a tale policy.
Non è necessario concedere autorizzazioni minime per la console agli utenti che effettuano chiamate solo verso AWS CLI o l' AWS API. Al contrario, è opportuno concedere l’accesso solo alle azioni che corrispondono all’operazione API che stanno cercando di eseguire.
Per garantire che utenti e ruoli possano ancora utilizzare la console AWS Glue, collega anche AWS Glue `ConsoleAccess` o la policy `ReadOnly` AWS gestita alle entità. Per maggiori informazioni, consulta [Aggiunta di autorizzazioni a un utente](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_users_change-permissions.html#users_change_permissions-add-console) nella *Guida per l’utente di IAM*.
Affinché un utente possa lavorare con la AWS Glue console, deve disporre di un set minimo di autorizzazioni che gli consentano di utilizzare le AWS Glue risorse del proprio AWS account. Oltre a queste autorizzazioni AWS Glue, la console richiede le autorizzazioni dei servizi seguenti:
+ Autorizzazioni Amazon CloudWatch Logs per visualizzare i log.
+ AWS Identity and Access Management (IAM) autorizzazioni per elencare e trasferire ruoli.
+ AWS CloudFormation autorizzazioni per lavorare con gli stack.
+ Autorizzazioni Amazon Elastic Compute Cloud (Amazon EC2) per VPCs elenchi, sottoreti, gruppi di sicurezza, istanze e altri oggetti.
+ Autorizzazioni Amazon Simple Storage Service (Amazon S3) per elencare bucket e oggetti e per recuperare e salvare script.
+ Autorizzazioni Amazon Redshift necessarie per l'utilizzo dei cluster.
+ Autorizzazioni Amazon Relational Database Service (Amazon RDS) per elencare le istanze.
Per ulteriori informazioni sulle autorizzazioni necessarie agli utenti per visualizzare e usare la console di AWS Glue, consultare [Fase 3: Collegamento di una policy agli utenti o ai gruppi che accedono a AWS Glue](attach-policy-iam-user.md).
Se decidi di creare una policy IAM più restrittiva delle autorizzazioni minime richieste, la console non funzionerà come previsto per gli utenti con tale policy IAM. Per garantire che gli utenti possano continuare a usare la console AWS Glue, collega anche la policy gestita `AWSGlueConsoleFullAccess`, come descritto in [AWS politiche gestite (predefinite) per AWS Glue](security-iam-awsmanpol.md#access-policy-examples-aws-managed).
## Consentire agli utenti di visualizzare le loro autorizzazioni
Questo esempio mostra in che modo è possibile creare una policy che consente agli utenti IAM di visualizzare le policy inline e gestite che sono collegate alla relativa identità utente. Questa politica include le autorizzazioni per completare questa azione sulla console o utilizzando l'API o in modo programmatico. AWS CLI AWS
```
{
"Version": "2012-10-17",
"Statement": [
{
"Sid": "ViewOwnUserInfo",
"Effect": "Allow",
"Action": [
"iam:GetUserPolicy",
"iam:ListGroupsForUser",
"iam:ListAttachedUserPolicies",
"iam:ListUserPolicies",
"iam:GetUser"
],
"Resource": ["arn:aws:iam::*:user/${aws:username}"]
},
{
"Sid": "NavigateInConsole",
"Effect": "Allow",
"Action": [
"iam:GetGroupPolicy",
"iam:GetPolicyVersion",
"iam:GetPolicy",
"iam:ListAttachedGroupPolicies",
"iam:ListGroupPolicies",
"iam:ListPolicyVersions",
"iam:ListPolicies",
"iam:ListUsers"
],
"Resource": "*"
}
]
}
```
## Concessione di autorizzazioni di sola lettura a una tabella
La policy seguente consente di concedere autorizzazioni di sola lettura per una tabella `books` nel database `db1`. Per ulteriori informazioni sulla risorsa Amazon Resource Names (ARNs), consulta[Catalogo dati ARNs](glue-specifying-resource-arns.md#data-catalog-resource-arns).
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Sid": "GetTablesActionOnBooks",
"Effect": "Allow",
"Action": [
"glue:GetTables",
"glue:GetTable"
],
"Resource": [
"arn:aws:glue:us-east-1:111122223333:catalog",
"arn:aws:glue:us-east-1:111122223333:database/db1",
"arn:aws:glue:us-east-1:111122223333:table/db1/books"
]
}
]
}
```
------
Questa policy consente di concedere autorizzazioni di sola lettura per una tabella `books` nel database denominato `db1`. Per concedere l'autorizzazione `Get` a una tabella è richiesta anche l'autorizzazione alle risorse del database e del catalogo.
La policy seguente concede il livello minimo di autorizzazioni necessarie per creare una tabella `tb1` nel database `db1`:
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"glue:CreateTable"
],
"Resource": [
"arn:aws:glue:us-east-1:111122223333:table/db1/tbl1",
"arn:aws:glue:us-east-1:111122223333:database/db1",
"arn:aws:glue:us-east-1:111122223333:catalog"
]
}
]
}
```
------
## Filtra le tabelle per GetTables autorizzazione
Supponiamo che ci siano tre tabelle (`customers`, `stores` e `store_sales`) nel database `db1`. La policy seguente concede l'autorizzazione `GetTables` a `stores` e `store_sales`, ma non a `customers`. Quando chiami `GetTables` con questa policy, il risultato contiene solo le due tabelle autorizzate (la tabella `customers` non viene restituita).
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Sid": "GetTablesExample",
"Effect": "Allow",
"Action": [
"glue:GetTables"
],
"Resource": [
"arn:aws:glue:us-east-1:111122223333:catalog",
"arn:aws:glue:us-east-1:111122223333:database/db1",
"arn:aws:glue:us-east-1:111122223333:table/db1/store_sales",
"arn:aws:glue:us-east-1:111122223333:table/db1/stores"
]
}
]
}
```
------
È possibile semplificare la policy precedente utilizzando `store*` per includere qualsiasi nome di tabella che inizi con `store`:
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Sid": "GetTablesExample2",
"Effect": "Allow",
"Action": [
"glue:GetTables"
],
"Resource": [
"arn:aws:glue:us-east-1:111122223333:catalog",
"arn:aws:glue:us-east-1:111122223333:database/db1",
"arn:aws:glue:us-east-1:111122223333:table/db1/store*"
]
}
]
}
```
------
Analogamente, utilizzando `/db1/*` per includere tutte le tabelle incluse nella cartella `db1`, la policy seguente concede l'autorizzazione `GetTables` a tutte le tabelle presenti in `db1`.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Sid": "GetTablesReturnAll",
"Effect": "Allow",
"Action": [
"glue:GetTables"
],
"Resource": [
"arn:aws:glue:us-east-1:111122223333:catalog",
"arn:aws:glue:us-east-1:111122223333:database/db1",
"arn:aws:glue:us-east-1:111122223333:table/db1/*"
]
}
]
}
```
------
Se non viene fornito nessun ARN di tabella, una chiamata a `GetTables` si conclude correttamente ma restituisce un elenco vuoto:
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Sid": "GetTablesEmptyResults",
"Effect": "Allow",
"Action": [
"glue:GetTables"
],
"Resource": [
"arn:aws:glue:us-east-1:111122223333:catalog",
"arn:aws:glue:us-east-1:111122223333:database/db1"
]
}
]
}
```
------
Se la policy non contiene l'ARN del database, una chiamata a `GetTables` ha esito negativo e restituisce `AccessDeniedException`:
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Sid": "GetTablesAccessDeny",
"Effect": "Allow",
"Action": [
"glue:GetTables"
],
"Resource": [
"arn:aws:glue:us-east-1:111122223333:catalog",
"arn:aws:glue:us-east-1:111122223333:table/db1/*"
]
}
]
}
```
------
## Concessione di accesso completo a una tabella e a tutte le partizioni
La policy seguente concede tutte le autorizzazioni su una tabella denominata `books` nel database `db1`. Questo include le autorizzazioni di lettura e scrittura sulla tabella stessa, sulle versioni archiviate e su tutte le partizioni.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Sid": "FullAccessOnTable",
"Effect": "Allow",
"Action": [
"glue:CreateTable",
"glue:GetTable",
"glue:GetTables",
"glue:UpdateTable",
"glue:DeleteTable",
"glue:BatchDeleteTable",
"glue:GetTableVersion",
"glue:GetTableVersions",
"glue:DeleteTableVersion",
"glue:BatchDeleteTableVersion",
"glue:CreatePartition",
"glue:BatchCreatePartition",
"glue:GetPartition",
"glue:GetPartitions",
"glue:BatchGetPartition",
"glue:UpdatePartition",
"glue:DeletePartition",
"glue:BatchDeletePartition"
],
"Resource": [
"arn:aws:glue:us-east-1:111122223333:catalog",
"arn:aws:glue:us-east-1:111122223333:database/db1",
"arn:aws:glue:us-east-1:111122223333:table/db1/books"
]
}
]
}
```
------
Nella pratica, la policy precedente può essere semplificata:
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Sid": "FullAccessOnTable",
"Effect": "Allow",
"Action": [
"glue:*Table*",
"glue:*Partition*"
],
"Resource": [
"arn:aws:glue:us-east-1:111122223333:catalog",
"arn:aws:glue:us-east-1:111122223333:database/db1",
"arn:aws:glue:us-east-1:111122223333:table/db1/books"
]
}
]
}
```
------
tieni presente che il livello minimo di granularità del controllo degli accessi è a livello di tabella. Questo significa che non è possibile concedere a un utente l'accesso ad alcune partizioni in una tabella, ma non ad altre, o ad alcune colonne ma non ad altre. Un utente ha accesso a tutte le parti di una tabella o a nessuna.
## Controllo degli accessi per nome prefisso e diniego esplicito
In questo esempio, supponiamo che i database e le tabelle del tuo AWS Glue Data Catalog siano organizzati utilizzando prefissi di nome. I database nella fase di sviluppo hanno il nome prefisso `dev-` e quelli in produzione hanno il nome prefisso `prod-`. È possibile utilizzare la seguente politica per concedere agli sviluppatori l'accesso completo a tutti i database, le tabelle e così via che hanno il prefisso. UDFs `dev-` Tuttavia, puoi anche concedere l'accesso in sola lettura a tutti gli elementi con il prefisso `prod-`.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Sid": "DevAndProdFullAccess",
"Effect": "Allow",
"Action": [
"glue:*Database*",
"glue:*Table*",
"glue:*Partition*",
"glue:*UserDefinedFunction*",
"glue:*Connection*"
],
"Resource": [
"arn:aws:glue:us-east-1:111122223333:catalog",
"arn:aws:glue:us-east-1:111122223333:database/dev-*",
"arn:aws:glue:us-east-1:111122223333:database/prod-*",
"arn:aws:glue:us-east-1:111122223333:table/dev-*/*",
"arn:aws:glue:us-east-1:111122223333:table/*/dev-*",
"arn:aws:glue:us-east-1:111122223333:table/prod-*/*",
"arn:aws:glue:us-east-1:111122223333:table/*/prod-*",
"arn:aws:glue:us-east-1:111122223333:userDefinedFunction/dev-*/*",
"arn:aws:glue:us-east-1:111122223333:userDefinedFunction/*/dev-*",
"arn:aws:glue:us-east-1:111122223333:userDefinedFunction/prod-*/*",
"arn:aws:glue:us-east-1:111122223333:userDefinedFunction/*/prod-*",
"arn:aws:glue:us-east-1:111122223333:connection/dev-*",
"arn:aws:glue:us-east-1:111122223333:connection/prod-*"
]
},
{
"Sid": "ProdWriteDeny",
"Effect": "Deny",
"Action": [
"glue:*Create*",
"glue:*Update*",
"glue:*Delete*"
],
"Resource": [
"arn:aws:glue:us-east-1:111122223333:database/prod-*",
"arn:aws:glue:us-east-1:111122223333:table/prod-*/*",
"arn:aws:glue:us-east-1:111122223333:table/*/prod-*",
"arn:aws:glue:us-east-1:111122223333:userDefinedFunction/prod-*/*",
"arn:aws:glue:us-east-1:111122223333:userDefinedFunction/*/prod-*",
"arn:aws:glue:us-east-1:111122223333:connection/prod-*"
]
}
]
}
```
------
La seconda istruzione nella policy precedente utilizza il codice esplicito `deny`. Puoi utilizzare il codice esplicito `deny` per sovrascrivere qualsiasi autorizzazione `allow` concessa al principale. Questo consente di bloccare l'accesso a risorse critiche e a impedire a un'altra policy di concedere accidentalmente l'accesso a esse.
Nell'esempio precedente, anche se la prima istruzione concede l'accesso completo alle risorse `prod-`, la seconda istruzione revoca esplicitamente l'accesso in scrittura, mantenendo solo l'accesso in lettura alle risorse `prod-`.
## Autorizzazione dell'accesso utilizzando tag
Supporre ad esempio che si voglia limitare l'accesso al trigger `t2` a un utente specifico denominato `Tom` nel proprio account. Tutti gli altri utenti, tra cui `Sam`, hanno accesso al trigger `t1`. I trigger `t1` e `t2` hanno le seguenti proprietà.
```
aws glue get-triggers
{
"Triggers": [
{
"State": "CREATED",
"Type": "SCHEDULED",
"Name": "t1",
"Actions": [
{
"JobName": "j1"
}
],
"Schedule": "cron(0 0/1 * * ? *)"
},
{
"State": "CREATED",
"Type": "SCHEDULED",
"Name": "t2",
"Actions": [
{
"JobName": "j1"
}
],
"Schedule": "cron(0 0/1 * * ? *)"
}
]
}
```
L'amministratore AWS Glue ha associato il valore di tag `Tom` (`aws:ResourceTag/Name": "Tom"`) al trigger `t2`. L'amministratore AWS Glue ha inoltre fornito a Tom una policy IAM con un'istruzione di condizione basata sul tag. Di conseguenza, Tom può utilizzare solo un'operazione AWS Glue che agisce sulle risorse con il valore di tag `Tom`.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": "glue:*",
"Resource": "*",
"Condition": {
"StringEquals": {
"aws:ResourceTag/Name": "Tom"
}
}
}
]
}
```
------
Quando Tom cerca di accedere al trigger `t1` riceve un messaggio di accesso rifiutato. Allo stesso tempo, può recuperare regolarmente il trigger `t2`.
```
aws glue get-trigger --name t1
An error occurred (AccessDeniedException) when calling the GetTrigger operation: User: Tom is not authorized to perform: glue:GetTrigger on resource: arn:aws:glue:us-east-1:123456789012:trigger/t1
aws glue get-trigger --name t2
{
"Trigger": {
"State": "CREATED",
"Type": "SCHEDULED",
"Name": "t2",
"Actions": [
{
"JobName": "j1"
}
],
"Schedule": "cron(0 0/1 * * ? *)"
}
}
```
Tom non può usare l'operazione dell'API `GetTriggers` plurale per elencare i trigger in quanto questa operazione non supporta il filtro sui tag.
Per concedere a Tom l'accesso a `GetTriggers`, l'amministratore di AWS Glue crea una policy che divide le autorizzazioni in due sezioni. Una sezione consente a Tom di accedere a tutti i trigger con l'operazione API `GetTriggers`. La seconda sezione consente a Tom di accedere alle operazioni API che sono contrassegnate con il valore `Tom`. Con questa policy, a Tom è consentito l'accesso `GetTriggers` e `GetTrigger` al trigger `t2`.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": "glue:GetTriggers",
"Resource": "*"
},
{
"Effect": "Allow",
"Action": "glue:*",
"Resource": "*",
"Condition": {
"StringEquals": {
"aws:ResourceTag/Name": "Tom"
}
}
}
]
}
```
------
## Negazione dell'accesso utilizzando tag
Un altro approccio per una policy delle risorse consiste nel negare in modo esplicito l'accesso alle risorse.
**Importante**
Una policy di negazione esplicita non funziona per le operazioni dell'API plurali, come `GetTriggers`.
Nella seguente policy di esempio, sono consentite tutte le operazioni di processo AWS Glue Tuttavia, la seconda dichiarazione `Effect` nega *esplicitamente* l'accesso ai processi contrassegnati con la chiave `Team` e il valore `Special`.
Quando un amministratore collega le seguenti policy a un'identità, questa può accedere a tutti i processi *tranne* quelli contrassegnati con la chiave `Team` e il valore `Special`.
## Utilizzo di tag con operazioni API in elenco e in batch
Un terzo approccio per scrivere una policy basata sulle risorse consiste nel consentire l'accesso alle risorse utilizzando un'operazione API `List` per elencare le risorse corrispondenti a un dato valore di tag. Quindi, si utilizza l'operazione API `Batch` corrispondente per consentire l'accesso ai dettagli delle risorse specifiche. Con questo approccio, l'amministratore non ha bisogno di consentire l'accesso alle operazioni API `GetCrawlers`, `GetDevEndpoints`, `GetJobs` o `GetTriggers` plurali. Puoi invece consentire la possibilità di elencare le risorse con le seguenti operazioni API:
+ `ListCrawlers`
+ `ListDevEndpoints`
+ `ListJobs`
+ `ListTriggers`
Puoi inoltre consentire la possibilità di ottenere i dettagli delle singole risorse con le seguenti operazioni API:
+ `BatchGetCrawlers`
+ `BatchGetDevEndpoints`
+ `BatchGetJobs`
+ `BatchGetTriggers`
In qualità di amministratore, per l'utilizzo di questo approccio, è possibile:
1. Aggiungere i tag a crawler, endpoint di sviluppo, processi e trigger.
1. Rifiutare l'accesso degli utenti alle operazioni API `Get`, ad esempio `GetCrawlers`, `GetDevEndponts`, `GetJobs` e `GetTriggers`.
1. Per permettere agli utenti di determinare a quali risorse con tag hanno accesso, consentire l'accesso degli utenti alle operazioni API `List`, ad esempio `ListCrawlers`, `ListDevEndponts`, `ListJobs` e `ListTriggers`.
1. Nega agli utenti l'accesso ai AWS Glue tag APIs, ad esempio e. `TagResource` `UntagResource`
1. Consentire l'accesso degli utenti ai dettagli delle risorse con le operazioni API `BatchGet`, ad esempio `BatchGetCrawlers`, `BatchGetDevEndponts`, `BatchGetJobs` e `BatchGetTriggers`.
Ad esempio, quando si richiama l'operazione `ListCrawlers`, fornire un valore di tag che corrisponda al nome dell'utente. Quindi il risultato è un elenco di crawler corrispondenti ai valori di tag forniti. Fornisci l'elenco dei nomi a `BatchGetCrawlers` per ottenere informazioni dettagliate su ogni crawler con il tag specificato.
Ad esempio, se Tom deve essere in grado di recuperare solo i dettagli dei trigger con il tag `Tom`, l'amministratore può aggiungere i tag ai trigger per `Tom`, rifiutare l'accesso all'operazione API `GetTriggers` a tutti gli utenti e consentire l'accesso di tutti gli utenti a `ListTriggers` e `BatchGetTriggers`.
Ecco la policy basata sulle risorse che l'amministratore di AWS Glue concede a Tom. Nella prima sezione della policy, le operazioni API AWS Glue sono rifiutate per `GetTriggers`. Nella seconda sezione della policy, `ListTriggers` è consentito per tutte le risorse. Tuttavia, nella terza sezione, tali risorse con il tag `Tom` possono eseguire l'accesso `BatchGetTriggers`.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Deny",
"Action": "glue:GetTriggers",
"Resource": "*"
},
{
"Effect": "Allow",
"Action": [
"glue:ListTriggers"
],
"Resource": [
"*"
]
},
{
"Effect": "Allow",
"Action": [
"glue:BatchGetTriggers"
],
"Resource": [
"*"
],
"Condition": {
"StringEquals": {
"aws:ResourceTag/Name": "Tom"
}
}
}
]
}
```
------
Usando gli stessi trigger dell'esempio precedente, Tom può accedere al trigger `t2`, ma non al trigger `t1`. L'esempio seguente mostra i risultati quando Tom cerca di accedere a `t1` e `t2` con `BatchGetTriggers`.
```
aws glue batch-get-triggers --trigger-names t2
{
"Triggers": {
"State": "CREATED",
"Type": "SCHEDULED",
"Name": "t2",
"Actions": [
{
"JobName": "j2"
}
],
"Schedule": "cron(0 0/1 * * ? *)"
}
}
aws glue batch-get-triggers --trigger-names t1
An error occurred (AccessDeniedException) when calling the BatchGetTriggers operation: No access to any requested resource.
```
L'esempio seguente mostra i risultati quando Tom cerca di accedere al trigger `t2` e `t3` (che non esiste) nella stessa chiamata `BatchGetTriggers`. Nota che poiché Tom ha accesso al trigger `t2` esistente, viene restituito solo `t2`. Sebbene a Tom sia consentito accedere al trigger `t3`, il trigger `t3` non esiste e pertanto `t3` viene restituito nella risposta in un elenco di `"TriggersNotFound": []`.
```
aws glue batch-get-triggers --trigger-names t2 t3
{
"Triggers": {
"State": "CREATED",
"Type": "SCHEDULED",
"Name": "t2",
"Actions": [
{
"JobName": "j2"
}
],
"TriggersNotFound": ["t3"],
"Schedule": "cron(0 0/1 * * ? *)"
}
}
```
## Controllo delle impostazioni utilizzando le chiavi di condizione o di contesto
Quando si concedono le autorizzazioni per creare e aggiornare i processi, è possibile utilizzare le chiavi di condizione o le chiavi di contesto. Queste sezioni trattano le chiavi:
+ [Policy di controllo che controllano le impostazioni utilizzando le chiavi di condizione](#glue-identity-based-policy-condition-key-vpc)
+ [Policy di controllo che controllano le impostazioni utilizzando le chiavi di contesto](#glue-identity-based-policy-context-key-glue)
### Policy di controllo che controllano le impostazioni utilizzando le chiavi di condizione
AWS Glue fornisce tre chiavi `glue:VpcIds` di condizione IAM e`glue:SecurityGroupIds`. `glue:SubnetIds` Quando si concedono le autorizzazioni per creare e aggiornare i processi, è possibile utilizzare le chiavi di condizione nelle policy IAM. È possibile utilizzare questa impostazione per garantire che i processi o le sessioni non vengano creati (o aggiornati) per essere eseguiti al di fuori dell'ambiente VPC desiderato. Le informazioni sull'impostazione del VPC non sono un input diretto dalla richiesta `CreateJob`, ma vengono inferite dal campo "connessioni" del processo che punta a una connessione AWS Glue.
**Esempio di utilizzo**
Crea un tipo di connessione di AWS Glue rete denominata "traffic-monitored-connection" con il VpcId «vpc-id1234" desiderato, e. SubnetIds SecurityGroupIds
Specifica la condizione delle chiavi di condizione per le operazioni `CreateJob` e `UpdateJob`nella policy IAM.
```
{
"Effect": "Allow",
"Action": [
"glue:CreateJob",
"glue:UpdateJob"
],
"Resource": [
"*"
],
"Condition": {
"ForAnyValue:StringLike": {
"glue:VpcIds": [
"vpc-id1234"
]
}
}
}
```
È possibile creare una policy IAM simile per vietare la creazione di un processo AWS Glue senza specificare le informazioni di connessione.
**Limitazione delle sessioni su VPCs**
Per imporre l'esecuzione delle sessioni create all'interno di un VPC specificato, puoi limitare l'autorizzazione del ruolo aggiungendo un effetto `Deny` all'operazione `glue:CreateSession`, a condizione che glue:vpc-id non sia uguale a vpc-<123>. Esempio:
```
"Effect": "Deny",
"Action": [
"glue:CreateSession"
],
"Condition": {
"StringNotEquals" : {"glue:VpcIds" : ["vpc-123"]}
}
```
È inoltre possibile imporre l'esecuzione delle sessioni create all'interno di un VPC aggiungendo un effetto `Deny` all'operazione `glue:CreateSession` a condizione che `glue:vpc-id` sia nullo. Esempio:
```
{
"Effect": "Deny",
"Action": [
"glue:CreateSession"
],
"Condition": {
"Null": {"glue:VpcIds": true}
}
},
{
"Effect": "Allow",
"Action": [
"glue:CreateSession"
],
"Resource": ["*"]
}
```
### Policy di controllo che controllano le impostazioni utilizzando le chiavi di contesto
AWS Glue fornisce una chiave di contesto (`glue:CredentialIssuingService= glue.amazonaws.com`) per ogni sessione di ruolo che AWS Glue rende disponibile per l'endpoint job e developer. Ciò consente di implementare controlli di sicurezza per le azioni intraprese dagli AWS Glue script. AWS Gluefornisce un'altra chiave di contesto (`glue:RoleAssumedBy=glue.amazonaws.com`) per ogni sessione di ruolo in cui AWS Glue effettua una chiamata a un altro AWS servizio per conto del cliente (non tramite un job/dev endpoint, ma direttamente dal AWS Glue servizio).
**Esempio di utilizzo**
Specifica l'autorizzazione condizionale nella policy IAM e allegala al ruolo che deve essere utilizzato da un processo AWS Glue. Ciò garantisce che determinate azioni si allowed/denied basino sull'utilizzo della sessione di ruolo per un ambiente di AWS Glue job runtime.
```
{
"Effect": "Allow",
"Action": "s3:GetObject",
"Resource": "arn:aws:s3:::amzn-s3-demo-bucket/*",
"Condition": {
"StringEquals": {
"glue:CredentialIssuingService": "glue.amazonaws.com"
}
}
}
```
## Negare a un'identità la possibilità di creare sessioni di anteprima dei dati
Questa sezione contiene un esempio di policy IAM utilizzato per negare a un'identità la possibilità di creare sessioni di anteprima dei dati. Collega questa policy all'identità, che è distinta dal ruolo utilizzato dalla sessione di anteprima dei dati durante la sua esecuzione.
```
{
"Sid": "DatapreviewDeny",
"Effect": "Deny",
"Action": [
"glue:CreateSession"
],
"Resource": [
"arn:aws:glue:*:*:session/glue-studio-datapreview*"
]
}
```
# Esempi di policy basate sulle risorse per Glue AWS
Questa sezione contiene le policy di esempio basate su risorse, tra cui le policy che concedono l'accesso multi-account.
Gli esempi utilizzano il AWS Command Line Interface (AWS CLI) per interagire con le operazioni dell'API di AWS Glue servizio. È possibile eseguire le stesse operazioni sulla AWS Glue console o utilizzando una delle AWS SDKs.
**Importante**
Modificando una policy della risorsa AWS Glue, potresti accidentalmente revocare le autorizzazioni per gli utenti AWS Glue esistenti nel tuo account e provocare interruzioni impreviste. Prova questi esempi solo con gli account di sviluppo o di test e verifica che non interrompano nessun flusso di lavoro esistente prima di apportare le modifiche.
**Topics**
+ [Considerazioni sull'utilizzo di politiche basate sulle risorse con Glue AWS](#security_iam_resource-based-policy-examples-considerations)
+ [Utilizza una policy della risorsa per controllare gli accessi nello stesso account](#glue-policy-resource-policies-example-same-account)
## Considerazioni sull'utilizzo di politiche basate sulle risorse con Glue AWS
**Nota**
Sia le policy IAM che una policy della risorsa AWS Glue richiedono pochi secondi, per la propagazione. Dopo aver collegato una nuova policy, potresti anche notare che la policy precedente è ancora in vigore finché la nuova policy non viene propagata attraverso il sistema.
È possibile utilizzare un documento di policy scritte in formato JSON per creare o modificare una policy della risorsa. La sintassi della policy è la stessa di una policy IAM basata sulle identità (consulta la [documentazione di riferimento sulle policy JSON IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies.html)), con le seguenti eccezioni:
+ Un blocco `"Principal"` o `"NotPrincipal"` è obbligatorio per ogni istruzione di policy.
+ Il `"Principal"` o il `"NotPrincipal"` deve identificare principali esistenti validi. I modelli dei caratteri jolly (ad esempio `arn:aws:iam::account-id:user/*`) non sono consentiti.
+ Il `"Resource"` blocco della policy richiede che tutte le risorse corrispondano ARNs alla seguente sintassi delle espressioni regolari (dove la prima `%s` è la e la seconda è *region* la): `%s` *account-id*
```
*arn:aws:glue:%s:%s:(\*|[a-zA-Z\*]+\/?.*)
```
Ad esempio, sia `arn:aws:glue:us-west-2:account-id:*` che `arn:aws:glue:us-west-2:account-id:database/default` sono consentiti, ma non è consentito `*`.
+ A differenza delle politiche basate sull'identità, una policy relativa alle AWS Glue risorse deve contenere solo Amazon Resource Names (ARNs) di risorse che appartengono al catalogo a cui è allegata la policy. Queste iniziano ARNs sempre con. `arn:aws:glue:`
+ Una policy non può impedire l'ulteriore creazione o modifica dell'identità che la crea.
+ La dimensione di un documento JSON di policy della risorsa non può superare 10 KB.
## Utilizza una policy della risorsa per controllare gli accessi nello stesso account
In questo esempio, un utente admin nell'account A crea una policy della risorsa che concede all'utente IAM `Alice` dell'account A l'accesso completo al catalogo. Alice non ha alcuna policy IAM collegata.
Per fare ciò, l'utente amministratore esegue il seguente AWS CLI comando.
```
# Run as admin of Account A
$ aws glue put-resource-policy --profile administrator-name --region us-west-2 --policy-in-json '{
"Version": "2012-10-17",
"Statement": [
{
"Principal": {
"AWS": [
"arn:aws:iam::account-A-id:user/Alice"
]
},
"Effect": "Allow",
"Action": [
"glue:*"
],
"Resource": [
"arn:aws:glue:us-west-2:account-A-id:*"
]
}
]
}'
```
Invece di inserire il documento di policy JSON come parte del AWS CLI comando, potete salvare un documento di policy in un file e fare riferimento al percorso del file nel AWS CLI comando, preceduto da. `file://` Di seguito è riportato un esempio di come svolgere questa operazione.
```
$ echo '{
"Version": "2012-10-17",
"Statement": [
{
"Principal": {
"AWS": [
"arn:aws:iam::account-A-id:user/Alice"
]
},
"Effect": "Allow",
"Action": [
"glue:*"
],
"Resource": [
"arn:aws:glue:us-west-2:account-A-id:*"
]
}
]
}' > /temp/policy.json
$ aws glue put-resource-policy --profile admin1 \
--region us-west-2 --policy-in-json file:///temp/policy.json
```
Dopo la propagazione di questa policy basata sulle risorse, Alice può accedere a tutte le risorse di AWS Glue nell'account A, come segue.
```
# Run as user Alice
$ aws glue create-database --profile alice --region us-west-2 --database-input '{
"Name": "new_database",
"Description": "A new database created by Alice",
"LocationUri": "s3://amzn-s3-demo-bucket"
}'
$ aws glue get-table --profile alice --region us-west-2 --database-name "default" --table-name "tbl1"}
```
in risposta alla chiamata `get-table` di Alice, il servizio AWS Glue restituisce quanto segue.
```
{
"Table": {
"Name": "tbl1",
"PartitionKeys": [],
"StorageDescriptor": {
......
},
......
}
}
```