* con il nome del ruolo del flusso di lavoro.
| Tipo di policy | Policy |
| --- | --- |
| AWS politica gestita | AWSGlueConsoleFullAccess |
| politica in linea (di base) | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/lake-formation/latest/dg/permissions-reference.html) |
| Politica in linea (per le operazioni su tabelle gestite, incluse le operazioni all'interno delle transazioni) | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/lake-formation/latest/dg/permissions-reference.html) |
| Policy in linea (per il controllo dell'accesso ai metadati utilizzando il metodo di controllo degli accessi basato su tag Lake Formation (LF-TBAC)) | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/lake-formation/latest/dg/permissions-reference.html) |
| Politica in linea (politica passrole per il ruolo del flusso di lavoro) | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/lake-formation/latest/dg/permissions-reference.html) |
### Autorizzazioni per analisti di dati
| Tipo di policy | Policy |
| --- | --- |
| AWS politica gestita | AmazonAthenaFullAccess |
| politica in linea (di base) | {
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"lakeformation:GetDataAccess",
"glue:GetTable",
"glue:GetTables",
"glue:SearchTables",
"glue:GetDatabase",
"glue:GetDatabases",
"glue:GetPartitions",
"lakeformation:GetResourceLFTags",
"lakeformation:ListLFTags",
"lakeformation:GetLFTag",
"lakeformation:SearchTablesByLFTags",
"lakeformation:SearchDatabasesByLFTags"
],
"Resource": "*"
}
]
} |
| (Facoltativo) Politica in linea (per le operazioni su tabelle gestite, incluse le operazioni all'interno delle transazioni) | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/lake-formation/latest/dg/permissions-reference.html) |
### Autorizzazioni relative ai ruoli del workflow
Questo ruolo dispone delle autorizzazioni necessarie per eseguire un flusso di lavoro. Si specifica un ruolo con queste autorizzazioni quando si crea un flusso di lavoro.
**Importante**
Nelle seguenti politiche, sostituiscilo ** con un identificatore di AWS regione valido (ad esempio`us-east-1`), ** con un numero di AWS account valido, ** con il nome del ruolo del flusso di lavoro e ** con il percorso Amazon S3 verso AWS CloudTrail i log.
| Tipo di policy | Policy |
| --- | --- |
| AWS politica gestita | AWSGlueServiceRole |
| policy in linea (accesso ai dati) | {
"Version": "2012-10-17",
"Statement": [
{
"Sid": "Lakeformation",
"Effect": "Allow",
"Action": [
"lakeformation:GetDataAccess",
"lakeformation:GrantPermissions"
],
"Resource": "*"
}
]
} |
| Politica in linea (politica passrole per il ruolo del flusso di lavoro) | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/lake-formation/latest/dg/permissions-reference.html) |
| Policy in linea (per l'acquisizione di dati all'esterno del data lake, ad esempio log) AWS CloudTrail | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/lake-formation/latest/dg/permissions-reference.html) |
# Modifica delle impostazioni predefinite per il data lake
Per mantenere la retrocompatibilità conAWS Glue, AWS Lake Formation dispone delle seguenti impostazioni di sicurezza iniziali:
+ L'`Super`autorizzazione viene concessa al gruppo `IAMAllowedPrincipals` su tutte le risorse del AWS Glue Data Catalog esistenti.
+ Le impostazioni «Usa solo il controllo di accesso IAM» sono abilitate per le nuove risorse del Data Catalog.
Queste impostazioni fanno sì che l'accesso alle risorse di Data Catalog e alle sedi Amazon S3 sia controllato esclusivamente da policy AWS Identity and Access Management (IAM). Le autorizzazioni individuali di Lake Formation non sono valide.
Il `IAMAllowedPrincipals` gruppo include tutti gli utenti e i ruoli IAM a cui è consentito l'accesso alle risorse del Data Catalog in base alle politiche IAM. L'`Super`autorizzazione consente a un principale di eseguire tutte le operazioni di Lake Formation supportate sul database o sulla tabella su cui è concessa.
Per modificare le impostazioni di sicurezza in modo che l'accesso alle risorse del Data Catalog (database e tabelle) sia gestito dalle autorizzazioni di Lake Formation, procedi come segue:
1. Modifica le impostazioni di sicurezza predefinite per le nuove risorse. Per istruzioni, consulta [Modifica il modello di autorizzazione predefinito o utilizza la modalità di accesso ibrida](initial-lf-config.md#setup-change-cat-settings).
1. Modifica le impostazioni per le risorse esistenti del Data Catalog. Per istruzioni, consulta [Aggiornamento delle autorizzazioni per AWS Glue i dati al modello AWS Lake Formation](upgrade-glue-lake-formation.md).
**Modifica delle impostazioni di sicurezza predefinite utilizzando l'operazione dell'`PutDataLakeSettings`API Lake Formation**
Puoi anche modificare le impostazioni di sicurezza predefinite utilizzando l'operazione [PutDataLakeSettings](https://docs.aws.amazon.com/lake-formation/latest/APIReference/API_PutDataLakeSettings.html)API Lake Formation. Questa azione utilizza come argomenti un ID di catalogo e una [DataLakeSettings](https://docs.aws.amazon.com/lake-formation/latest/APIReference/API_DataLakeSettings.html)struttura opzionali.
Per applicare i metadati e il controllo dell'accesso ai dati sottostanti da parte di Lake Formation su nuovi database e tabelle, codifica la `DataLakeSettings` struttura come segue.
**Nota**
Sostituiscilo ** con un ID AWS account valido e ** con un nome utente IAM valido. Puoi specificare più di un utente come amministratore del data lake.
```
{
"DataLakeSettings": {
"DataLakeAdmins": [
{
"DataLakePrincipalIdentifier": "arn:aws:iam:::user/"
}
],
"CreateDatabaseDefaultPermissions": [],
"CreateTableDefaultPermissions": []
}
}
```
È inoltre possibile codificare la struttura come segue. Omettere il `CreateTableDefaultPermissions` parametro `CreateDatabaseDefaultPermissions` or equivale a passare un elenco vuoto.
```
{
"DataLakeSettings": {
"DataLakeAdmins": [
{
"DataLakePrincipalIdentifier": "arn:aws:iam:::user/"
}
]
}
}
```
Questa azione revoca efficacemente tutte le autorizzazioni di Lake Formation dal `IAMAllowedPrincipals` gruppo su nuovi database e tabelle. Quando crei un database, puoi sovrascrivere questa impostazione.
Per applicare i metadati e il controllo dell'accesso ai dati sottostanti solo da parte di IAM su nuovi database e tabelle, codifica la `DataLakeSettings` struttura come segue.
```
{
"DataLakeSettings": {
"DataLakeAdmins": [
{
"DataLakePrincipalIdentifier": "arn:aws:iam:::user/"
}
],
"CreateDatabaseDefaultPermissions": [
{
"Principal": {
"DataLakePrincipalIdentifier": "IAM_ALLOWED_PRINCIPALS"
},
"Permissions": [
"ALL"
]
}
],
"CreateTableDefaultPermissions": [
{
"Principal": {
"DataLakePrincipalIdentifier": "IAM_ALLOWED_PRINCIPALS"
},
"Permissions": [
"ALL"
]
}
]
}
}
```
Ciò concede a `Super` Lake Formation l'autorizzazione al `IAMAllowedPrincipals` gruppo su nuovi database e tabelle. Quando crei un database, puoi sovrascrivere questa impostazione.
**Nota**
Nella `DataLakeSettings` struttura precedente, l'unico valore consentito per `DataLakePrincipalIdentifier` è e `IAM_ALLOWED_PRINCIPALS` l'unico valore consentito per `Permissions` è. `ALL`
# Autorizzazioni implicite di Lake Formation
AWS Lake Formation concede le seguenti autorizzazioni implicite agli amministratori di data lake, ai creatori di database e ai creatori di tabelle.
**amministratori di data lake**
+ Hanno `Describe` accesso a tutte le risorse del Data Catalog ad eccezione delle risorse condivise da un altro account direttamente con un altro principale. Questo accesso non può essere revocato a un amministratore.
+ Disponi delle autorizzazioni per la localizzazione dei dati ovunque nel data lake.
+ Può concedere o revocare l'accesso a qualsiasi risorsa del Data Catalog a qualsiasi principale (incluso se stesso). Questo accesso non può essere revocato a un amministratore.
+ Può creare database nel Data Catalog.
+ Può concedere il permesso di creare un database a un altro utente.
Gli amministratori di Data Lake possono registrare le sedi Amazon S3 solo se dispongono delle autorizzazioni IAM necessarie per farlo. Le politiche di amministrazione dei data lake suggerite in questa guida concedono tali autorizzazioni. Inoltre, gli amministratori dei data lake non dispongono delle autorizzazioni implicite per eliminare database o alter/drop tabelle creati da altri. Tuttavia, possono concedersi le autorizzazioni per farlo.
Per ulteriori informazioni sugli amministratori del data lake, consulta. [Crea un amministratore del data lake](initial-lf-config.md#create-data-lake-admin)
**Creatori di cataloghi**
+ Dispongono di tutte le autorizzazioni di catalogo sui cataloghi che creano, delle autorizzazioni sui database e sulle tabelle che creano nel catalogo e possono concedere ad altri responsabili dello stesso AWS account il permesso di creare database e tabelle nel catalogo. Un creatore di catalogo che dispone anche della politica `AWSLakeFormationCrossAccountManager` AWS gestita può concedere le autorizzazioni sul catalogo ad altri account o organizzazioni. AWS
Gli amministratori di Data Lake possono utilizzare la console o l'API di Lake Formation per designare i creatori del catalogo.
**Nota**
I creatori di cataloghi non dispongono implicitamente delle autorizzazioni sui database e sulle tabelle che altri creano nel catalogo.
Per ulteriori informazioni sulla creazione di cataloghi, consulta. [Inserire i dati nel AWS Glue Data Catalog](bring-your-data-overview.md)
**Creatori di database**
+ Dispongono di tutte le autorizzazioni di database sui database che creano, delle autorizzazioni sulle tabelle che creano nel database e possono concedere ad altri responsabili dello stesso AWS account il permesso di creare tabelle nel database. Un creatore di database che dispone anche della politica `AWSLakeFormationCrossAccountManager` AWS gestita può concedere le autorizzazioni sul database ad altri AWS account o organizzazioni.
Gli amministratori di Data Lake possono utilizzare la console o l'API di Lake Formation per designare i creatori di database.
**Nota**
I creatori di database non dispongono implicitamente delle autorizzazioni sulle tabelle create da altri nel database.
Per ulteriori informazioni, consulta [Creazione di un database](creating-database.md).
**I creatori di tabelle**
+ Disponi di tutte le autorizzazioni sulle tabelle che creano.
+ Possono concedere le autorizzazioni su tutte le tabelle che creano ai responsabili dello stesso account. AWS
+ Può concedere le autorizzazioni su tutte le tabelle che crea ad altri AWS account o organizzazioni se dispongono della `AWSLakeFormationCrossAccountManager` AWS politica gestita.
+ Può visualizzare i database che contengono le tabelle che crea.
# Riferimento alle autorizzazioni di Lake Formation
Per eseguire AWS Lake Formation le operazioni, i mandanti necessitano sia delle autorizzazioni di Lake Formation che delle autorizzazioni AWS Identity and Access Management (IAM). In genere concedi le autorizzazioni IAM utilizzando politiche di controllo degli *accessi granulari,* come descritto in. [Panoramica delle autorizzazioni di Lake Formation](lf-permissions-overview.md) Puoi concedere le autorizzazioni di Lake Formation utilizzando la console, l'API o AWS Command Line Interface (AWS CLI).
Per informazioni su come concedere o revocare le autorizzazioni di Lake Formation, vedere e. [Concessione delle autorizzazioni per le risorse del Data Catalog](granting-catalog-permissions.md) [Concessione delle autorizzazioni per la localizzazione dei dati](granting-location-permissions.md)
**Nota**
Gli esempi in questa sezione mostrano come concedere le autorizzazioni ai responsabili dello stesso account. AWS Per esempi di sovvenzioni su più account, vedere. [Condivisione dei dati tra account in Lake Formation](cross-account-permissions.md)
## Autorizzazioni Lake Formation per tipo di risorsa
Di seguito sono riportate le autorizzazioni valide di Lake Formation disponibili per ogni tipo di risorsa:
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/lake-formation/latest/dg/lf-permissions-reference.html)
**Topics**
+ [Autorizzazioni Lake Formation per tipo di risorsa](#lf-resource-permissions-summary)
+ [I comandi di concessione e AWS CLI revoca di Lake Formation](#perm-command-format)
+ [Autorizzazioni Lake Formation](#lf-permissions)
## I comandi di concessione e AWS CLI revoca di Lake Formation
Ogni descrizione dell'autorizzazione in questa sezione include esempi di concessione dell'autorizzazione tramite un comando. AWS CLI Di seguito sono riportate le sinossi **grant-permissions** e **revoke-permissions** AWS CLI i comandi del Lake Formation.
```
grant-permissions
[--catalog-id ]
--principal
--resource
--permissions
[--permissions-with-grant-option ]
[--cli-input-json ]
[--generate-cli-skeleton ]
```
```
revoke-permissions
[--catalog-id ]
--principal
--resource
--permissions
[--permissions-with-grant-option ]
[--cli-input-json ]
[--generate-cli-skeleton ]
```
[https://docs.aws.amazon.com/cli/latest/reference/lakeformation/revoke-permissions.html](https://docs.aws.amazon.com/cli/latest/reference/lakeformation/revoke-permissions.html) Questa sezione fornisce informazioni aggiuntive sull'opzione. `--principal`
Il valore dell'`--principal`opzione è uno dei seguenti:
+ Amazon Resource Name (ARN) per un utente o un AWS Identity and Access Management ruolo (IAM)
+ ARN per un utente o un gruppo che esegue l'autenticazione tramite un provider SAML, come Microsoft Active Directory Federation Service (ADFS)
+ ARN per un utente o un gruppo Amazon Quick
+ Per le autorizzazioni su più account, un ID AWS account, un ID dell'organizzazione o un ID di unità organizzativa
+ Per utente o gruppo IAM Identity Center, ARN per utenti o gruppi IAM Identity Center.
Di seguito sono riportati la sintassi e gli esempi per tutti i `--principal` tipi.
**Principal è un utente IAM**
Sintassi:
```
--principal DataLakePrincipalIdentifier=arn:aws:iam:::user/
```
Esempio:
```
--principal DataLakePrincipalIdentifier=arn:aws:iam::111122223333:user/datalake_user1
```
**Principal è un ruolo IAM**
Sintassi:
```
--principal DataLakePrincipalIdentifier=arn:aws:iam:::role/
```
Esempio:
```
--principal DataLakePrincipalIdentifier=arn:aws:iam::111122223333:role/workflowrole
```
**Principal è un utente che si autentica tramite un provider SAML**
Sintassi:
```
--principal DataLakePrincipalIdentifier=arn:aws:iam:::saml-provider/:user/
```
Esempi:
```
--principal DataLakePrincipalIdentifier=arn:aws:iam::111122223333:saml-provider/idp1:user/datalake_user1
```
```
--principal DataLakePrincipalIdentifier=arn:aws:iam::111122223333:saml-provider/AthenaLakeFormationOkta:user/athena-user@example.com
```
**Principal è un gruppo che si autentica tramite un provider SAML**
Sintassi:
```
--principal DataLakePrincipalIdentifier=arn:aws:iam:::saml-provider/:group/
```
Esempi:
```
--principal DataLakePrincipalIdentifier=arn:aws:iam::111122223333:saml-provider/idp1:group/data-scientists
```
```
--principal DataLakePrincipalIdentifier=arn:aws:iam::111122223333:saml-provider/AthenaLakeFormationOkta:group/my-group
```
**Principal è un utente di Amazon Quick Enterprise Edition**
Sintassi:
```
--principal DataLakePrincipalIdentifier=arn:aws:quicksight:::user//
```
Per **, è necessario specificare `default`.
Esempio:
```
--principal DataLakePrincipalIdentifier=arn:aws:quicksight:us-east-1:111122223333:user/default/bi_user1
```
**Principal è un gruppo Amazon Quick Enterprise Edition**
Sintassi:
```
--principal DataLakePrincipalIdentifier=arn:aws:quicksight:::group//
```
Per **, è necessario specificare `default`.
Esempio:
```
--principal DataLakePrincipalIdentifier=arn:aws:quicksight:us-east-1:111122223333:group/default/data_scientists
```
**Principal è un AWS account**
Sintassi:
```
--principal DataLakePrincipalIdentifier=
```
Esempio:
```
--principal DataLakePrincipalIdentifier=111122223333
```
**Il preside è un'organizzazione**
Sintassi:
```
--principal DataLakePrincipalIdentifier=arn:aws:organizations:::organization/
```
Esempio:
```
--principal DataLakePrincipalIdentifier=arn:aws:organizations::111122223333:organization/o-abcdefghijkl
```
**Il preside è un'unità organizzativa**
Sintassi:
```
--principal DataLakePrincipalIdentifier=arn:aws:organizations:::ou//
```
Esempio:
```
--principal DataLakePrincipalIdentifier=arn:aws:organizations::111122223333:ou/o-abcdefghijkl/ou-ab00-cdefghij
```
**Il preside è un utente o un gruppo di identità di IAM Identity Center**
Esempio: utente
```
--principal DataLakePrincipalIdentifier=arn:aws:identitystore:::user/
```
Esempio: Gruppo:
```
--principal DataLakePrincipalIdentifier=arn:aws:identitystore:::group/
```
**Principal è un gruppo IAM - `IAMAllowedPrincipals`**
Lake Formation imposta le `Super` autorizzazioni su tutti i database e le tabelle del Data Catalog a un gruppo chiamato per `IAMAllowedPrincipals` impostazione predefinita. Se questa autorizzazione di gruppo esiste su un database o una tabella, tutti i principali del tuo account avranno accesso alla risorsa tramite le politiche principali IAM per AWS Glue. Fornisce la compatibilità con le versioni precedenti quando inizi a utilizzare le autorizzazioni di Lake Formation per proteggere le risorse del Data Catalog per cui in precedenza erano protette dalle politiche IAM. AWS Glue
Quando utilizzi Lake Formation per gestire le autorizzazioni per le tue risorse Data Catalog, devi prima revocare l'`IAMAllowedPrincipals`autorizzazione sulle risorse o attivare i principali e le risorse per la modalità di accesso ibrido affinché le autorizzazioni di Lake Formation funzionino.
Esempio:
```
--principal DataLakePrincipalIdentifier=IAM_Allowed_Principals
```
**Principal è un gruppo IAM - `ALLIAMPrincipals`**
Quando concedi le autorizzazioni per il `ALLIAMPrincipals` gruppo su una risorsa Data Catalog, ogni principale dell'account ottiene l'accesso alla risorsa Data Catalog utilizzando le autorizzazioni Lake Formation e le autorizzazioni IAM.
Esempio:
```
--principal DataLakePrincipalIdentifier=123456789012:IAMPrincipals
```
## Autorizzazioni Lake Formation
Questa sezione contiene i permessi disponibili di Lake Formation che puoi concedere ai presidi.
### `ALTER`
| Autorizzazione | Concesso su questa risorsa | Inoltre, il beneficiario ha bisogno |
| --- | --- | --- |
| ALTER | DATABASE | glue:UpdateDatabase |
| ALTER | TABLE | glue:UpdateTable |
| ALTER | LF-Tag | lakeformation:UpdateLFTag |
Un principale con questa autorizzazione può modificare i metadati di un database o di una tabella nel Catalogo dati. Per le tabelle, è possibile modificare lo schema delle colonne e aggiungere parametri di colonna. Non è possibile modificare le colonne nei dati sottostanti a cui fa riferimento una tabella di metadati.
Se la proprietà da modificare è una posizione registrata di Amazon Simple Storage Service (Amazon S3), il principale deve disporre delle autorizzazioni per la localizzazione dei dati nella nuova posizione.
**Example**
L'esempio seguente concede l'`ALTER`autorizzazione all'utente `datalake_user1` sul database `retail` nell'account 1111-2222-3333. AWS
```
aws lakeformation grant-permissions --principal DataLakePrincipalIdentifier=arn:aws:iam::111122223333:user/datalake_user1 --permissions "ALTER" --resource '{ "Database": {"Name":"retail"}}'
```
**Example**
L'esempio seguente concede `ALTER` a un utente l'`datalake_user1`accesso alla tabella del database. `inventory` `retail`
```
aws lakeformation grant-permissions --principal DataLakePrincipalIdentifier=arn:aws:iam::111122223333:user/datalake_user1 --permissions "ALTER" --resource '{ "Table": {"DatabaseName":"retail", "Name":"inventory"}}'
```
### `CREATE_DATABASE`
| Autorizzazione | Concesso su questa risorsa | Inoltre, il beneficiario ha bisogno |
| --- | --- | --- |
| CREATE\$1DATABASE | Catalogo dati | glue:CreateDatabase |
Un responsabile con questa autorizzazione può creare un database di metadati o un collegamento a una risorsa nel Catalogo dati. Il principale può anche creare tabelle nel database.
**Example**
L'esempio seguente concede `CREATE_DATABASE` a un utente `datalake_user1` nell' AWS account 1111-2222-3333.
```
aws lakeformation grant-permissions --principal DataLakePrincipalIdentifier=arn:aws:iam::111122223333:user/datalake_user1 --permissions "CREATE_DATABASE" --resource '{ "Catalog": {}}'
```
Quando un principale crea un database nel Data Catalog, non viene concessa alcuna autorizzazione per i dati sottostanti. Vengono concesse le seguenti autorizzazioni aggiuntive per i metadati (oltre alla possibilità di concedere tali autorizzazioni ad altri):
+ `CREATE_TABLE`nel database
+ Database `ALTER`
+ Database `DROP`
Quando crea un database, il principale può facoltativamente specificare una posizione Amazon S3. A seconda che il principale disponga delle autorizzazioni per la localizzazione dei dati, l'`CREATE_DATABASE`autorizzazione potrebbe non essere sufficiente per creare database in tutti i casi. È importante tenere a mente i tre casi seguenti.
| Crea un caso d'uso del database | Autorizzazioni necessarie |
| --- | --- |
| La proprietà location non è specificata. | CREATE\$1DATABASEè sufficiente. |
| La proprietà location è specificata e la posizione non è gestita da Lake Formation (non è registrata). | CREATE\$1DATABASEè sufficiente. |
| La proprietà location è specificata e la posizione è gestita da Lake Formation (è registrata). | CREATE\$1DATABASEè obbligatorio più le autorizzazioni di localizzazione dei dati nella posizione specificata. |
### `CREATE_TABLE`
| Autorizzazione | Concesso su questa risorsa | Inoltre, il beneficiario ha bisogno |
| --- | --- | --- |
| CREATE\$1TABLE | DATABASE | glue:CreateTable |
Un principale con questa autorizzazione può creare una tabella di metadati o un collegamento a una risorsa nel Catalogo dati all'interno del database specificato.
**Example**
L'esempio seguente concede all'utente l'`datalake_user1`autorizzazione a creare tabelle nel `retail` database nell' AWS account 1111-2222-3333.
```
aws lakeformation grant-permissions --principal DataLakePrincipalIdentifier=arn:aws:iam::111122223333:user/datalake_user1
--permissions "CREATE_TABLE" --resource '{ "Database": {"Name":"retail"}}'
```
Quando un principale crea una tabella nel Data Catalog, tutti i permessi di Lake Formation sulla tabella vengono concessi al principale, con la possibilità di concedere tali autorizzazioni ad altri.
**Sovvenzioni per più account**
Se un account del proprietario del database concede `CREATE_TABLE` a un account destinatario e un utente dell'account destinatario crea correttamente una tabella nel database dell'account proprietario, si applicano le seguenti regole:
+ Gli amministratori utente e data lake nell'account del destinatario dispongono di tutte le autorizzazioni di Lake Formation sulla tabella. Possono concedere le autorizzazioni sulla tabella ad altri responsabili del loro account. Non possono concedere autorizzazioni ai responsabili dell'account proprietario o di qualsiasi altro account.
+ Gli amministratori di Data Lake dell'account proprietario possono concedere le autorizzazioni relative alla tabella ad altri responsabili del proprio account.
**Autorizzazioni per la localizzazione dei dati**
Quando tenti di creare una tabella che punti a una posizione Amazon S3, a seconda che tu disponga delle autorizzazioni per la localizzazione dei dati, l'`CREATE_TABLE`autorizzazione potrebbe non essere sufficiente per creare una tabella. È importante tenere a mente i seguenti tre casi.
| Crea un caso d'uso della tabella | Autorizzazioni necessarie |
| --- | --- |
| La località specificata non è gestita da Lake Formation (non è registrata). | CREATE\$1TABLEè sufficiente. |
| La posizione specificata è gestita da Lake Formation (è registrata) e il database contenente non ha alcuna proprietà location o ha una proprietà location che non sia un prefisso Amazon S3 della posizione della tabella. | CREATE\$1TABLEè richiesta più le autorizzazioni di localizzazione dei dati nella posizione specificata. |
| La posizione specificata è gestita da Lake Formation (è registrata) e il database che lo contiene ha una proprietà location che punta a una posizione registrata ed è un prefisso Amazon S3 della posizione della tabella. | CREATE\$1TABLEè sufficiente. |
### `DATA_LOCATION_ACCESS`
| Autorizzazione | Concesso su questa risorsa | Inoltre, il beneficiario ha bisogno |
| --- | --- | --- |
| DATA\$1LOCATION\$1ACCESS | Posizione di Amazon S3. | (Autorizzazioni Amazon S3 sulla posizione, che devono essere specificate dal ruolo utilizzato per registrare la posizione.) |
Questa è l'unica autorizzazione per la localizzazione dei dati. Un principale con questa autorizzazione può creare un database o una tabella di metadati che punti alla posizione Amazon S3 specificata. La sede deve essere registrata. Un preside che dispone delle autorizzazioni per la localizzazione dei dati su una sede dispone anche delle autorizzazioni di localizzazione per le sedi dei figli.
**Example**
L'esempio seguente concede le autorizzazioni di localizzazione dei dati `s3://products/retail` all'utente `datalake_user1` nell'account 1111-2222-3333. AWS
```
aws lakeformation grant-permissions --principal DataLakePrincipalIdentifier=arn:aws:iam::111122223333:user/datalake_user1 --permissions "DATA_LOCATION_ACCESS" --resource '{ "DataLocation": {"ResourceArn":"arn:aws:s3:::products/retail"}}'
```
`DATA_LOCATION_ACCESS`non è necessario per interrogare o aggiornare i dati sottostanti. Questa autorizzazione si applica solo alla creazione di risorse del catalogo dati.
Per ulteriori informazioni sulle autorizzazioni per la localizzazione dei dati, vedere[Underlying data access control](access-control-underlying-data.md#data-location-permissions).
### `DELETE`
| Autorizzazione | Concesso su questa risorsa | Inoltre, il beneficiario ha bisogno |
| --- | --- | --- |
| DELETE | TABLE | (Non sono necessarie autorizzazioni IAM aggiuntive se la posizione è registrata.) |
Un principale con questa autorizzazione può inserire, aggiornare e leggere i dati sottostanti nella posizione Amazon S3 specificata dalla tabella. Il responsabile può anche visualizzare la tabella sulla console di Lake Formation e recuperare informazioni sulla tabella con l'AWS GlueAPI.
**Example**
L'esempio seguente concede l'`DELETE`autorizzazione all'utente `datalake_user1` sulla tabella del database `inventory` `retail` nell' AWS account 1111-2222-3333.
```
aws lakeformation grant-permissions --principal DataLakePrincipalIdentifier=arn:aws:iam::111122223333:user/datalake_user1 --permissions "DELETE" --resource '{ "Table": {"DatabaseName":"retail", "Name":"inventory"}}'
```
Questa autorizzazione si applica solo ai dati in Amazon S3 e non ai dati in altri archivi di dati come Amazon Relational Database Service (Amazon RDS).
### `DESCRIBE`
| Autorizzazione | Concesso su questa risorsa | Inoltre, il beneficiario ha bisogno |
| --- | --- | --- |
| DESCRIBE | Link alle risorse della tabella Link alle risorse del database | `glue:GetTable` `glue:GetDatabase` |
| DESCRIBE | DATABASE | glue:GetDatabase |
| DESCRIBE | TABLE | glue:GetTable |
| DESCRIBE | LF-Tag | `glue:GetTable` `glue:GetDatabase` `lakeformation:GetResourceLFTags` `lakeformation:ListLFTags` `lakeformation:GetLFTag` `lakeformation:SearchTablesByLFTags` `lakeformation:SearchDatabasesByLFTags` |
Un principale con questa autorizzazione può visualizzare il database, la tabella o il link alla risorsa specificato. Non vengono concesse implicitamente altre autorizzazioni di Data Catalog e non vengono concesse implicitamente autorizzazioni di accesso ai dati. I database e le tabelle vengono visualizzati negli editor di query dei servizi integrati, ma non è possibile eseguire alcuna query su di essi a meno che non vengano concesse altre autorizzazioni di Lake Formation (ad esempio`SELECT`).
Ad esempio, un utente che ha un database può visualizzare il database e tutti i metadati del database (descrizione, posizione e così `DESCRIBE` via). Tuttavia, l'utente non può scoprire quali tabelle contiene il database e non può eliminare, modificare o creare tabelle nel database. Analogamente, un utente che `DESCRIBE` utilizza una tabella può visualizzare la tabella e i relativi metadati (descrizione, schema, posizione e così via), ma non può eliminare, modificare o eseguire query sulla tabella.
Di seguito sono riportate alcune regole aggiuntive per: `DESCRIBE`
+ Se un utente dispone di altre autorizzazioni Lake Formation su un database, una tabella o un collegamento a una risorsa, `DESCRIBE` viene concessa implicitamente.
+ Se un utente ha `SELECT` solo un sottoinsieme di colonne per una tabella (parziale`SELECT`), l'utente è limitato a visualizzare solo quelle colonne.
+ Non puoi concedere `DESCRIBE` a un utente che dispone di una selezione parziale su una tabella. Al contrario, non è possibile specificare elenchi di inclusione o esclusione di colonne per le tabelle a cui `DESCRIBE` è consentito.
**Example**
L'esempio seguente concede all'utente `datalake_user1` l'`DESCRIBE`autorizzazione per il collegamento alle risorse della tabella nel database `inventory-link` `retail` nell' AWS account 1111-2222-3333.
```
aws lakeformation grant-permissions --principal DataLakePrincipalIdentifier=arn:aws:iam::111122223333:user/datalake_user1 --permissions "DESCRIBE" --resource '{ "Table": {"DatabaseName":"retail", "Name":"inventory-link"}}'
```
### `DROP`
| Autorizzazione | Concesso su questa risorsa | Inoltre, il beneficiario ha bisogno |
| --- | --- | --- |
| DROP | DATABASE | glue:DeleteDatabase |
| DROP | TABLE | glue:DeleteTable |
| DROP | LF-Tag | lakeformation:DeleteLFTag |
| DROP | Collegamento alla risorsa del database Link alle risorse della tabella | `glue:DeleteDatabase` `glue:DeleteTable` |
Un principale con questa autorizzazione può eliminare un collegamento a un database, una tabella o una risorsa nel Catalogo dati. Non puoi concedere DROP su un database a un account o un'organizzazione esterni.
**avvertimento**
L'eliminazione di un database comporta l'eliminazione di tutte le tabelle del database.
**Example**
L'esempio seguente concede l'`DROP`autorizzazione all'utente del database `retail` nell' AWS account `datalake_user1` 1111-2222-3333.
```
aws lakeformation grant-permissions --principal DataLakePrincipalIdentifier=arn:aws:iam::111122223333:user/datalake_user1 --permissions "DROP" --resource '{ "Database": {"Name":"retail"}}'
```
**Example**
L'esempio seguente concede `DROP` all'utente l'accesso alla tabella del database`datalake_user1`. `inventory` `retail`
```
aws lakeformation grant-permissions --principal DataLakePrincipalIdentifier=arn:aws:iam::111122223333:user/datalake_user1 --permissions "DROP" --resource '{ "Table": {"DatabaseName":"retail", "Name":"inventory"}}'
```
**Example**
L'esempio che segue concede `DROP` all'utente `datalake_user1` della tabella un link di risorse `inventory-link` nel database. `retail`
```
aws lakeformation grant-permissions --principal DataLakePrincipalIdentifier=arn:aws:iam::111122223333:user/datalake_user1 --permissions "DROP" --resource '{ "Table": {"DatabaseName":"retail", "Name":"inventory-link"}}'
```
### `INSERT`
| Autorizzazione | Concesso su questa risorsa | Inoltre, il beneficiario ha bisogno |
| --- | --- | --- |
| INSERT | TABLE | (Non sono necessarie autorizzazioni IAM aggiuntive se la posizione è registrata.) |
Un principale con questa autorizzazione può inserire, aggiornare e leggere i dati sottostanti nella posizione Amazon S3 specificata dalla tabella. Il responsabile può anche visualizzare la tabella nella console di Lake Formation e recuperare informazioni sulla tabella con l'AWS GlueAPI.
**Example**
L'esempio seguente concede l'`INSERT`autorizzazione all'utente `datalake_user1` sulla tabella del database `inventory` `retail` nell' AWS account 1111-2222-3333.
```
aws lakeformation grant-permissions --principal DataLakePrincipalIdentifier=arn:aws:iam::111122223333:user/datalake_user1 --permissions "INSERT" --resource '{ "Table": {"DatabaseName":"retail", "Name":"inventory"}}'
```
Questa autorizzazione si applica solo ai dati in Amazon S3 e non ai dati in altri archivi di dati come Amazon RDS.
### `SELECT`
| Autorizzazione | Concesso su questa risorsa | Inoltre, il beneficiario ha bisogno |
| --- | --- | --- |
| SELECT | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/lake-formation/latest/dg/lf-permissions-reference.html) | (Non sono necessarie autorizzazioni IAM aggiuntive se la posizione è registrata.) |
Un principale con questa autorizzazione può visualizzare una tabella nel catalogo dati e interrogare i dati sottostanti in Amazon S3 nella posizione specificata dalla tabella. Il responsabile può visualizzare la tabella nella console di Lake Formation e recuperare informazioni sulla tabella con l'AWS GlueAPI. Se il filtraggio delle colonne è stato applicato quando è stata concessa questa autorizzazione, il principale può visualizzare i metadati solo per le colonne incluse e può interrogare i dati solo dalle colonne incluse.
**Nota**
È responsabilità del servizio di analisi integrato applicare il filtro delle colonne durante l'elaborazione di una query.
**Example**
L'esempio seguente concede l'`SELECT`autorizzazione all'utente `datalake_user1` sulla tabella del database `inventory` `retail` nell' AWS account 1111-2222-3333.
```
aws lakeformation grant-permissions --principal DataLakePrincipalIdentifier=arn:aws:iam::111122223333:user/datalake_user1 --permissions "SELECT" --resource '{ "Table": {"DatabaseName":"retail", "Name":"inventory"}}'
```
Questa autorizzazione si applica solo ai dati in Amazon S3 e non ai dati in altri archivi di dati come Amazon RDS.
Puoi filtrare (limitare l'accesso a) colonne specifiche con un elenco di inclusione o un elenco di esclusione facoltativo. Un elenco di inclusione specifica le colonne a cui è possibile accedere. Un elenco di esclusione specifica le colonne a cui non è possibile accedere. In assenza di un elenco di inclusione o esclusione, tutte le colonne della tabella sono accessibili.
I risultati di `glue:GetTable` restituiscono solo le colonne che il chiamante è autorizzato a visualizzare. I servizi integrati come Amazon Athena e Amazon Redshift rispettano gli elenchi di inclusione ed esclusione delle colonne.
**Example**
L'esempio seguente concede `SELECT` all'utente presente nella tabella l'`inventory`utilizzo di `datalake_user1` un elenco di inclusione.
```
aws lakeformation grant-permissions --principal DataLakePrincipalIdentifier=arn:aws:iam::111122223333:user/datalake_user1 --permissions "SELECT" --resource '{ "TableWithColumns": {"DatabaseName":"retail", "Name":"inventory", "ColumnNames": ["prodcode","location","period","withdrawals"]}}'
```
**Example**
L'esempio successivo prevede l'utilizzo di `SELECT` un elenco di esclusione `inventory` nella tabella.
```
aws lakeformation grant-permissions --principal DataLakePrincipalIdentifier=arn:aws:iam::111122223333:user/datalake_user1 --permissions "SELECT" --resource '{ "TableWithColumns": {"DatabaseName":"retail", "Name":"inventory", "ColumnWildcard": {"ExcludedColumnNames": ["intkey", "prodcode"]}}}'
```
Le seguenti restrizioni si applicano all'`SELECT`autorizzazione:
+ Quando si concede`SELECT`, non è possibile includere l'opzione di concessione se viene applicato il filtro delle colonne.
+ Non è possibile limitare il controllo dell'accesso alle colonne che sono chiavi di partizione.
+ A un principale con l'`SELECT`autorizzazione su un sottoinsieme di colonne di una tabella non può essere concessa l'`INSERT`autorizzazione`ALTER`,`DROP`,`DELETE`, o per quella tabella. Analogamente, a un'entità con l'`INSERT`autorizzazione `ALTER``DROP`,`DELETE`, o su una tabella non può essere concessa l'`SELECT`autorizzazione con il filtro delle colonne.
L'`SELECT`autorizzazione appare sempre nella pagina **Autorizzazioni dati** della console Lake Formation come una riga separata. L'immagine seguente mostra che `SELECT` è concesso agli utenti `datalake_user2` e `datalake_user3` su tutte le colonne della `inventory` tabella.
![\[La pagina Autorizzazioni dati mostra quattro righe. La prima e la terza riga elencano la tabella delle autorizzazioni di eliminazione e inserimento con il tipo di risorsa con la risorsa mostrata come inventario, mentre la seconda e la quarta riga elencano l'autorizzazione Seleziona con il tipo di risorsa Column e con la risorsa mostrata come retail.inventory.*.\]](http://docs.aws.amazon.com/it_it/lake-formation/latest/dg/images/data-permissions-dialog-select-cross.png)
### `Super`
| Autorizzazione | Concesso su questa risorsa | Inoltre, il beneficiario ha bisogno |
| --- | --- | --- |
| Super | DATABASE | glue:\$1Database\$1 |
| Super | TABLE | glue:\$1Table\$1, glue:\$1Partition\$1 |
Questa autorizzazione consente a un principale di eseguire tutte le operazioni di Lake Formation supportate sul database o sulla tabella. Non puoi concedere `Super` un database a un account esterno.
Questa autorizzazione può coesistere con le altre autorizzazioni di Lake Formation. Ad esempio, puoi concedere le `INSERT` autorizzazioni `Super``SELECT`, e su una tabella di metadati. Il principale può quindi eseguire tutte le operazioni supportate sulla tabella. Quando si revoca`Super`, le `INSERT` autorizzazioni `SELECT` e rimangono invariate e il principale può eseguire solo operazioni di selezione e inserimento.
Invece di concedere `Super` a un singolo committente, puoi concederlo al gruppo. `IAMAllowedPrincipals` Il `IAMAllowedPrincipals` gruppo viene creato automaticamente e include tutti gli utenti e i ruoli IAM a cui è consentito l'accesso alle risorse del Data Catalog dalle politiche IAM. Quando `Super` viene concesso a `IAMAllowedPrincipals` una risorsa Data Catalog, l'accesso alla risorsa è effettivamente controllato esclusivamente dalle politiche IAM.
Puoi avere l'`Super`autorizzazione da concedere automaticamente `IAMAllowedPrincipals` per nuove risorse del catalogo sfruttando le opzioni nella pagina **Impostazioni** della console Lake Formation.
![\[La finestra di dialogo delle impostazioni del catalogo dati ha il sottotitolo «Autorizzazioni predefinite per database e tabelle appena creati» e ha due caselle di controllo, descritte nel testo.\]](http://docs.aws.amazon.com/it_it/lake-formation/latest/dg/images/settings-page.png)
+ Per concedere `Super` a `IAMAllowedPrincipals` tutti i nuovi database, seleziona **Usa solo il controllo di accesso IAM per i nuovi** database.
+ Per concedere `Super` a `IAMAllowedPrincipals` tutte le nuove tabelle nei nuovi database, seleziona **Usa solo il controllo di accesso IAM per le nuove tabelle nei nuovi database**.
**Nota**
Questa opzione fa sì che la casella di controllo **Usa solo il controllo di accesso IAM per le nuove tabelle in questo database** **nella finestra di dialogo Crea database** sia selezionata per impostazione predefinita. Non fa altro che questo. È la casella di controllo nella finestra di dialogo **Crea database** che abilita la concessione di `Super` a`IAMAllowedPrincipals`.
Queste opzioni della pagina **Impostazioni** sono abilitate per impostazione predefinita. Per ulteriori informazioni, consulta gli argomenti seguenti:
+ [Modifica delle impostazioni predefinite per il data lake](change-settings.md)
+ [Aggiornamento delle autorizzazioni per AWS Glue i dati al modello AWS Lake Formation](upgrade-glue-lake-formation.md)
### `SUPER_USER`
| Autorizzazione | Concesso su questa risorsa | Inoltre, il beneficiario ha bisogno |
| --- | --- | --- |
| Super user | Catalog | glue:GetCatalog |
È possibile concedere l'`Super user`autorizzazione solo a soggetti specifici sui cataloghi all'interno del Data Catalog predefinito. Non puoi concedere l'`Super user`autorizzazione sul catalogo predefinito o su altri tipi di risorse come database e tabelle o ai responsabili degli account esterni. L'`Super user`autorizzazione consente a un responsabile di eseguire tutte le operazioni di Lake Formation supportate sui database e sulle tabelle all'interno del catalogo concesso.
Con l'`Super user`autorizzazione, il principale (beneficiario) è in grado di eseguire le seguenti azioni sulle risorse (cataloghi, database e tabelle) all'interno del catalogo:
+ `CREATE_DATABASE`, `DESCRIBE` autorizzazioni sul catalogo.
+ `DROP`,`ALTER`,`CREATE_TABLE`, `DESCRIBE` (effettivamente`SUPER`) autorizzazioni su tutti i database all'interno del catalogo.
+ `DROP`,,`ALTER`,`DESCRIBE`, `SELECT``INSERT`, `DELETE` (effettivamente`SUPER`) autorizzazioni su tutte le tabelle all'interno di tutti i database all'interno del catalogo.
+ `All`(effettivamente SUPER) autorizzazioni sui cataloghi all'interno del catalogo.
+ Autorizzazioni concedibili (la possibilità di concedere queste autorizzazioni ad altri principali) su tutti i cataloghi, i database e le tabelle all'interno del catalogo.
Con l'`Super user`autorizzazione su una risorsa del catalogo, al beneficiario non è consentito eseguire o delegare alcuna azione sul catalogo. `ALTER` `DROP`
### `ASSOCIATE`
| Autorizzazione | Concesso su questa risorsa | Inoltre, il beneficiario ha bisogno |
| --- | --- | --- |
| ASSOCIATE | LF-Tag | `glue:GetDatabase` `glue:GetTable` `lakeformation:AddLFTagsToResource"` `lakeformation:RemoveLFTagsFromResource"` `lakeformation:GetResourceLFTags` `lakeformation:ListLFTags` `lakeformation:GetLFTag` `lakeformation:SearchTablesByLFTags` `lakeformation:SearchDatabasesByLFTags` |
Un principale con questa autorizzazione su un tag LF può assegnare il tag LF a una risorsa del catalogo dati. `ASSOCIATE``DESCRIBE`Concedere concessioni implicite.
**Example**
Questo esempio concede all'utente l'`ASSOCIATE`autorizzazione per l'uso `datalake_user1` del tag LF con la chiave. `module` Concede le autorizzazioni per visualizzare e assegnare tutti i valori per quella chiave, come indicato dall'asterisco (\$1).
```
aws lakeformation grant-permissions --principal DataLakePrincipalIdentifier=arn:aws:iam::111122223333:user/datalake_user1 --permissions "ASSOCIATE" --resource '{ "LFTag": {"CatalogId":"111122223333","TagKey":"module","TagValues":["*"]}}'
```
# Integrazione di IAM Identity Center
Con AWS IAM Identity Center, puoi connetterti ai provider di identità (IdPs) e gestire centralmente l'accesso per utenti e gruppi tra i servizi di AWS analisi. È possibile integrare gestori di identità digitali come Okta, Ping e Microsoft Entra ID (in precedenza Azure Active Directory) con il Centro identità IAM per consentire agli utenti nell'organizzazione di accedere ai dati utilizzando un'esperienza di accesso singolo. Il Centro identità IAM supporta anche la connessione con altri gestori dell'identità digitali di terze parti.
Per ulteriori informazioni, consulta la sezione [Provider di identità supportati](https://docs.aws.amazon.com/singlesignon/latest/userguide/supported-idps.html) nella Guida AWS IAM Identity Center per l'utente.
Puoi configurarlo AWS Lake Formation come applicazione abilitata in IAM Identity Center e gli amministratori del data lake possono concedere autorizzazioni granulari a utenti e gruppi autorizzati sulle risorse. AWS Glue Data Catalog
Gli utenti della tua organizzazione possono accedere a qualsiasi applicazione abilitata per Identity Center utilizzando il provider di identità dell'organizzazione e interrogare i set di dati utilizzando le autorizzazioni Lake Formation. Con questa integrazione, puoi gestire l'accesso ai AWS servizi, senza creare più ruoli IAM.
[La propagazione affidabile delle identità](https://docs.aws.amazon.com//singlesignon/latest/userguide/trustedidentitypropagation-overview.html) è una AWS IAM Identity Center funzionalità che gli amministratori di connected Servizi AWS possono utilizzare per concedere e controllare l'accesso ai dati del servizio. L’accesso a questi dati si basa su attributi utente come le associazioni di gruppo. La configurazione di una propagazione affidabile delle identità richiede la collaborazione tra gli amministratori di connected Servizi AWS e gli amministratori di IAM Identity Center. Per ulteriori informazioni, consulta [Prerequisites and considerations](https://docs.aws.amazon.com//singlesignon/latest/userguide/trustedidentitypropagation-overall-prerequisites.html).
Per le limitazioni, consulta [Limitazioni dell'integrazione di IAM Identity Center](identity-center-lf-notes.md).
**Topics**
+ [Prerequisiti per l'integrazione di IAM Identity Center con Lake Formation](prerequisites-identity-center.md)
+ [Connessione di Lake Formation con IAM Identity Center](connect-lf-identity-center.md)
+ [Aggiornamento dell'integrazione con IAM Identity Center](update-lf-identity-center-connection.md)
+ [Eliminazione di una connessione Lake Formation con IAM Identity Center](delete-lf-identity-center-connection.md)
+ [Concessione di autorizzazioni a utenti e gruppi](grant-permissions-sso.md)
+ [Inclusione del contesto utente di IAM Identity Center nei log CloudTrail](identity-center-ct-logs.md)
# Prerequisiti per l'integrazione di IAM Identity Center con Lake Formation
Di seguito sono riportati i prerequisiti per l'integrazione di IAM Identity Center con Lake Formation.
1. Abilita IAM Identity Center: abilitare IAM Identity Center è un prerequisito per supportare l'autenticazione e la propagazione delle identità.
1. Scegli la tua fonte di identità: dopo aver abilitato IAM Identity Center, devi disporre di un provider di identità per gestire utenti e gruppi. È possibile utilizzare la directory Identity Center integrata come origine di identità o utilizzare un IdP esterno, ad esempio Microsoft Entra ID o Okta.
Per ulteriori informazioni, consulta [Manage your identity source](https://docs.aws.amazon.com/singlesignon/latest/userguide/manage-your-identity-source.html) e [Connect to a un provider di identità esterno](https://docs.aws.amazon.com/singlesignon/latest/userguide/manage-your-identity-source-idp.html) nella Guida per l' AWS IAM Identity Center utente.
1. Crea un ruolo IAM: il ruolo che crea la connessione IAM Identity Center richiede le autorizzazioni per creare e modificare la configurazione dell'applicazione in Lake Formation e IAM Identity Center come nella seguente politica in linea.
È necessario aggiungere le autorizzazioni in base alle migliori pratiche IAM. Le autorizzazioni specifiche sono illustrate nelle procedure che seguono. Per ulteriori informazioni, consulta [Guida introduttiva a IAM Identity Center](https://docs.aws.amazon.com/singlesignon/latest/userguide/get-started-enable-identity-center.html).
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"lakeformation:CreateLakeFormationIdentityCenterConfiguration",
"sso:CreateApplication",
"sso:PutApplicationAssignmentConfiguration",
"sso:PutApplicationAuthenticationMethod",
"sso:PutApplicationGrant",
"sso:PutApplicationAccessScope"
],
"Resource": [
"*"
]
}
]
}
```
------
Se condividi risorse di Data Catalog con organizzazioni esterne Account AWS o esterne, devi disporre delle autorizzazioni AWS Resource Access Manager (AWS RAM) per creare condivisioni di risorse. Per ulteriori informazioni sulle autorizzazioni necessarie per condividere risorse, consulta Prerequisiti per la condivisione [dei dati tra account](cross-account-prereqs.md).
Le seguenti politiche in linea contengono autorizzazioni specifiche necessarie per visualizzare, aggiornare ed eliminare le proprietà dell'integrazione di Lake Formation con IAM Identity Center.
+ Utilizza la seguente policy in linea per consentire a un ruolo IAM di visualizzare un'integrazione di Lake Formation con IAM Identity Center.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"lakeformation:DescribeLakeFormationIdentityCenterConfiguration",
"sso:DescribeApplication"
],
"Resource": [
"*"
]
}
]
}
```
------
+ Utilizza la seguente policy in linea per consentire a un ruolo IAM di aggiornare un'integrazione di Lake Formation con IAM Identity Center. La policy include anche le autorizzazioni opzionali necessarie per condividere risorse con account esterni.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"lakeformation:UpdateLakeFormationIdentityCenterConfiguration",
"lakeformation:DescribeLakeFormationIdentityCenterConfiguration",
"sso:DescribeApplication",
"sso:UpdateApplication"
],
"Resource": [
"*"
]
}
]
}
```
------
+ Utilizza la seguente policy in linea per consentire a un ruolo IAM di eliminare un'integrazione di Lake Formation con IAM Identity Center.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"lakeformation:DeleteLakeFormationIdentityCenterConfiguration",
"sso:DeleteApplication"
],
"Resource": [
"*"
]
}
]
}
```
------
+ Per le autorizzazioni IAM necessarie per concedere o revocare le autorizzazioni del data lake per utenti e gruppi IAM Identity Center, consulta. [Autorizzazioni IAM necessarie per concedere o revocare le autorizzazioni di Lake Formation](required-permissions-for-grant.md)
*Descrizione delle autorizzazioni*
+ `lakeformation:CreateLakeFormationIdentityCenterConfiguration`— Crea la configurazione iDC di Lake Formation.
+ `lakeformation:DescribeLakeFormationIdentityCenterConfiguration`— Descrive una configurazione iDC esistente.
+ `lakeformation:DeleteLakeFormationIdentityCenterConfiguration`— Offre la possibilità di eliminare una configurazione iDC di Lake Formation esistente.
+ `lakeformation:UpdateLakeFormationIdentityCenterConfiguration`— Usato per modificare una configurazione esistente di Lake Formation.
+ `sso:CreateApplication`: utilizzato per creare un'applicazione Centro identità IAM.
+ `sso:DeleteApplication`: utilizzato per eliminare un'applicazione Centro identità IAM.
+ `sso:UpdateApplication`: utilizzato per aggiornare un'applicazione Centro identità IAM.
+ `sso:PutApplicationGrant`: utilizzato per modificare le informazioni sull'emittente di token attendibile.
+ `sso:PutApplicationAuthenticationMethod`— Garantisce l'accesso all'autenticazione di Lake Formation.
+ `sso:GetApplicationGrant`: utilizzato per elencare informazioni sull'emittente di token attendibile.
+ `sso:DeleteApplicationGrant`: elimina le informazioni sull'emittente di token attendibile.
+ `sso:PutApplicationAccessScope`— Aggiunge o aggiorna l'elenco degli obiettivi autorizzati per un ambito di accesso di IAM Identity Center per un'applicazione.
+ `sso:PutApplicationAssignmentConfiguration`— Utilizzato per configurare il modo in cui gli utenti accedono a un'applicazione.
# Connessione di Lake Formation con IAM Identity Center
Prima di poter utilizzare IAM Identity Center per gestire le identità e concedere l'accesso alle risorse del Data Catalog utilizzando Lake Formation, devi completare i seguenti passaggi. Puoi creare l'integrazione con IAM Identity Center utilizzando la console Lake Formation oppure AWS CLI.
------
#### [ Console di gestione AWS ]
**Per connettere Lake Formation con IAM Identity Center**
1. Accedi a Console di gestione AWS, e apri la console Lake Formation all'indirizzo [https://console.aws.amazon.com/lakeformation/](https://console.aws.amazon.com/lakeformation/).
1. Nel riquadro di navigazione a sinistra, seleziona **IAM Identity Center integration**.
![\[Schermata di integrazione di IAM Identity Center con Identity Center ARN.\]](http://docs.aws.amazon.com/it_it/lake-formation/latest/dg/images/identity-center-integ.png)
1. (Facoltativo) Inserisci una o più organizzazioni IDs o unità and/or organizzative valide Account AWS IDs IDs per consentire agli account esterni di accedere alle risorse del Data Catalog. Quando gli utenti o i gruppi di IAM Identity Center cercano di accedere alle risorse del Data Catalog gestite da Lake Formation, Lake Formation assume un ruolo IAM per autorizzare l'accesso ai metadati. Se il ruolo IAM appartiene a un account esterno che non dispone di una policy di AWS Glue risorse e di una condivisione di AWS RAM risorse, gli utenti e i gruppi di IAM Identity Center non saranno in grado di accedere alla risorsa anche se dispongono delle autorizzazioni Lake Formation.
Lake Formation utilizza il servizio AWS Resource Access Manager (AWS RAM) per condividere la risorsa con account e organizzazioni esterni. AWS RAM invia un invito all'account del beneficiario per accettare o rifiutare la condivisione delle risorse.
Per ulteriori informazioni, consulta [Accettazione di un invito alla condivisione di risorse da AWS RAM](accepting-ram-invite.md).
**Nota**
Lake Formation consente ai ruoli IAM di account esterni di agire come portatori per conto degli utenti e dei gruppi di IAM Identity Center per l'accesso alle risorse del Data Catalog, ma le autorizzazioni possono essere concesse solo sulle risorse del Data Catalog all'interno dell'account proprietario. Se provi a concedere le autorizzazioni agli utenti e ai gruppi di IAM Identity Center sulle risorse di Data Catalog in un account esterno, Lake Formation genera il seguente errore: «Le sovvenzioni tra account non sono supportate per il principale».
1. (Facoltativo) Nella schermata di **integrazione Create Lake Formation**, specifica le applicazioni ARNs di terze parti che possono accedere ai dati nelle località Amazon S3 registrate con Lake Formation. Lake Formation fornisce credenziali temporanee limitate sotto forma di token alle sedi Amazon S3 registrate in base AWS STS alle autorizzazioni effettive, in modo che le applicazioni autorizzate possano accedere ai dati per conto degli utenti.
1. (Facoltativo) Nella schermata di **integrazione Create Lake Formation**, seleziona la casella di controllo Amazon Redshift Connect in Trusted Identity Propagation per abilitare la scoperta di Amazon Redshift Federated Permissions tramite IDC. Lake Formation propaga l'identità a valle sulla base delle autorizzazioni effettive, in modo che le applicazioni autorizzate possano accedere ai dati per conto degli utenti.
1. Selezionare **Invia**.
Dopo che l'amministratore di Lake Formation ha completato i passaggi e creato l'integrazione, le proprietà di IAM Identity Center vengono visualizzate nella console di Lake Formation. Il completamento di queste attività rende Lake Formation un'applicazione abilitata per IAM Identity Center. Le proprietà della console includono lo stato dell'integrazione. Lo stato dell'integrazione indica `Success` quando è completata. Questo stato indica se la configurazione di IAM Identity Center è stata completata.
------
#### [ AWS CLI ]
+ L'esempio seguente mostra come creare l'integrazione di Lake Formation con IAM Identity Center. Puoi anche specificare il `Status` (`ENABLED`,`DISABLED`) delle applicazioni.
```
aws lakeformation create-lake-formation-identity-center-configuration \
--catalog-id <123456789012> \
--instance-arn \
--share-recipients '[{"DataLakePrincipalIdentifier": "<123456789012>"},
{"DataLakePrincipalIdentifier": "<555555555555>"}]' \
--external-filtering '{"AuthorizedTargets": ["", ""], "Status": "ENABLED"}'
```
+ L'esempio seguente mostra come visualizzare un'integrazione di Lake Formation con IAM Identity Center.
```
aws lakeformation describe-lake-formation-identity-center-configuration
--catalog-id <123456789012>
```
+ L'esempio seguente mostra come abilitare `Redshift:Connect` l'autorizzazione. L'autorizzazione può essere ABILITATA o DISABILITATA.
```
aws lakeformation create-lake-formation-identity-center-configuration \
--instance-arn \
--service-integrations '[{
"Redshift": [{
"RedshiftConnect": {
"Authorization": "ENABLED"
}
}]
}]'
```
+ Usa il `describe-lake-formation-identity-center-configuration` comando per descrivere l'applicazione Lake Formation Identity Center. `Redshift:Connect`l'integrazione dei servizi è essenziale per la propagazione delle identità IDC tra servizi e cluster:
```
aws lakeformation describe-lake-formation-identity-center-configuration --catalog-id <123456789012>
```
Risposta:
```
{
"CatalogId": "CATALOG ID",
"InstanceArn": "INSTANCE ARN",
"ApplicationArn": "APPLICATION ARN",
"ShareRecipients": [],
"ServiceIntegrations": [
{
"Redshift": [
{
"RedshiftConnect": {
"Authorization": "ENABLED"
}
}
]
}
]
}
```
------
## Utilizzo di IAM Identity Center su più piattaforme Regioni AWS
Lake Formation supporta IAM Identity Center in più versioni Regioni AWS. Puoi estendere IAM Identity Center dalla tua regione principale Regione AWS ad altre regioni per migliorare le prestazioni grazie alla vicinanza agli utenti e all'affidabilità. Quando viene aggiunta una nuova regione in IAM Identity Center, puoi creare applicazioni Lake Formation Identity Center nella nuova regione senza replicare le identità dalla regione principale. Per maggiori dettagli su come iniziare a utilizzare IAM Identity Center in più regioni, consulta [IAM Identity Center multiregionale nella Guida](https://docs.aws.amazon.com/singlesignon/latest/userguide/multi-region-iam-identity-center.html) per l'utente di *IAM Identity Center*.
# Aggiornamento dell'integrazione con IAM Identity Center
Dopo aver creato la connessione, puoi aggiungere applicazioni di terze parti per l'integrazione di IAM Identity Center da integrare con Lake Formation e ottenere l'accesso ai dati di Amazon S3 per conto degli utenti. Puoi anche rimuovere le applicazioni esistenti dall'integrazione con IAM Identity Center. È possibile aggiungere o rimuovere applicazioni utilizzando la console Lake Formation e utilizzando [UpdateLakeFormationIdentityCenterConfiguration](https://docs.aws.amazon.com/lake-formation/latest/APIReference/API_UpdateLakeFormationIdentityCenterConfiguration.html)operation. AWS CLI
**Nota**
Dopo aver creato l'integrazione con IAM Identity Center, non puoi aggiornare l'istanza`ARN`.
------
#### [ Console di gestione AWS ]
**Per aggiornare una connessione IAM Identity Center esistente con Lake Formation**
1. Accedi a Console di gestione AWS, e apri la console Lake Formation all'indirizzo [https://console.aws.amazon.com/lakeformation/](https://console.aws.amazon.com/lakeformation/).
1. Nel riquadro di navigazione a sinistra, seleziona **IAM Identity Center integration**.
1. Seleziona **Aggiungi** nella pagina di **integrazione di IAM Identity Center**.
1. Inserisci una o più organizzazioni IDs o unità and/or organizzative valide Account AWS IDs IDs per consentire agli account esterni di accedere alle risorse del Data Catalog.
1. Nella schermata **Aggiungi applicazioni**, inserisci l'applicazione IDs delle applicazioni di terze parti che desideri integrare con Lake Formation.
1. Selezionare **Aggiungi**.
1. (Facoltativo) Nella pagina di **integrazione di IAM Identity Center** puoi abilitare la propagazione dell'identità affidabile per Amazon Redshift, connetterla o disabilitarla. Lake Formation propaga l'identità a valle sulla base delle autorizzazioni effettive, in modo che le applicazioni autorizzate possano accedere ai dati per conto degli utenti.
------
#### [ AWS CLI ]
Puoi aggiungere o rimuovere applicazioni di terze parti per l'integrazione con IAM Identity Center eseguendo il comando seguente. AWS CLI Quando imposti lo stato del filtro esterno su`ENABLED`, consente a IAM Identity Center di fornire la gestione delle identità per le applicazioni di terze parti per accedere ai dati gestiti da Lake Formation. Puoi anche abilitare o disabilitare l'integrazione di IAM Identity Center impostando lo stato dell'applicazione.
```
aws lakeformation update-lake-formation-identity-center-configuration \
--external-filtering '{"AuthorizedTargets": ["", ""], "Status": "ENABLED"}'\
--share-recipients '[{"DataLakePrincipalIdentifier": "<444455556666>"}
{"DataLakePrincipalIdentifier": "<777788889999>"}]' \
--application-status ENABLED
```
Se disponi di un'applicazione LF IDC esistente, ma desideri aggiungere l'`Redshift:Connect`autorizzazione, puoi utilizzare quanto segue per aggiornare la tua applicazione IDC Lake Formation. L'autorizzazione può essere ABILITATA o DISABILITATA.
```
aws lakeformation update-lake-formation-identity-center-configuration \
--service-integrations '[{
"Redshift": [{
"RedshiftConnect": {
"Authorization": "ENABLED"
}
}]
}]'
```
------
# Eliminazione di una connessione Lake Formation con IAM Identity Center
Se desideri eliminare un'integrazione esistente di IAM Identity Center, puoi farlo utilizzando la console o l'[DeleteLakeFormationIdentityCenterConfiguration](https://docs.aws.amazon.com/lake-formation/latest/APIReference/API_DeleteLakeFormationIdentityCenterConfiguration.html)operazione Lake Formation. AWS CLI
------
#### [ Console di gestione AWS ]
**Per eliminare una connessione IAM Identity Center esistente con Lake Formation**
1. Accedi a Console di gestione AWS, e apri la console Lake Formation all'indirizzo [https://console.aws.amazon.com/lakeformation/](https://console.aws.amazon.com/lakeformation/).
1. Nel riquadro di navigazione a sinistra, seleziona **IAM Identity Center integration**.
1. Seleziona **Elimina** nella pagina di **integrazione di IAM Identity Center**.
1. Nella schermata di **conferma dell'integrazione**, conferma l'azione e seleziona **Elimina**.
------
#### [ AWS CLI ]
Puoi eliminare l'integrazione con IAM Identity Center eseguendo il AWS CLI comando seguente.
```
aws lakeformation delete-lake-formation-identity-center-configuration \
--catalog-id <123456789012>
```
------
# Concessione di autorizzazioni a utenti e gruppi
L'amministratore del data lake può concedere autorizzazioni agli utenti e ai gruppi di IAM Identity Center sulle risorse del Data Catalog (database, tabelle e viste) per consentire un facile accesso ai dati. Per concedere o revocare le autorizzazioni del data lake, il concedente richiede le autorizzazioni per le seguenti azioni di IAM Identity Center.
+ [DescribeUser](https://docs.aws.amazon.com/singlesignon/latest/IdentityStoreAPIReference/API_DescribeUser.html)
+ [DescribeGroup](https://docs.aws.amazon.com/singlesignon/latest/IdentityStoreAPIReference/API_DescribeGroup.html)
+ [DescribeInstance](https://docs.aws.amazon.com/singlesignon/latest/APIReference/API_DescribeInstance.html)
Puoi concedere le autorizzazioni utilizzando la console Lake Formation, l'API o il AWS CLI.
Per ulteriori informazioni sulla concessione delle autorizzazioni, consulta. [Concessione delle autorizzazioni per le risorse del Data Catalog](granting-catalog-permissions.md)
**Nota**
Puoi concedere autorizzazioni solo sulle risorse del tuo account. Per assegnare a catena le autorizzazioni a utenti e gruppi sulle risorse condivise con te, devi utilizzare AWS RAM le condivisioni di risorse.
------
#### [ Console di gestione AWS ]
**Per concedere autorizzazioni a utenti e gruppi**
1. Accedi a Console di gestione AWS, e apri la console Lake Formation all'indirizzo [https://console.aws.amazon.com/lakeformation/](https://console.aws.amazon.com/lakeformation/).
1. Seleziona **le autorizzazioni del data lake** in **Autorizzazioni** nella console Lake Formation.
1. **Seleziona Concedi.**
1. Nella pagina **Concedi le autorizzazioni del data lake**, scegli utenti e gruppi di **IAM Identity Center**.
1. Seleziona **Aggiungi** per scegliere gli utenti e i gruppi a cui concedere le autorizzazioni.
![\[Concedi la schermata delle autorizzazioni del data lake con gli utenti e i gruppi di IAM Identity Center selezionati.\]](http://docs.aws.amazon.com/it_it/lake-formation/latest/dg/images/identity-center-grant-perm.png)
1. Nella schermata **Assegna utenti e gruppi, scegli i gruppi** di utenti and/or a cui concedere le autorizzazioni.
**Seleziona Assegna.**
![\[Concedi la schermata delle autorizzazioni del data lake con utenti e gruppi di IAM Identity Center selezionati.\]](http://docs.aws.amazon.com/it_it/lake-formation/latest/dg/images/identity-center-assign-users-groups.png)
1. Quindi, scegli il metodo per concedere le autorizzazioni.
Per istruzioni sulla concessione delle autorizzazioni utilizzando il metodo delle risorse denominate, vedere. [Concessione delle autorizzazioni per i dati utilizzando il metodo di risorsa denominato](granting-cat-perms-named-resource.md)
Per istruzioni sulla concessione di autorizzazioni utilizzando i tag LF, vedere. [Concessione delle autorizzazioni per il data lake utilizzando il metodo LF-TBAC](granting-catalog-perms-TBAC.md)
1. Scegliete le risorse del Data Catalog per le quali desiderate concedere le autorizzazioni.
1. Scegli le autorizzazioni del Data Catalog da concedere.
1. Seleziona **Concedi**.
------
#### [ AWS CLI ]
L'esempio seguente mostra come concedere l'`SELECT`autorizzazione utente di IAM Identity Center su una tabella.
```
aws lakeformation grant-permissions \
--principal DataLakePrincipalIdentifier=arn:aws:identitystore:::user/ \
--permissions "SELECT" \
--resource '{ "Table": { "DatabaseName": "retail", "TableWildcard": {} } }'
```
Per eseguire il recupero `UserId` da IAM Identity Center, consulta il [GetUserId](https://docs.aws.amazon.com/singlesignon/latest/IdentityStoreAPIReference/API_GetUserId.html)funzionamento nel riferimento all'API IAM Identity Center.
------
# Inclusione del contesto utente di IAM Identity Center nei log CloudTrail
Lake Formation utilizza la funzionalità di [vendita di credenziali](using-cred-vending.md) per fornire un accesso temporaneo ai dati di Amazon S3. Per impostazione predefinita, quando un utente di IAM Identity Center invia una query a un servizio di analisi integrato, CloudTrail i log includono solo il ruolo IAM assunto dal servizio per fornire un accesso a breve termine. Se utilizzi un ruolo definito dall'utente per registrare la posizione dei dati di Amazon S3 con Lake Formation, puoi scegliere di includere il contesto dell'utente di IAM Identity Center negli eventi e quindi tracciare CloudTrail gli utenti che accedono alle tue risorse.
**Importante**
Per includere le richieste API Amazon S3 a livello di oggetto in, devi CloudTrail abilitare CloudTrail la registrazione degli eventi per i bucket e gli oggetti Amazon S3. Per ulteriori informazioni, consulta [Enabling CloudTrail event logging for Amazon S3 bucket and objects nella Amazon S3 User Guide](https://docs.aws.amazon.com/AmazonS3/latest/userguide/enable-cloudtrail-logging-for-s3.html).
**Per abilitare il controllo della distribuzione delle credenziali nelle sedi di data lake registrate con ruoli definiti dall'utente**
1. Accedi alla console Lake Formation all'indirizzo [https://console.aws.amazon.com/lakeformation/](https://console.aws.amazon.com/lakeformation/).
1. Nella barra di navigazione a sinistra, espandi **Amministrazione** e scegli le impostazioni del **catalogo dati**.
1. In **Controllo avanzato**, scegli **Propagate** il contesto fornito.
1. Scegli **Save** (Salva).
È inoltre possibile abilitare l'opzione di controllo avanzato impostando l'`Parameters`attributo nell'operazione. [PutDataLakeSettings](https://docs.aws.amazon.com/lake-formation/latest/APIReference/API_PutDataLakeSettings.html) Per impostazione predefinita, il valore del `SET_CONTEXT"` parametro è impostato su «true».
```
{
"DataLakeSettings": {
"Parameters": {"SET_CONTEXT": "true"},
}
}
```
Di seguito è riportato un estratto di un CloudTrail evento con l'opzione di controllo avanzata. Questo log include sia il contesto della sessione dell'utente IAM Identity Center sia il ruolo IAM definito dall'utente assunto da Lake Formation per accedere alla posizione dati di Amazon S3. Vedi il `onBehalfOf` parametro nel seguente estratto.
```
{
"eventVersion":"1.09",
"userIdentity":{
"type":"AssumedRole",
"principalId":"AROAW7F7MOX4OYE6FLIFN:access-grants-e653760c-4e8b-44fd-94d9-309e035b75ab",
"arn":"arn:aws:sts::123456789012:assumed-role/accessGrantsTestRole/access-grants-e653760c-4e8b-44fd-94d9-309e035b75ab",
"accountId":"123456789012",
"accessKeyId":"ASIAW7F7MOX4CQLD4JIZN",
"sessionContext":{
"sessionIssuer":{
"type":"Role",
"principalId":"AROAW7F7MOX4OYE6FLIFN",
"arn":"arn:aws:iam::123456789012:role/accessGrantsTestRole",
"accountId":"123456789012",
"userName":"accessGrantsTestRole"
},
"attributes":{
"creationDate":"2023-08-09T17:24:02Z",
"mfaAuthenticated":"false"
}
},
"onBehalfOf":{
"userId": "",
"identityStoreArn": "arn:aws:identitystore::"
}
},
"eventTime":"2023-08-09T17:25:43Z",
"eventSource":"s3.amazonaws.com",
"eventName":"GetObject",
....
```
# Aggiungere una posizione Amazon S3 al tuo data lake
Per aggiungere una posizione dati come spazio di archiviazione nel tuo data lake, *registri* la posizione (**Data lake location**) con AWS Lake Formation. Puoi quindi utilizzare le autorizzazioni di Lake Formation per un controllo granulare degli accessi agli AWS Glue Data Catalog oggetti che puntano a questa posizione e ai dati sottostanti nella posizione.
Lake Formation consente inoltre di registrare una posizione dei dati in modalità di accesso ibrida e offre la flessibilità necessaria per abilitare selettivamente le autorizzazioni di Lake Formation per database e tabelle nel Data Catalog. Con la modalità di accesso Hybrid, hai a disposizione un percorso incrementale che ti consente di impostare le autorizzazioni di Lake Formation per un set specifico di utenti senza interrompere le politiche di autorizzazione di altri utenti o carichi di lavoro esistenti.
Per ulteriori informazioni sulla configurazione della modalità di accesso ibrida, vedere [Modalità di accesso ibrida](hybrid-access-mode.md)
Quando registri una posizione, vengono registrati quel percorso Amazon S3 e tutte le cartelle in quel percorso.
Ad esempio, supponiamo di avere un'organizzazione dei percorsi Amazon S3 come la seguente:
`/mybucket/accounting/sales/`
Se ti registri`S3://mybucket/accounting`, anche la `sales` cartella è registrata e sotto la gestione di Lake Formation.
Per ulteriori informazioni sulla registrazione delle sedi, vedere[Underlying data access control](access-control-underlying-data.md#underlying-data-access-control).
**Nota**
Le autorizzazioni Lake Formation sono consigliate per i dati strutturati (disposti in tabelle con righe e colonne). Se i tuoi dati contengono dati non strutturati basati su oggetti, prendi in considerazione l'utilizzo delle concessioni di accesso di Amazon S3 per gestire l'accesso ai dati.
**Topics**
+ [Requisiti per i ruoli utilizzati per registrare le sedi](registration-role.md)
+ [Registrazione di una sede Amazon S3](register-location.md)
+ [Registrazione di una posizione Amazon S3 crittografata](register-encrypted.md)
+ [Registrazione di una sede Amazon S3 in un altro account AWS](register-cross-account.md)
+ [Registrazione di una posizione Amazon S3 crittografata tra più account AWS](register-cross-encrypted.md)
+ [Annullamento della registrazione di una sede Amazon S3](unregister-location.md)
# Requisiti per i ruoli utilizzati per registrare le sedi
È necessario specificare un ruolo AWS Identity and Access Management (IAM) quando si registra una sede Amazon Simple Storage Service (Amazon S3). AWS Lake Formation assume quel ruolo quando accede ai dati in quella posizione.
È possibile utilizzare uno dei seguenti tipi di ruolo per registrare una posizione:
+ Il ruolo legato ai servizi di Lake Formation. Questo ruolo concede le autorizzazioni necessarie sulla sede. L'utilizzo di questo ruolo è il modo più semplice per registrare la posizione. Per ulteriori informazioni, consultare [Utilizzo di ruoli collegati ai servizi per Lake Formation](service-linked-roles.md) e [Limitazioni dei ruoli legati ai servizi](service-linked-role-limitations.md).
+ Un ruolo definito dall'utente. Utilizza un ruolo definito dall'utente quando devi concedere più autorizzazioni rispetto a quelle fornite dal ruolo collegato al servizio.
È necessario utilizzare un ruolo definito dall'utente nelle seguenti circostanze:
+ Quando si registra una sede in un altro account.
Per ulteriori informazioni, consultare [Registrazione di una sede Amazon S3 in un altro account AWS](register-cross-account.md) e [Registrazione di una posizione Amazon S3 crittografata tra più account AWS](register-cross-encrypted.md).
+ Se hai utilizzato una CMK (`aws/s3`) AWS gestita per crittografare la posizione Amazon S3.
Per ulteriori informazioni, consulta [Registrazione di una posizione Amazon S3 crittografata](register-encrypted.md).
+ Se prevedi di accedere alla posizione utilizzando Amazon EMR.
Se hai già registrato una sede con il ruolo collegato al servizio e desideri iniziare ad accedervi con Amazon EMR, devi annullare la registrazione della sede e registrarla nuovamente con un ruolo definito dall'utente. Per ulteriori informazioni, consulta [Annullamento della registrazione di una sede Amazon S3](unregister-location.md).
# Utilizzo di ruoli collegati ai servizi per Lake Formation
AWS Lake Formation *utilizza un ruolo collegato al AWS Identity and Access Management servizio (IAM).* Un ruolo collegato ai servizi è un tipo unico di ruolo IAM collegato direttamente a Lake Formation. Il ruolo collegato al servizio è predefinito da Lake Formation e include tutte le autorizzazioni richieste dal servizio per chiamare altri AWS servizi per tuo conto.
Un ruolo collegato al servizio semplifica la configurazione di Lake Formation perché non è necessario creare un ruolo e aggiungere manualmente le autorizzazioni necessarie. Lake Formation definisce le autorizzazioni del suo ruolo collegato ai servizi e, se non diversamente definito, solo Lake Formation può assumerne i ruoli. Le autorizzazioni definite includono la policy di attendibilità e la policy delle autorizzazioni che non può essere collegata a nessun'altra entità IAM.
Questo ruolo collegato al servizio si affida ai seguenti servizi per l'assunzione del ruolo:
+ `lakeformation.amazonaws.com`
Quando utilizzi un ruolo collegato al servizio nell'account A per registrare una sede Amazon S3 di proprietà dell'account B, la policy del bucket Amazon S3 (una politica basata sulle risorse) nell'account B deve concedere le autorizzazioni di accesso al ruolo collegato al servizio nell'account A.
Per informazioni sull'utilizzo del ruolo collegato al servizio per registrare una posizione di dati, consulta. [Limitazioni dei ruoli legati ai servizi](service-linked-role-limitations.md)
**Nota**
Le politiche di controllo del servizio (SCPs) non influiscono sui ruoli collegati ai servizi.
Per ulteriori informazioni, consulta [Service control policies (SCPs) nella guida](https://docs.aws.amazon.com/organizations/latest/userguide/orgs_manage_policies_scps.html) per l'*AWS Organizations utente*.
## Autorizzazioni di ruolo collegate al servizio per Lake Formation
Lake Formation utilizza il ruolo collegato al servizio denominato. `AWSServiceRoleForLakeFormationDataAccess` Questo ruolo fornisce una serie di autorizzazioni Amazon Simple Storage Service (Amazon S3) che consentono al servizio integrato Lake Formation (ad esempio) di accedere alle sedi Amazon Athena registrate. Quando registri una posizione di data lake, devi fornire un ruolo con le read/write autorizzazioni Amazon S3 richieste in quella posizione. Invece di creare un ruolo con le autorizzazioni richieste di Amazon S3, puoi utilizzare questo ruolo collegato al servizio.
La prima volta che nomini il ruolo collegato al servizio come ruolo con cui registrare un percorso, il ruolo collegato al servizio e una nuova policy IAM vengono creati per tuo conto. Lake Formation aggiunge il percorso alla politica in linea e la associa al ruolo collegato ai servizi. Quando registri percorsi successivi con il ruolo collegato al servizio, Lake Formation aggiunge il percorso alla policy esistente.
Dopo aver effettuato l'accesso come amministratore del data lake, registra una posizione di data lake. Quindi, nella console IAM, cerca il ruolo `AWSServiceRoleForLakeFormationDataAccess` e visualizza le policy allegate.
Ad esempio, dopo aver registrato la località`s3://my-kinesis-test/logs`, Lake Formation crea la seguente politica in linea e la allega a. `AWSServiceRoleForLakeFormationDataAccess`
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Sid": "LakeFormationDataAccessPermissionsForS3",
"Effect": "Allow",
"Action": [
"s3:PutObject",
"s3:GetObject",
"s3:DeleteObject",
"s3:AbortMultipartUpload",
"s3:ListMultipartUploadParts"
],
"Resource": [
"arn:aws:s3:::my-kinesis-test/logs/*"
]
},
{
"Sid": "LakeFormationDataAccessPermissionsForS3ListBucket",
"Effect": "Allow",
"Action": [
"s3:ListBucket",
"s3:ListBucketMultipartUploads"
],
"Resource": [
"arn:aws:s3:::my-kinesis-test"
]
}
]
}
```
------
## Creazione di un ruolo legato ai servizi per Lake Formation
Non hai bisogno di creare manualmente un ruolo collegato ai servizi. Quando registri una sede Amazon S3 con Lake Formation nell' AWS API Console di gestione AWS, Lake Formation crea automaticamente il ruolo collegato al servizio. AWS CLI
**Importante**
Questo ruolo collegato ai servizi può apparire nell'account se è stata completata un'operazione in un altro servizio che utilizza le funzionalità supportate dal ruolo. Per ulteriori informazioni, consulta [Un nuovo ruolo è apparso nel mio account IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/troubleshoot_roles.html#troubleshoot_roles_new-role-appeared).
Se elimini questo ruolo collegato al servizio, è possibile ricrearlo seguendo lo stesso processo utilizzato per ricreare il ruolo nell’account. Quando registri una sede Amazon S3 con Lake Formation, Lake Formation crea nuovamente il ruolo collegato al servizio per te.
Puoi anche utilizzare la console IAM per creare un ruolo collegato ai servizi con lo use case **Lake Formation**. Nella AWS CLI o nell' AWS API, crea un ruolo collegato al servizio con il nome del servizio. `lakeformation.amazonaws.com` Per ulteriori informazioni, consulta [Creazione di un ruolo collegato ai servizi](https://docs.aws.amazon.com/IAM/latest/UserGuide/using-service-linked-roles.html#create-service-linked-role) nella *Guida per l’utente IAM*. Se elimini il ruolo collegato ai servizi, è possibile utilizzare lo stesso processo per crearlo nuovamente.
## Modifica di un ruolo collegato ai servizi per Lake Formation
Lake Formation non consente di modificare il ruolo `AWSServiceRoleForLakeFormationDataAccess` collegato al servizio. Dopo avere creato un ruolo collegato al servizio, non sarà possibile modificarne il nome perché varie entità potrebbero farvi riferimento. È possibile tuttavia modificarne la descrizione utilizzando IAM. Per ulteriori informazioni, consulta la sezione [Modifica di un ruolo collegato ai servizi](https://docs.aws.amazon.com/IAM/latest/UserGuide/using-service-linked-roles.html#edit-service-linked-role) nella *Guida per l'utente di IAM*.
## Eliminazione di un ruolo collegato al servizio per Lake Formation
Se non è più necessario utilizzare una funzionalità o un servizio che richiede un ruolo collegato al servizio, ti consigliamo di eliminare il ruolo. In questo modo non sarà più presente un'entità non utilizzata che non viene monitorata e gestita attivamente. Tuttavia, è necessario effettuare la pulizia delle risorse associate al ruolo collegato al servizio prima di poterlo eliminare manualmente.
**Nota**
Se il servizio Lake Formation utilizza il ruolo quando si tenta di eliminare le risorse, l'eliminazione potrebbe non riuscire. In questo caso, attendi alcuni minuti e quindi ripeti l’operazione.
**Per eliminare le risorse di Lake Formation utilizzate da Lake Formation**
+ Se hai utilizzato il ruolo collegato al servizio per registrare le sedi Amazon S3 con Lake Formation, prima di eliminare il ruolo collegato al servizio, devi annullare la registrazione della posizione e registrarla nuovamente utilizzando un ruolo personalizzato.
**Per eliminare manualmente il ruolo collegato ai servizi mediante IAM**
Usa la console IAM, o l'API per eliminare il ruolo collegato al servizio. AWS CLI AWS `AWSServiceRoleForLakeFormationDataAccess` Per ulteriori informazioni, consulta [Eliminazione del ruolo collegato ai servizi](https://docs.aws.amazon.com/IAM/latest/UserGuide/using-service-linked-roles.html#delete-service-linked-role) nella *Guida per l'utente di IAM*.
Di seguito sono riportati i requisiti per un ruolo definito dall'utente:
+ Quando crei il nuovo ruolo, **nella pagina Crea ruolo** della console IAM, scegli **AWS service**, quindi in **Choose a use case** scegli **Lake Formation**.
Se crei il ruolo utilizzando un percorso diverso, assicurati che il ruolo abbia una relazione di fiducia con`lakeformation.amazonaws.com`. Per ulteriori informazioni, vedere [Modifica di una politica di attendibilità dei ruoli (Console).](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_update-role-trust-policy.html)
+ Il ruolo deve avere una politica in linea che conceda le autorizzazioni di Amazon read/write S3 sulla posizione. Di seguito è riportata una politica tipica.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"s3:PutObject",
"s3:GetObject",
"s3:DeleteObject"
],
"Resource": [
"arn:aws:s3:::awsexamplebucket/*"
]
},
{
"Effect": "Allow",
"Action": [
"s3:ListBucket"
],
"Resource": [
"arn:aws:s3:::awsexamplebucket"
]
}
]
}
```
------
+ Aggiungi la seguente policy di fiducia al ruolo IAM per consentire al servizio Lake Formation di assumere il ruolo e fornire credenziali temporanee ai motori analitici integrati.
Per includere il contesto utente di IAM Identity Center nei CloudTrail log, la policy di fiducia deve disporre dell'autorizzazione per l'azione. `sts:SetContext`
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Sid": "DataCatalogViewDefinerAssumeRole1",
"Effect": "Allow",
"Principal": {
"Service": [
"lakeformation.amazonaws.com"
]
},
"Action": [
"sts:AssumeRole",
"sts:SetContext"
]
}
]
}
```
------
+ L'amministratore del data lake che registra la posizione deve disporre dell'`iam:PassRole`autorizzazione per il ruolo.
Di seguito è riportata una politica in linea che concede questa autorizzazione. Sostituiscilo ** con un numero di AWS account valido e ** sostituiscilo con il nome del ruolo.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Sid": "PassRolePermissions",
"Effect": "Allow",
"Action": [
"iam:PassRole"
],
"Resource": [
"arn:aws:iam::111122223333:role/"
]
}
]
}
```
------
+ Per consentire a Lake Formation di aggiungere log in CloudWatch Logs e pubblicare metriche, aggiungi la seguente politica in linea.
**Nota**
La scrittura su CloudWatch Logs comporta un costo.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Sid": "Sid1",
"Effect": "Allow",
"Action": [
"logs:CreateLogStream",
"logs:CreateLogGroup",
"logs:PutLogEvents"
],
"Resource": [
"arn:aws:logs:us-east-1:111122223333:log-group:/aws-lakeformation-acceleration/*",
"arn:aws:logs:us-east-1:111122223333:log-group:/aws-lakeformation-acceleration/*:log-stream:*"
]
}
]
}
```
------
# Registrazione di una sede Amazon S3
È necessario specificare un ruolo AWS Identity and Access Management (IAM) quando si registra una sede Amazon Simple Storage Service (Amazon S3). Lake Formation assume questo ruolo quando concede credenziali temporanee ai AWS servizi integrati che accedono ai dati in quella posizione.
**Importante**
Evita di registrare un bucket Amazon S3 con Requester pay **abilitato**. Per i bucket registrati con Lake Formation, il ruolo utilizzato per registrare il bucket viene sempre visualizzato come richiedente. Se al bucket si accede da un altro AWS account, al proprietario del bucket viene addebitato l'accesso ai dati se il ruolo appartiene allo stesso account del proprietario del bucket.
Puoi utilizzare la AWS Lake Formation console, l'API Lake Formation o AWS Command Line Interface (AWS CLI) per registrare una sede Amazon S3.
**Prima di iniziare**
Rivedi i [requisiti per il ruolo utilizzato per registrare la sede](registration-role.md).
**Per registrare una posizione (console)**
**Importante**
Le seguenti procedure presuppongono che la posizione Amazon S3 si trovi nello stesso AWS account del Data Catalog e che i dati in essa contenuti non siano crittografati. Altre sezioni di questo capitolo riguardano la registrazione tra account e la registrazione di posizioni crittografate.
1. Apri la AWS Lake Formation console all'indirizzo [https://console.aws.amazon.com/lakeformation/](https://console.aws.amazon.com/lakeformation/). Accedi come amministratore del data lake o come utente con l'autorizzazione `lakeformation:RegisterResource` IAM.
1. Nel riquadro di navigazione, in **Amministrazione**, seleziona **Data lake locations**.
1. Scegli **Registra posizione**, quindi scegli **Sfoglia** per selezionare un percorso Amazon Simple Storage Service (Amazon S3).
1. (Facoltativo, ma fortemente consigliato) Seleziona **Rivedi le autorizzazioni della posizione** per visualizzare un elenco di tutte le risorse esistenti nella posizione Amazon S3 selezionata e le relative autorizzazioni.
La registrazione della località selezionata potrebbe consentire agli utenti di Lake Formation di accedere ai dati già presenti in quella posizione. La visualizzazione di questo elenco ti aiuta a garantire che i dati esistenti rimangano sicuri.
1. Per il **ruolo IAM**, scegli il ruolo `AWSServiceRoleForLakeFormationDataAccess` collegato al servizio (predefinito) o un ruolo IAM personalizzato che soddisfi i requisiti di. [Requisiti per i ruoli utilizzati per registrare le sedi](registration-role.md)
Puoi aggiornare una posizione registrata o altri dettagli solo quando la registri utilizzando un ruolo IAM personalizzato. Per modificare una sede registrata utilizzando un ruolo collegato al servizio, è necessario annullare la registrazione della posizione e registrarla nuovamente.
1. Scegli l'opzione **Enable Data Catalog Federation** per consentire a Lake Formation di assumere un ruolo e vendere credenziali temporanee ai AWS servizi integrati per accedere alle tabelle nei database federati. Se una posizione è registrata con Lake Formation e desideri utilizzare la stessa posizione per una tabella in un database federato, devi registrare la stessa posizione con l'opzione **Enable Data Catalog Federation**.
1. Scegli la **modalità di accesso ibrida** per non abilitare le autorizzazioni di Lake Formation per impostazione predefinita. Quando registri una posizione Amazon S3 in modalità di accesso ibrido, puoi abilitare le autorizzazioni Lake Formation optando per i principali database e tabelle in quella posizione.
Per ulteriori informazioni sulla configurazione della modalità di accesso ibrida, consulta. [Modalità di accesso ibrida](hybrid-access-mode.md)
1. Seleziona **Registra posizione**.
**Per registrare una sede (AWS CLI)**
1.
**Registra una nuova sede con Lake Formation**
Questo esempio utilizza un ruolo collegato al servizio per registrare la posizione. È possibile utilizzare l'`--role-arn`argomento invece per fornire il proprio ruolo.
Sostituiscilo ** con un percorso Amazon S3 valido, un numero di account con un AWS account valido e ** con un ruolo IAM che dispone delle autorizzazioni per registrare una posizione dati.
**Nota**
Non puoi modificare le proprietà di una posizione registrata se è registrata utilizzando un ruolo collegato al servizio.
```
aws lakeformation register-resource \
--resource-arn arn:aws:s3::: \
--use-service-linked-role
```
L'esempio seguente utilizza un ruolo personalizzato per registrare la posizione.
```
aws lakeformation register-resource \
--resource-arn arn:aws:s3::: \
--role-arn arn:aws:iam::<123456789012>:role/
```
1.
**Per aggiornare una località registrata con Lake Formation**
Puoi modificare una sede registrata solo se è registrata utilizzando un ruolo IAM personalizzato. Per una sede registrata con un ruolo collegato al servizio, è necessario annullare la registrazione della posizione e registrarla nuovamente. Per ulteriori informazioni, consulta [Annullamento della registrazione di una sede Amazon S3](unregister-location.md).
```
aws lakeformation update-resource \
--role-arn arn:aws:iam::<123456789012>:role/\
--resource-arn arn:aws:s3:::
```
```
aws lakeformation update-resource \
--resource-arn arn:aws:s3::: \
--use-service-linked-role
```
1.
**Registra una posizione dati in modalità di accesso ibrida con federazione**
```
aws lakeformation register-resource \
--resource-arn arn:aws:s3::: \
--role-arn arn:aws:iam::<123456789012>:role/ \
--hybrid-access-enabled
```
```
aws lakeformation register-resource \
--resource-arn arn:aws:s3::: \
--role-arn arn:aws:iam::<123456789012>:role/ \
--with-federation
```
```
aws lakeformation update-resource \
--resource-arn arn:aws:s3::: \
--role-arn arn:aws:iam::<123456789012>:role/ \
--hybrid-access-enabled
```
Per ulteriori informazioni, consulta Funzionamento [RegisterResource](https://docs.aws.amazon.com/lake-formation/latest/APIReference/API_RegisterResource.html)delle API.
**Nota**
Dopo aver registrato una posizione Amazon S3, qualsiasi AWS Glue tabella che punta alla posizione (o a una delle sue sedi secondarie) restituirà il valore del `IsRegisteredWithLakeFormation` parametro come `true` nella chiamata. `GetTable` È noto che le operazioni dell'API Data Catalog, come `GetTables` e `SearchTables` non, aggiornano il valore del `IsRegisteredWithLakeFormation` parametro e restituiscono il valore predefinito, che è falso. Si consiglia di utilizzare l'`GetTable`API per visualizzare il valore corretto del `IsRegisteredWithLakeFormation` parametro.
# Registrazione di una posizione Amazon S3 crittografata
Lake Formation si integra con [AWS Key Management Service](https://docs.aws.amazon.com/kms/latest/developerguide/overview.html)(AWS KMS) per consentirti di configurare più facilmente altri servizi integrati per crittografare e decrittografare i dati nelle sedi Amazon Simple Storage Service (Amazon S3).
Entrambi sono gestiti dal cliente e sono supportati. AWS KMS keys Chiavi gestite da AWS Attualmente, il lato client encryption/decryption è supportato solo con Athena.
È necessario specificare un ruolo AWS Identity and Access Management (IAM) quando si registra una sede Amazon S3. Per le sedi Amazon S3 crittografate, il ruolo deve disporre dell'autorizzazione per crittografare e decrittografare i dati con o la politica della AWS KMS key chiave KMS deve concedere le autorizzazioni sulla chiave del ruolo.
**Importante**
Evita di registrare un bucket Amazon S3 con Requester pay **abilitato**. Per i bucket registrati con Lake Formation, il ruolo utilizzato per registrare il bucket viene sempre visualizzato come richiedente. Se al bucket si accede da un altro AWS account, al proprietario del bucket viene addebitato l'accesso ai dati se il ruolo appartiene allo stesso account del proprietario del bucket.
Lake Formation utilizza un ruolo collegato al servizio per registrare le posizioni dei dati. [Tuttavia, questo ruolo presenta diverse limitazioni.](service-linked-role-limitations.md) A causa di questi vincoli, consigliamo invece di creare e utilizzare un ruolo IAM personalizzato per maggiore flessibilità e controllo. Il ruolo personalizzato creato per registrare la sede deve soddisfare i requisiti specificati in. [Requisiti per i ruoli utilizzati per registrare le sedi](registration-role.md)
**Importante**
Se hai utilizzato un Chiave gestita da AWS per crittografare la posizione Amazon S3, non puoi utilizzare il ruolo collegato al servizio Lake Formation. È necessario utilizzare un ruolo personalizzato e aggiungere le autorizzazioni IAM sulla chiave del ruolo. I dettagli sono forniti più avanti in questa sezione.
Le seguenti procedure spiegano come registrare una posizione Amazon S3 crittografata con una chiave gestita dal cliente o un. Chiave gestita da AWS
+ [Registrazione di una posizione crittografata con una chiave gestita dal cliente](#proc-register-cust-cmk)
+ [Registrazione di una posizione crittografata con un Chiave gestita da AWS](#proc-register-aws-cmk)
**Prima di iniziare**
Esamina i [requisiti per il ruolo utilizzato per registrare la sede](registration-role.md).
**Per registrare una posizione Amazon S3 crittografata con una chiave gestita dal cliente**
**Nota**
Se la chiave KMS o la posizione Amazon S3 non si trovano AWS nello stesso account del Data Catalog, segui invece le istruzioni riportate [Registrazione di una posizione Amazon S3 crittografata tra più account AWS](register-cross-encrypted.md) in.
1. Apri la AWS KMS console su [https://console.aws.amazon.com/kms](https://console.aws.amazon.com/kms) e accedi come utente amministrativo AWS Identity and Access Management (IAM) o come utente che può modificare la politica chiave della chiave KMS utilizzata per crittografare la posizione.
1. Nel pannello di navigazione, scegli **Customer managed keys**, quindi scegli il nome della chiave KMS desiderata.
1. Nella pagina dei dettagli della chiave KMS, scegli la scheda **Politica chiave**, quindi esegui una delle seguenti operazioni per aggiungere il tuo ruolo personalizzato o il ruolo collegato al servizio Lake Formation come utente chiave KMS:
+ **Se viene visualizzata la visualizzazione predefinita** (con le sezioni **Amministratori** **chiave, Eliminazione** **chiavi, Utenti chiave** e **Altri AWS account**), nella sezione **Utenti chiave**, aggiungi il tuo ruolo personalizzato o il ruolo collegato al servizio Lake Formation. `AWSServiceRoleForLakeFormationDataAccess`
+ **Se viene visualizzata la policy chiave (JSON)**, modifica la policy per aggiungere il ruolo personalizzato o il ruolo collegato `AWSServiceRoleForLakeFormationDataAccess` al servizio Lake Formation all'oggetto «Consenti l'uso della chiave», come mostrato nell'esempio seguente.
**Nota**
Se quell'oggetto manca, aggiungilo con le autorizzazioni mostrate nell'esempio. L'esempio utilizza il ruolo collegato al servizio.
```
...
{
"Sid": "Allow use of the key",
"Effect": "Allow",
"Principal": {
"AWS": [
"arn:aws:iam::111122223333:role/aws-service-role/lakeformation.amazonaws.com/AWSServiceRoleForLakeFormationDataAccess",
"arn:aws:iam::111122223333:user/keyuser"
]
},
"Action": [
"kms:Encrypt",
"kms:Decrypt",
"kms:ReEncrypt*",
"kms:GenerateDataKey*",
"kms:DescribeKey"
],
"Resource": "*"
},
...
```
1. Apri la AWS Lake Formation console all'indirizzo. [https://console.aws.amazon.com/lakeformation/](https://console.aws.amazon.com/lakeformation/) Accedi come amministratore del data lake o come utente con l'autorizzazione `lakeformation:RegisterResource` IAM.
1. Nel riquadro di navigazione, in **Amministrazione**, scegli **Data lake locations**.
1. Scegli **Registra posizione**, quindi scegli **Sfoglia** per selezionare un percorso Amazon Simple Storage Service (Amazon S3).
1. (Facoltativo, ma fortemente consigliato) Scegli **Rivedi le autorizzazioni della sede** per visualizzare un elenco di tutte le risorse esistenti nella posizione Amazon S3 selezionata e le relative autorizzazioni.
La registrazione della località selezionata potrebbe consentire agli utenti di Lake Formation di accedere ai dati già presenti in quella posizione. La visualizzazione di questo elenco ti aiuta a garantire che i dati esistenti rimangano sicuri.
1. Per **il ruolo IAM**, scegli il ruolo `AWSServiceRoleForLakeFormationDataAccess` collegato al servizio (predefinito) o il ruolo personalizzato che soddisfa i. [Requisiti per i ruoli utilizzati per registrare le sedi](registration-role.md)
1. Scegli **Registra posizione**.
Per ulteriori informazioni sul ruolo collegato al servizio, consulta [Autorizzazioni di ruolo collegate al servizio per Lake Formation](service-linked-roles.md#service-linked-role-permissions).
**Per registrare una posizione Amazon S3 crittografata con un Chiave gestita da AWS**
**Importante**
Se la sede Amazon S3 non si trova nello stesso AWS account del Data Catalog, segui invece le istruzioni riportate in[Registrazione di una posizione Amazon S3 crittografata tra più account AWS](register-cross-encrypted.md).
1. Crea un ruolo IAM da utilizzare per registrare la posizione. Assicurati che soddisfi i requisiti elencati in[Requisiti per i ruoli utilizzati per registrare le sedi](registration-role.md).
1. Aggiungi la seguente politica in linea al ruolo. Concede le autorizzazioni sulla chiave del ruolo. La `Resource` specifica deve indicare l'Amazon Resource Name (ARN) di. Chiave gestita da AWSÈ possibile ottenere l'ARN dalla AWS KMS console. Per ottenere l'ARN corretto, assicurati di accedere alla AWS KMS console con lo stesso AWS account e la stessa regione utilizzati per crittografare la Chiave gestita da AWS posizione.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"kms:Encrypt",
"kms:Decrypt",
"kms:ReEncrypt*",
"kms:GenerateDataKey*",
"kms:DescribeKey"
],
"Resource": "arn:aws:kms:us-east-1:111122223333:key/1234abcd-12ab-34cd-56ef-1234567890ab"
}
]
}
```
------
Puoi utilizzare gli alias delle chiavi KMS anziché l'ID della chiave - `arn:aws:kms:region:account-id:key/alias/your-key-alias`
Per ulteriori informazioni, consulta la sezione [Alias nella AWS KMS](https://docs.aws.amazon.com/kms/latest/developerguide/kms-alias.html) sezione della Guida per gli AWS Key Management Service sviluppatori.
1. Apri la AWS Lake Formation console all'indirizzo [https://console.aws.amazon.com/lakeformation/](https://console.aws.amazon.com/lakeformation/). Accedi come amministratore del data lake o come utente con l'autorizzazione `lakeformation:RegisterResource` IAM.
1. Nel riquadro di navigazione, in **Amministrazione**, scegli **Data lake locations**.
1. Scegli **Registra posizione**, quindi scegli **Sfoglia** per selezionare un percorso Amazon S3.
1. (Facoltativo, ma fortemente consigliato) Scegli **Rivedi le autorizzazioni della sede** per visualizzare un elenco di tutte le risorse esistenti nella posizione Amazon S3 selezionata e le relative autorizzazioni.
La registrazione della località selezionata potrebbe consentire agli utenti di Lake Formation di accedere ai dati già presenti in quella posizione. La visualizzazione di questo elenco ti aiuta a garantire che i dati esistenti rimangano sicuri.
1. Per il **ruolo IAM**, scegli il ruolo che hai creato nella fase 1.
1. Scegli la **posizione di registrazione**.
# Registrazione di una sede Amazon S3 in un altro account AWS
AWS Lake Formation consente di registrare sedi Amazon Simple Storage Service (Amazon S3) su più account. AWS Ad esempio, se si AWS Glue Data Catalog trova nell'account A, un utente nell'account A può registrare un bucket Amazon S3 nell'account B.
La registrazione di un bucket Amazon S3 AWS nell'account B utilizzando AWS Identity and Access Management un ruolo (IAM) AWS nell'account A richiede le seguenti autorizzazioni:
+ Il ruolo nell'account A deve concedere le autorizzazioni sul bucket dell'account B.
+ La politica del bucket nell'account B deve concedere le autorizzazioni di accesso al ruolo nell'account A.
**Importante**
Evita di registrare un bucket Amazon S3 con Requester pay **abilitato**. Per i bucket registrati con Lake Formation, il ruolo utilizzato per registrare il bucket viene sempre visualizzato come richiedente. Se al bucket si accede da un altro AWS account, al proprietario del bucket viene addebitato l'accesso ai dati se il ruolo appartiene allo stesso account del proprietario del bucket.
Non puoi utilizzare il ruolo collegato al servizio Lake Formation per registrare una sede in un altro account. È invece necessario utilizzare un ruolo definito dall'utente. Il ruolo deve soddisfare i requisiti di[Requisiti per i ruoli utilizzati per registrare le sedi](registration-role.md). Per ulteriori informazioni sul ruolo collegato al servizio, consulta [Autorizzazioni di ruolo collegate al servizio per Lake Formation](service-linked-roles.md#service-linked-role-permissions).
**Prima di iniziare**
Esamina i [requisiti per il ruolo utilizzato per registrare la sede](registration-role.md).
**Per registrare una sede in un altro AWS account**
**Nota**
Se la posizione è crittografata, segui [Registrazione di una posizione Amazon S3 crittografata tra più account AWS](register-cross-encrypted.md) invece le istruzioni riportate in.
La procedura seguente presuppone che un titolare dell'account 1111-2222-3333, che contiene il Data Catalog, desideri registrare il `awsexamplebucket1` bucket Amazon S3, che si trova nell'account 1234-5678-9012.
1. Nell'account 1111-2222-3333, accedi e apri la console IAM all'indirizzo. Console di gestione AWS [https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/)
1. Crea un nuovo ruolo o visualizza un ruolo esistente che soddisfa i requisiti in. [Requisiti per i ruoli utilizzati per registrare le sedi](registration-role.md) Assicurati che il ruolo conceda le autorizzazioni di Amazon S3. `awsexamplebucket1`
1. Apri la console Amazon S3 all'indirizzo. [https://console.aws.amazon.com/s3/](https://console.aws.amazon.com/s3/) Accedi con l'account 1234-5678-9012.
1. Nell'elenco dei nomi del **bucket, scegli il nome del bucket**,. `awsexamplebucket1`
1. Seleziona **Autorizzazioni**.
1. **Nella pagina **Autorizzazioni**, scegli Bucket Policy.**
1. Nell'**editor di policy Bucket**, incolla la seguente politica. Sostituisci ** con il nome del ruolo.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect":"Allow",
"Principal": {
"AWS":"arn:aws:iam::111122223333:role/"
},
"Action":"s3:ListBucket",
"Resource":"arn:aws:s3:::awsexamplebucket1"
},
{
"Effect":"Allow",
"Principal": {
"AWS":"arn:aws:iam::111122223333:role/"
},
"Action": [
"s3:DeleteObject",
"s3:GetObject",
"s3:PutObject"
],
"Resource":"arn:aws:s3:::awsexamplebucket1/*"
}
]
}
```
------
1. Scegli **Save** (Salva).
1. Apri la AWS Lake Formation console all'indirizzo [https://console.aws.amazon.com/lakeformation/](https://console.aws.amazon.com/lakeformation/). Accedi all'account 1111-2222-3333 come amministratore del data lake o come utente con autorizzazioni sufficienti per registrare le sedi.
1. **Nel riquadro di navigazione, in **Amministrazione, scegli Posizioni Data lake**.**
1. Nella pagina **delle sedi dei Data lake**, scegli **Registra posizione**.
1. Nella **pagina Registra posizione**, per il **percorso Amazon S3**, inserisci il nome del bucket. `s3://awsexamplebucket1`
**Nota**
**Devi digitare il nome del bucket perché i bucket tra account non vengono visualizzati nell'elenco quando scegli Sfoglia.**
1. Per il **ruolo IAM, scegli il tuo ruolo**.
1. Scegli **Registra la posizione**.
# Registrazione di una posizione Amazon S3 crittografata tra più account AWS
AWS Lake Formation si integra con [AWS Key Management Service](https://docs.aws.amazon.com/kms/latest/developerguide/overview.html)(AWS KMS) per consentirti di configurare più facilmente altri servizi integrati per crittografare e decrittografare i dati nelle sedi Amazon Simple Storage Service (Amazon S3) Simple Storage Service (Amazon S3).
Sono supportate entrambe le chiavi gestite dal cliente. Chiavi gestite da AWS Il lato client non encryption/decryption è supportato.
**Importante**
Evita di registrare un bucket Amazon S3 con Requester pay **abilitato**. Per i bucket registrati con Lake Formation, il ruolo utilizzato per registrare il bucket viene sempre visualizzato come richiedente. Se al bucket si accede da un altro AWS account, al proprietario del bucket viene addebitato l'accesso ai dati se il ruolo appartiene allo stesso account del proprietario del bucket.
Questa sezione spiega come registrare una sede Amazon S3 nelle seguenti circostanze:
+ I dati nella posizione Amazon S3 sono crittografati con una chiave KMS creata in. AWS KMS
+ La sede Amazon S3 non si trova nello stesso AWS account di. AWS Glue Data Catalog
+ La chiave KMS è o non si trova nello stesso AWS account del Data Catalog.
La registrazione di un bucket Amazon S3 AWS KMS crittografato AWS nell'account B utilizzando AWS Identity and Access Management un ruolo (IAM) AWS nell'account A richiede le seguenti autorizzazioni:
+ Il ruolo nell'account A deve concedere le autorizzazioni sul bucket dell'account B.
+ La politica del bucket nell'account B deve concedere le autorizzazioni di accesso al ruolo nell'account A.
+ Se la chiave KMS è nell'account B, la politica chiave deve concedere l'accesso al ruolo nell'account A e il ruolo nell'account A deve concedere le autorizzazioni sulla chiave KMS.
Nella procedura seguente, si crea un ruolo nell' AWS account che contiene il catalogo dati (l'account A nella discussione precedente). Quindi, si utilizza questo ruolo per registrare la posizione. Lake Formation assume questo ruolo quando accede ai dati sottostanti in Amazon S3. Il ruolo assunto dispone delle autorizzazioni richieste sulla chiave KMS. Di conseguenza, non è necessario concedere le autorizzazioni sulla chiave KMS ai responsabili che accedono ai dati sottostanti con lavori ETL o con servizi integrati come. Amazon Athena
**Importante**
Non puoi utilizzare il ruolo collegato al servizio Lake Formation per registrare una sede in un altro account. È invece necessario utilizzare un ruolo definito dall'utente. Il ruolo deve soddisfare i requisiti di[Requisiti per i ruoli utilizzati per registrare le sedi](registration-role.md). Per ulteriori informazioni sul ruolo collegato al servizio, consulta [Autorizzazioni di ruolo collegate al servizio per Lake Formation](service-linked-roles.md#service-linked-role-permissions).
**Prima di iniziare**
Esamina i [requisiti per il ruolo utilizzato per registrare la sede](registration-role.md).
**Per registrare una posizione Amazon S3 crittografata tra più account AWS**
1. Nello stesso AWS account del Data Catalog, accedi Console di gestione AWS e apri la console IAM all'indirizzo[https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/).
1. Crea un nuovo ruolo o visualizza un ruolo esistente che soddisfa i requisiti in[Requisiti per i ruoli utilizzati per registrare le sedi](registration-role.md). Assicurati che il ruolo includa una policy che conceda le autorizzazioni di Amazon S3 sulla location.
1. Se la chiave KMS non si trova nello stesso account del Data Catalog, aggiungi al ruolo una policy in linea che conceda le autorizzazioni richieste sulla chiave KMS. Di seguito è riportata una policy di esempio. Sostituisci la regione e l'ID dell'account con la regione e il numero di account della chiave KMS. Sostituisci ** con l'ID della chiave.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"kms:Encrypt",
"kms:Decrypt",
"kms:ReEncrypt*",
"kms:GenerateDataKey*",
"kms:DescribeKey"
],
"Resource": "arn:aws:kms:us-east-1:111122223333:key/"
}
]
}
```
------
1. Sulla console Amazon S3, aggiungi una bucket policy che conceda le autorizzazioni Amazon S3 richieste per il ruolo. Di seguito è riportato un esempio di policy di bucket. Sostituisci l'ID dell' AWS account con il numero di account del Data Catalog, ** con il nome del tuo ruolo e ** con il nome del bucket.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect":"Allow",
"Principal": {
"AWS":"arn:aws:iam::111122223333:role/"
},
"Action":"s3:ListBucket",
"Resource":"arn:aws:s3:::"
},
{
"Effect":"Allow",
"Principal": {
"AWS":"arn:aws:iam::111122223333:role/"
},
"Action": [
"s3:DeleteObject",
"s3:GetObject",
"s3:PutObject"
],
"Resource":"arn:aws:s3:::/*"
}
]
}
```
------
1. In AWS KMS, aggiungi il ruolo come utente della chiave KMS.
1. Apri la AWS KMS console in [https://console.aws.amazon.com/kms.](https://console.aws.amazon.com/kms) Quindi, accedi come utente amministratore o come utente che può modificare la politica chiave della chiave KMS utilizzata per crittografare la posizione.
1. Nel riquadro di navigazione, scegli **Customer managed keys**, quindi scegli il nome della chiave KMS.
1. Nella pagina dei dettagli della chiave KMS, nella scheda **Politica chiave**, se la visualizzazione JSON della politica chiave non viene visualizzata, scegli **Passa alla** visualizzazione delle politiche.
1. Nella sezione **Key policy**, scegli **Modifica** e aggiungi l'Amazon Resource Name (ARN) del ruolo all'`Allow use of the key`oggetto, come mostrato nell'esempio seguente.
**Nota**
Se quell'oggetto manca, aggiungilo con le autorizzazioni mostrate nell'esempio.
```
...
{
"Sid": "Allow use of the key",
"Effect": "Allow",
"Principal": {
"AWS": [
"arn:aws:iam:::role/"
]
},
"Action": [
"kms:Encrypt",
"kms:Decrypt",
"kms:ReEncrypt*",
"kms:GenerateDataKey*",
"kms:DescribeKey"
],
"Resource": "*"
},
...
```
Per ulteriori informazioni, consulta [Consentire agli utenti di altri account di utilizzare una chiave KMS nella Guida](https://docs.amazonaws.cn/en_us/kms/latest/developerguide/key-policy-modifying-external-accounts.html) per gli *AWS Key Management Service sviluppatori*.
1. Apri la AWS Lake Formation console all'indirizzo [https://console.aws.amazon.com/lakeformation/](https://console.aws.amazon.com/lakeformation/). Accedi all' AWS account Data Catalog come amministratore del data lake.
1. Nel riquadro di navigazione, in **Amministrazione**, scegli **Posizioni Data lake**.
1. Scegli **Registra posizione**.
1. Nella **pagina Registra posizione**, per il percorso **Amazon S3, inserisci il percorso** della posizione come. **s3://**/**** Sostituiscilo ** con il nome del bucket e ** con il resto del percorso della posizione.
**Nota**
**È necessario digitare il percorso perché i bucket tra account non vengono visualizzati nell'elenco quando si sceglie Sfoglia.**
1. Per il **ruolo IAM**, scegli il ruolo dalla Fase 2.
1. Scegli **Registra posizione**.
# Annullamento della registrazione di una sede Amazon S3
Puoi annullare la registrazione di una sede Amazon Simple Storage Service (Amazon S3) se non desideri più che venga gestita da Lake Formation. L'annullamento della registrazione di una sede non influisce sulle autorizzazioni di localizzazione dei dati di Lake Formation concesse in quella località. Puoi registrare nuovamente una sede che hai annullato e le autorizzazioni relative alla localizzazione dei dati rimangono valide. È possibile utilizzare un ruolo diverso per registrare nuovamente la posizione.
**Per annullare la registrazione di una posizione (console)**
1. Apri la AWS Lake Formation console all'indirizzo. [https://console.aws.amazon.com/lakeformation/](https://console.aws.amazon.com/lakeformation/) Accedi come amministratore del data lake o come utente con l'autorizzazione `lakeformation:RegisterResource` IAM.
1. Nel riquadro di navigazione, in **Amministrazione**, scegli **Data lake locations**.
1. Seleziona una posizione e nel menu **Azioni** scegli **Rimuovi**.
1. Quando viene richiesta la conferma, scegli **Rimuovi**.
# Modalità di accesso ibrida
AWS Lake Formation la *modalità di accesso ibrida* supporta due percorsi di autorizzazione per gli stessi oggetti. AWS Glue Data Catalog
Nel primo percorso, Lake Formation ti consente di selezionare principali specifici e concedere loro le autorizzazioni di Lake Formation per accedere a cataloghi, database, tabelle e visualizzazioni attivando il consenso. Il secondo percorso consente a tutti gli altri principali di accedere a queste risorse tramite le politiche e le azioni principali IAM predefinite per Amazon AWS Glue S3.
Quando registri una sede Amazon S3 con Lake Formation, hai la possibilità di applicare le autorizzazioni di Lake Formation per tutte le risorse in questa sede o utilizzare la modalità di accesso ibrida. Per impostazione predefinita, la modalità di accesso ibrida applica solo le `CREATE_TABLE` autorizzazioni. `CREATE_PARTITION` `UPDATE_TABLE` Quando una sede Amazon S3 è in modalità ibrida, puoi abilitare le autorizzazioni Lake Formation attivando i principali per gli oggetti Data Catalog in quella posizione. Significa che sia le autorizzazioni Lake Formation che le autorizzazioni IAM possono controllare l'accesso a quei dati. Ciò significa che i responsabili che hanno aderito richiederanno sia le autorizzazioni Lake Formation che le autorizzazioni IAM per accedere ai dati, mentre i non-opted-in principali continueranno ad accedere ai dati utilizzando solo le autorizzazioni IAM.
Pertanto, la modalità di accesso ibrido offre la flessibilità necessaria per abilitare selettivamente Lake Formation per cataloghi, database e tabelle nel tuo Data Catalog per un set specifico di utenti senza interrompere l'accesso per altri utenti o carichi di lavoro esistenti.
![\[Account AWS architecture showing data flow between S3, Glue, Lake Formation, Athena, and IAM roles.\]](http://docs.aws.amazon.com/it_it/lake-formation/latest/dg/images/hybrid-access-mode-concept.png)
Per considerazioni e limitazioni, vedere [Considerazioni e limitazioni della modalità di accesso ibrido](notes-hybrid.md).Termini e definizioni
Di seguito sono riportate le definizioni delle risorse di Data Catalog in base alla modalità di impostazione delle autorizzazioni di accesso:
Risorsa Lake Formation
Una risorsa registrata presso Lake Formation. Gli utenti richiedono le autorizzazioni di Lake Formation per accedere alla risorsa.
AWS Glue risorsa
Una risorsa che non è registrata presso Lake Formation. Gli utenti richiedono solo le autorizzazioni IAM per accedere alla risorsa perché dispone di autorizzazioni di `IAMAllowedPrincipals` gruppo. Le autorizzazioni di Lake Formation non vengono applicate.
Per ulteriori informazioni sulle autorizzazioni `IAMAllowedPrincipals` di gruppo, vedere. [Autorizzazioni per i metadati](metadata-permissions.md)
Risorsa ibrida
Una risorsa registrata in modalità di accesso ibrida. In base agli utenti che accedono alla risorsa, la risorsa passa dinamicamente dall'essere una risorsa Lake Formation a una AWS Glue risorsa.
## Casi d'uso comuni della modalità di accesso ibrido
È possibile utilizzare la modalità di accesso ibrido per fornire l'accesso in scenari di condivisione dei dati con account singolo e tra account:
**Scenari con account singolo**
+ **Convertire una AWS Glue risorsa in una risorsa ibrida**: in questo scenario, attualmente non stai utilizzando Lake Formation ma desideri adottare le autorizzazioni Lake Formation per gli oggetti Data Catalog. Quando registri la posizione Amazon S3 in modalità di accesso ibrido, puoi concedere le autorizzazioni di Lake Formation agli utenti che optano per database e tabelle specifici che puntano a quella posizione.
+ **Convertire una risorsa Lake Formation in una risorsa ibrida**: attualmente, utilizzi le autorizzazioni di Lake Formation per controllare l'accesso a un database Data Catalog, ma desideri fornire l'accesso a nuovi principali utilizzando le autorizzazioni IAM per Amazon S3 e AWS Glue senza interrompere le autorizzazioni Lake Formation esistenti.
Quando aggiorni la registrazione di una posizione dati alla modalità di accesso ibrida, i nuovi responsabili possono accedere al database Data Catalog puntando alla posizione Amazon S3 utilizzando le policy di autorizzazione IAM senza interrompere le autorizzazioni Lake Formation degli utenti esistenti.
Prima di aggiornare la registrazione della posizione dei dati per abilitare la modalità di accesso ibrida, devi prima attivare i principali che attualmente accedono alla risorsa con le autorizzazioni di Lake Formation.
Questo serve a prevenire potenziali interruzioni del flusso di lavoro corrente.
È inoltre necessario concedere al `IAMAllowedPrincipal` gruppo l'`Super`autorizzazione per le tabelle del database.
**Scenari di condivisione dei dati tra account**
+ **Condividi AWS Glue risorse utilizzando la modalità di accesso ibrido**: in questo scenario, l'account produttore dispone di tabelle in un database che sono attualmente condivise con un account consumer utilizzando le politiche di autorizzazione IAM per Amazon S3 AWS Glue e le azioni. La posizione dei dati del database non è registrata con Lake Formation.
Prima di registrare la posizione dei dati in modalità di accesso ibrido, è necessario aggiornare **le impostazioni della versione dell'account Cross** alla versione 4. La versione 4 fornisce le nuove politiche di AWS RAM autorizzazione necessarie per la condivisione tra account quando il `IAMAllowedPrincipal` gruppo dispone dell'`Super`autorizzazione sulla risorsa. Per le risorse con autorizzazioni di `IAMAllowedPrincipal` gruppo, puoi concedere le autorizzazioni di Lake Formation agli account esterni e consentire loro di utilizzare le autorizzazioni Lake Formation. L'amministratore del data lake nell'account del destinatario può concedere le autorizzazioni di Lake Formation ai responsabili dell'account e autorizzarli a far valere le autorizzazioni di Lake Formation.
+ **Condividi le risorse di Lake Formation utilizzando la modalità di accesso ibrida**: attualmente, l'account produttore contiene tabelle in un database che vengono condivise con un account consumatore che applica le autorizzazioni di Lake Formation. La posizione dei dati del database è registrata presso Lake Formation.
In questo caso, puoi aggiornare la registrazione della posizione Amazon S3 alla modalità di accesso ibrida e condividere i dati di Amazon S3 e i metadati di Data Catalog utilizzando le policy dei bucket di Amazon S3 e le politiche delle risorse del Catalogo dati con i principali dell'account consumatore. È necessario concedere nuovamente le autorizzazioni esistenti di Lake Formation e attivare i principali prima di aggiornare la registrazione delle sedi Amazon S3. Inoltre, devi concedere al gruppo `Super` l'autorizzazione per le tabelle del database. `IAMAllowedPrincipals`
**Topics**
+ [Casi d'uso comuni della modalità di accesso ibrido](#hybrid-access-mode-use-cases)
+ [Come funziona la modalità di accesso ibrida](hybrid-access-workflow.md)
+ [Configurazione della modalità di accesso ibrida: scenari comuni](hybrid-access-setup.md)
+ [Rimozione di principi e risorse dalla modalità di accesso ibrida](delete-hybrid-access.md)
+ [Visualizzazione dei principali e delle risorse in modalità di accesso ibrida](view-hybrid-access.md)
+ [Risorse aggiuntive](additional-resources-hybrid.md)
# Come funziona la modalità di accesso ibrida
Il diagramma seguente mostra come funziona l'autorizzazione di Lake Formation in modalità di accesso ibrido quando si interrogano le risorse del Data Catalog.
![\[AWS Lake Formation authorization process flowchart for hybrid access mode queries.\]](http://docs.aws.amazon.com/it_it/lake-formation/latest/dg/images/hybrid-workflow.png)
Prima di accedere ai dati nel data lake, un amministratore del data lake o un utente con autorizzazioni amministrative configura le politiche utente delle singole tabelle di Data Catalog per consentire o negare l'accesso alle tabelle del Data Catalog. Quindi, un principale che dispone delle autorizzazioni per eseguire l'`RegisterResource`operazione registra la posizione Amazon S3 della tabella con Lake Formation in modalità di accesso ibrido. Se una posizione dati non è registrata con Lake Formation, l'amministratore concede le autorizzazioni di Lake Formation a utenti specifici sui database e sulle tabelle del Data Catalog e li autorizza a utilizzare le autorizzazioni Lake Formation per tali database e tabelle in modalità di accesso ibrido.
1. **Invia una query**: un principale invia una query o uno script ETL utilizzando un servizio integrato come Amazon Athena, Amazon EMR o AWS Glue Amazon Redshift Spectrum.
1. **Richiede dati**: il motore analitico integrato identifica la tabella richiesta e invia la richiesta di metadati al Data Catalog (,). `GetTable` `GetDatabase`
1. **Verifica le autorizzazioni**: il Data Catalog verifica le autorizzazioni di accesso del responsabile dell'interrogazione con Lake Formation.
1. Se alla tabella non sono allegate autorizzazioni di `IAMAllowedPrincipals` gruppo, vengono applicate le autorizzazioni di Lake Formation.
1. Se il principale ha scelto di utilizzare le autorizzazioni di Lake Formation nella modalità di accesso ibrida e alla tabella sono allegate le autorizzazioni di `IAMAllowedPrincipals` gruppo, le autorizzazioni di Lake Formation vengono applicate. Il motore di query applica i filtri ricevuti da Lake Formation e restituisce i dati all'utente.
1. Se la posizione della tabella non è registrata con Lake Formation e il principale non ha scelto di utilizzare le autorizzazioni di Lake Formation in modalità di accesso ibrido, il Data Catalog verifica se alla tabella sono associate autorizzazioni di `IAMAllowedPrincipals` gruppo. Se questa autorizzazione esiste nella tabella, tutti i principali dell'account ottengono `Super` i `All` permessi sulla tabella.
La vendita di credenziali di Lake Formation non è disponibile, anche se è stato attivato, a meno che la posizione dei dati non sia registrata con Lake Formation.
1. **Ottieni credenziali**: il Data Catalog controlla e fa sapere al motore se la posizione della tabella è registrata o meno con Lake Formation. Se i dati sottostanti sono registrati con Lake Formation, il motore analitico richiede a Lake Formation le credenziali temporanee per accedere ai dati nel bucket Amazon S3.
1. **Ottieni dati**: se il responsabile è autorizzato ad accedere ai dati della tabella, Lake Formation fornisce l'accesso temporaneo al motore analitico integrato. Utilizzando l'accesso temporaneo, il motore analitico recupera i dati da Amazon S3 ed esegue i filtri necessari come il filtraggio di colonne, righe o celle. Quando il motore termina l'esecuzione del lavoro, restituisce i risultati all'utente. Questo processo è denominato distribuzione di credenziali. Per ulteriori informazioni, vedere[Integrazione di servizi di terze parti con Lake Formation](Integrating-with-LakeFormation.md).
1.
Se la posizione dei dati della tabella non è registrata con Lake Formation, la seconda chiamata dal motore di analisi viene effettuata direttamente ad Amazon S3. La policy del bucket Amazon S3 interessata e la politica utente IAM vengono valutate per l'accesso ai dati. Ogni volta che si utilizzano le policy IAM, assicurati di seguire le best practice IAM. Per ulteriori informazioni, consulta le [best practice di sicurezza in IAM nella IAM User Guide](https://docs.aws.amazon.com/IAM/latest/UserGuide/best-practices.html).
# Configurazione della modalità di accesso ibrida: scenari comuni
Come per le autorizzazioni di Lake Formation, in genere sono disponibili due tipi di scenari in cui è possibile utilizzare la modalità di accesso ibrida per gestire l'accesso ai dati: fornire l'accesso ai principali all'interno di uno Account AWS e fornire l'accesso a un principale Account AWS o esterno.
Questa sezione fornisce istruzioni per configurare la modalità di accesso ibrida nei seguenti scenari:
**Gestisci le autorizzazioni in modalità di accesso ibrida all'interno di un'unica soluzione Account AWS**
+ [Conversione di una AWS Glue risorsa in una risorsa ibrida](hybrid-access-mode-new.md)— Attualmente stai fornendo l'accesso alle tabelle in un database per tutti i principali del tuo account utilizzando le autorizzazioni IAM per Amazon S3 AWS Glue e desideri adottare Lake Formation per gestire le autorizzazioni in modo incrementale.
+ [Conversione di una risorsa di Lake Formation in una risorsa ibrida](hybrid-access-mode-update.md)— Attualmente stai utilizzando Lake Formation per gestire l'accesso alle tabelle in un database per tutti i principali del tuo account, ma desideri utilizzare Lake Formation solo per i principali specifici. Desideri fornire l'accesso a nuovi principali utilizzando le autorizzazioni IAM per Amazon S3 sullo stesso database AWS Glue e sulle stesse tabelle.
**Gestisci le autorizzazioni in modalità di accesso ibrida su s Account AWS**
+ [Condivisione di una AWS Glue risorsa utilizzando la modalità di accesso ibrida](hybrid-access-mode-cross-account.md)— Al momento non stai utilizzando Lake Formation per gestire le autorizzazioni per una tabella, ma desideri applicare le autorizzazioni di Lake Formation per fornire l'accesso ai principali in un altro account.
+ [Condivisione di una risorsa Lake Formation utilizzando la modalità di accesso ibrida](hybrid-access-mode-cross-account-IAM.md)— Stai utilizzando Lake Formation per gestire l'accesso a una tabella ma desideri fornire l'accesso ai principali in un altro account utilizzando le autorizzazioni IAM per Amazon S3 sullo stesso database AWS Glue e sulle stesse tabelle.
**Configurazione della modalità di accesso ibrida: passaggi di alto livello**
1. Registra la posizione dei dati di Amazon S3 con Lake Formation selezionando la modalità di **accesso ibrida**.
1. I responsabili devono avere `DATA_LOCATION` l'autorizzazione su una posizione di data lake per creare tabelle o database di Data Catalog che puntano a quella posizione.
1. Imposta l'**impostazione della versione per più account** sulla versione 4.
1. Concedi autorizzazioni dettagliate a utenti o ruoli IAM specifici su database e tabelle. Allo stesso tempo, assicurati di impostare `Super` o `All` autorizzare il `IAMAllowedPrincipals` gruppo sul database e tutte le tabelle del database o solo alcune di esse.
1. Scegli i principi e le risorse. Gli altri responsabili dell'account possono continuare ad accedere ai database e alle tabelle utilizzando le policy di autorizzazione IAM AWS Glue e le azioni di Amazon S3.
1. Opzionalmente, pulisci le politiche di autorizzazione IAM per Amazon S3 per i principali che hanno scelto di utilizzare le autorizzazioni Lake Formation.
# Prerequisiti per la configurazione della modalità di accesso ibrida
Di seguito sono riportati i prerequisiti per l'impostazione della modalità di accesso ibrida:
**Nota**
Consigliamo a un amministratore di Lake Formation di registrare la posizione Amazon S3 in modalità di accesso ibrida e di attivare i principali e le risorse.
1. Concedi l'autorizzazione all'ubicazione dei dati (`DATA_LOCATION_ACCESS`) per creare risorse Data Catalog che puntino alle sedi Amazon S3. Le autorizzazioni di localizzazione dei dati controllano la capacità di creare cataloghi, database e tabelle di Data Catalog che puntano a particolari posizioni Amazon S3.
1. Per condividere le risorse di Data Catalog con un altro account in modalità di accesso ibrida (senza rimuovere le autorizzazioni di `IAMAllowedPrincipals` gruppo dalla risorsa), devi aggiornare **le impostazioni della versione dell'account Cross alla versione 4** o successiva. Per aggiornare la versione utilizzando la console Lake Formation, scegli la **versione 4** o la **versione 5** nelle **impostazioni della versione dell'account Cross** nella pagina **delle impostazioni del Data Catalog**.
Puoi anche usare il `put-data-lake-settings` AWS CLI comando per impostare il `CROSS_ACCOUNT_VERSION` parametro sulla versione 4 o 5:
```
aws lakeformation put-data-lake-settings --region us-east-1 --data-lake-settings file://settings
{
"DataLakeAdmins": [
{
"DataLakePrincipalIdentifier": "arn:aws:iam::<111122223333>:user/"
}
],
"CreateDatabaseDefaultPermissions": [],
"CreateTableDefaultPermissions": [],
"Parameters": {
"CROSS_ACCOUNT_VERSION": "5"
}
}
```
1.
Per concedere le autorizzazioni su più account in modalità di accesso ibrida, il concedente deve disporre delle autorizzazioni IAM richieste per e i servizi. AWS Glue AWS RAM La policy AWS `AWSLakeFormationCrossAccountManager` gestita concede le autorizzazioni richieste.
Per abilitare la condivisione dei dati tra account in modalità di accesso ibrido, abbiamo aggiornato la policy `AWSLakeFormationCrossAccountManager` gestita aggiungendo due nuove autorizzazioni IAM:
+ ram: ListResourceSharePermissions
+ ram: AssociateResourceSharePermission
**Nota**
Se non utilizzi la politica AWS gestita per il ruolo di concedente, aggiungi le politiche precedenti alle politiche personalizzate.
## Ubicazione del bucket Amazon S3 e accesso utente
Quando crei un catalogo, un database o una tabella in AWS Glue Data Catalog, puoi specificare la posizione del bucket Amazon S3 dei dati sottostanti e registrarli con Lake Formation. Le tabelle seguenti descrivono come funzionano le autorizzazioni per gli utenti AWS Glue e gli utenti di Lake Formation (responsabili) in base alla posizione dei dati in Amazon S3 della tabella o del database.
**Sede Amazon S3 registrata presso Lake Formation**
| Ubicazione di un database in Amazon S3 | AWS Glue utenti | Utenti di Lake Formation |
| --- | --- | --- |
| Registrato a Lake Formation (in modalità di accesso ibrido o in modalità Lake Formation) | read/write Accedi alla posizione dati di Amazon S3 ereditando le autorizzazioni dal gruppo IAMAllowed Principal (super accesso). | Eredita le autorizzazioni per creare tabelle dall'autorizzazione CREATE TABLE concessa. |
| Nessuna sede Amazon S3 associata | Richiedi l'autorizzazione esplicita DATA LOCATION per eseguire le istruzioni CREATE TABLE e INSERT TABLE. | Richiedi l'autorizzazione esplicita DATA LOCATION per eseguire le istruzioni CREATE TABLE e INSERT TABLE. |
****IsRegisteredWithLakeFormation**proprietà della tabella**
La `IsRegisteredWithLakeFormation` proprietà di una tabella indica se la posizione dei dati della tabella è registrata con Lake Formation per il richiedente. Se la modalità di autorizzazione della posizione è registrata come Lake Formation, la `IsRegisteredWithLakeFormation` proprietà è valida `true` per tutti gli utenti che accedono alla posizione dei dati perché tutti gli utenti sono considerati iscritti a quella tabella. Se la posizione è registrata in modalità di accesso ibrida, il valore è impostato `true` solo per gli utenti che hanno optato per quella tabella.
**Funzionamento di `IsRegisteredWithLakeFormation`**
| Modalità di autorizzazione | Utenti/ruoli | `IsRegisteredWithLakeFormation` | Description |
| --- | --- | --- | --- |
| Lake Formation | Tutti | True | Quando una posizione viene registrata con Lake Formation, la `IsRegisteredWithLakeFormation` proprietà verrà impostata su true per tutti gli utenti. Ciò significa che le autorizzazioni definite in Lake Formation si applicano alla sede registrata. La vendita di credenziali sarà effettuata da Lake Formation. |
| Modalità di accesso ibrida | Ha aderito | True | Per gli utenti che hanno scelto di utilizzare Lake Formation per l'accesso e la governance dei dati per una tabella, la `IsRegisteredWithLakeFormation` proprietà verrà impostata su `true` per quella tabella. Sono soggetti alle politiche di autorizzazione definite in Lake Formation per la sede registrata. |
| Modalità di accesso ibrida | Non è stata attivata | False | Per gli utenti che non hanno scelto di utilizzare le autorizzazioni di Lake Formation, la `IsRegisteredWithLakeFormation` proprietà è impostata su. `false` Non sono soggetti alle politiche di autorizzazione definite in Lake Formation per la sede registrata. Gli utenti seguiranno invece le politiche di autorizzazione di Amazon S3. |
# Conversione di una AWS Glue risorsa in una risorsa ibrida
Segui questi passaggi per registrare una sede Amazon S3 in modalità di accesso ibrido e inserire nuovi utenti Lake Formation senza interrompere l'accesso ai dati degli utenti esistenti del Data Catalog.
Descrizione dello scenario: la posizione dei dati non è registrata con Lake Formation e l'accesso degli utenti al database e alle tabelle di Data Catalog è determinato dalle politiche di autorizzazione IAM per Amazon AWS Glue S3 e dalle azioni.
Per impostazione predefinita, il `IAMAllowedPrincipals` gruppo dispone di `Super` autorizzazioni su tutte le tabelle del database.
**Per abilitare la modalità di accesso ibrido per una posizione dati non registrata con Lake Formation**
1.
**Registra una posizione Amazon S3 abilitando la modalità di accesso ibrida.**
------
#### [ Console ]
1. Accedi alla [console Lake Formation](https://console.aws.amazon.com/lakeformation/) come amministratore del data lake.
1. Nel riquadro di navigazione, scegli **Posizioni dei data lake** in **Amministrazione**.
1. Scegli **Registra posizione**.
![\[Register location form for Amazon S3 data lake with path input, IAM role selection, and permission mode options.\]](http://docs.aws.amazon.com/it_it/lake-formation/latest/dg/images/hybrid-access-register-s3.png)
1. Nella finestra **Registra posizione**, scegli il percorso **Amazon S3** che desideri registrare con Lake Formation.
1. Per il **ruolo IAM**, scegli il ruolo `AWSServiceRoleForLakeFormationDataAccess` collegato al servizio (predefinito) o un ruolo IAM personalizzato ruolo che soddisfa i requisiti di. [Requisiti per i ruoli utilizzati per registrare le sedi](registration-role.md)
1. Scegli la **modalità di accesso ibrida** per applicare politiche di controllo degli accessi granulari di Lake Formation ai principali opt-in e ai database e alle tabelle di Data Catalog che puntano alla posizione registrata.
Scegli Lake Formation per consentire a Lake Formation di autorizzare le richieste di accesso alla posizione registrata.
1. Scegli **Registra posizione**.
------
#### [ AWS CLI ]
Di seguito è riportato un esempio di registrazione di una posizione dati con Lake Formation HybridAccessEnabled con:true/false. Il valore predefinito per il parametro è false. `HybridAccessEnabled` Sostituisci il percorso, il nome del ruolo e l'ID AWS account di Amazon S3 con valori validi.
```
aws lakeformation register-resource --cli-input-json file:file path
json:
{
"ResourceArn": "arn:aws:s3:::s3-path",
"UseServiceLinkedRole": false,
"RoleArn": "arn:aws:iam::<123456789012>:role/",
"HybridAccessEnabled": true
}
```
------
1.
**Concedi le autorizzazioni e attiva i principali per utilizzare le autorizzazioni di Lake Formation per le risorse in modalità di accesso ibrido**
Prima di attivare i principali e le risorse in modalità di accesso ibrido, verifica che `Super` i `All` permessi di `IAMAllowedPrincipals` raggruppamento esistano sui database e sulle tabelle la cui posizione è registrata con Lake Formation in modalità di accesso ibrida.
**Nota**
Non puoi concedere l'autorizzazione al `IAMAllowedPrincipals` gruppo `All tables` all'interno di un database. È necessario selezionare ogni tabella separatamente dal menu a discesa e concedere le autorizzazioni. Inoltre, quando crei nuove tabelle nel database, puoi scegliere di utilizzarle `Use only IAM access control for new tables in new databases` nelle Impostazioni del catalogo **dati**. Questa opzione concede automaticamente l'`Super`autorizzazione al `IAMAllowedPrincipals` gruppo quando si creano nuove tabelle all'interno del database.
------
#### [ Console ]
1. Nella console Lake Formation, in **Data Catalog**, scegli **Cataloghi**, **Database** o **Tabelle**.
1. Seleziona un catalogo, un database o una tabella dall'elenco e scegli **Concedi** dal menu **Azioni**.
1. Scegliete i principali per concedere le autorizzazioni sul database, sulle tabelle e sulle colonne utilizzando il metodo della risorsa denominata o i tag LF.
**In alternativa, scegli **Autorizzazioni dati**, seleziona i principali a cui concedere le autorizzazioni dall'elenco e scegli Concedi.**
Per maggiori dettagli sulla concessione delle autorizzazioni per i dati, consulta. [Concessione delle autorizzazioni per le risorse del Data Catalog](granting-catalog-permissions.md)
**Nota**
Se concedi l'autorizzazione Create table a un principale, devi anche concedere le autorizzazioni per la localizzazione dei dati (`DATA_LOCATION_ACCESS`) al principale. Questa autorizzazione non è necessaria per aggiornare le tabelle.
Per ulteriori informazioni, consulta [Concessione delle autorizzazioni per la localizzazione dei dati](granting-location-permissions.md).
1. Quando si utilizza il **metodo Named resource** per concedere le autorizzazioni, l'opzione per attivare i principali e le risorse è disponibile nella sezione inferiore della pagina **Concedi l'autorizzazione ai dati**.
Scegli **Rendi immediatamente effettive le autorizzazioni di Lake Formation** per abilitare le autorizzazioni di Lake Formation per i committenti e le risorse.
![\[L'opzione per scegliere la modalità di accesso ibrida per la risorsa Data Catalog.\]](http://docs.aws.amazon.com/it_it/lake-formation/latest/dg/images/hybrid-access-grant-option.png)
1. Scegliere **Concedi**.
Quando si attiva il principale A sulla tabella A che punta a una posizione dei dati, consente al principale A di accedere alla posizione di questa tabella utilizzando le autorizzazioni di Lake Formation se la posizione dei dati è registrata in modalità ibrida.
------
#### [ AWS CLI ]
Di seguito è riportato un esempio di attivazione di un principale e di una tabella in modalità di accesso ibrida. Sostituisci il nome del ruolo, l'id AWS dell'account, il nome del database e il nome della tabella con valori validi.
```
aws lakeformation create-lake-formation-opt-in --cli-input-json file://file path
json:
{
"Principal": {
"DataLakePrincipalIdentifier": "arn:aws:iam::<123456789012>:role/"
},
"Resource": {
"Table": {
"CatalogId": "<123456789012>",
"DatabaseName": "",
"Name": ""
}
}
}
```
------
1. Se scegli LF-Tags per concedere le autorizzazioni, puoi attivare i principali per utilizzare i permessi di Lake Formation in un passaggio separato. Puoi farlo scegliendo la **modalità di accesso ibrido** in **Autorizzazioni** nella barra di navigazione a sinistra.
1. Nella sezione inferiore della pagina della **modalità di accesso ibrida**, scegli **Aggiungi per aggiungere** risorse e principali alla modalità di accesso ibrida.
1. Nella pagina **Aggiungi risorse e principali, scegli i** cataloghi, i database e le tabelle registrati in modalità di accesso ibrido.
Puoi scegliere `All tables` all'interno di un database per concedere l'accesso.
![\[L'interfaccia per aggiungere cataloghi, database e tabelle in modalità di accesso ibrido.\]](http://docs.aws.amazon.com/it_it/lake-formation/latest/dg/images/hybrid-access-opt-in.png)
1. Scegli i titolari e accetta di utilizzare le autorizzazioni di Lake Formation in modalità di accesso ibrida.
+ **Responsabili**: puoi scegliere utenti e ruoli IAM nello stesso account o in un altro account. Puoi anche scegliere utenti e gruppi SAML.
+ **Attributi**: seleziona gli attributi per concedere le autorizzazioni in base agli attributi.
![\[L'interfaccia per aggiungere principi e risorse con un'espressione di attributo.\]](http://docs.aws.amazon.com/it_it/lake-formation/latest/dg/images/abac-hybrid-access.png)
+ Inserisci la coppia chiave-valore per creare una concessione basata sugli attributi. Controlla l'espressione della policy Cedar sulla console. Per ulteriori informazioni su Cedar, vedi [Cos'è Cedar? \$1 Cedar Policy](https://docs.cedarpolicy.com/) Language Reference. GuideLink
+ Scegliere **Aggiungi**.
A tutti gli IAM roles/users con attributi corrispondenti viene concesso l'accesso.
1. Scegliere **Aggiungi**.
# Conversione di una risorsa di Lake Formation in una risorsa ibrida
Nei casi in cui attualmente utilizzi le autorizzazioni di Lake Formation per i database e le tabelle del Data Catalog, puoi modificare le proprietà di registrazione della posizione per abilitare la modalità di accesso ibrida. Ciò consente di fornire ai nuovi principali l'accesso alle stesse risorse utilizzando le politiche di autorizzazione IAM per Amazon S3 AWS Glue e le azioni senza interrompere le autorizzazioni esistenti di Lake Formation.
Descrizione dello scenario: i passaggi seguenti presuppongono che tu abbia una posizione dei dati registrata con Lake Formation e che tu abbia impostato le autorizzazioni per i principali su database, tabelle o colonne che puntano a quella posizione. Se la posizione è stata registrata con un ruolo collegato al servizio, non puoi aggiornare i parametri di posizione e abilitare la modalità di accesso ibrida. Per impostazione predefinita, il `IAMAllowedPrincipals` gruppo dispone di autorizzazioni Super sul database e su tutte le relative tabelle.
**Importante**
Non aggiornate la registrazione di una posizione alla modalità di accesso ibrida senza attivare i principali che accedono ai dati in questa posizione.
**Abilitazione della modalità di accesso ibrido per una posizione dati registrata con Lake Formation**
1.
**avvertimento**
Non consigliamo di convertire una posizione dati gestita da Lake Formation in modalità di accesso ibrida per evitare di interrompere le politiche di autorizzazione di altri utenti o carichi di lavoro esistenti.
Scegli i presidi esistenti che dispongono dei permessi di Lake Formation.
1. Elenca e rivedi le autorizzazioni che hai concesso ai responsabili su cataloghi, database e tabelle. Per ulteriori informazioni, consulta [Visualizzazione delle autorizzazioni per database e tabelle in Lake Formation](viewing-permissions.md).
1. **Scegli la **modalità di accesso ibrido** in **Autorizzazioni** dalla barra di navigazione a sinistra e scegli Aggiungi.**
1. Nella pagina **Aggiungi principali e risorse, scegli i** cataloghi, i database e le tabelle dalla posizione dati di Amazon S3 che desideri utilizzare in modalità di accesso ibrido. Scegli i presidi che dispongono già dei permessi di Lake Formation.
1. Scegli **Aggiungi** per attivare i principali per utilizzare le autorizzazioni di Lake Formation in modalità di accesso ibrida.
1. Aggiorna la bucket/prefix registrazione Amazon S3 scegliendo l'opzione della **modalità di accesso ibrida**.
------
#### [ Console ]
1. Accedi alla console di Lake Formation come amministratore del data lake.
1. Nel riquadro di navigazione, in **Register and Ingest**, scegli **Data lake locations**.
1. Seleziona una posizione e nel menu **Azioni** scegli **Modifica**.
1. Scegli la **modalità di accesso ibrida**.
1. Scegli **Save** (Salva).
1. In Data Catalog, seleziona il database o la tabella e `Super` concedi `All` le autorizzazioni al gruppo virtuale chiamato`IAMAllowedPrincipals`.
1. Verifica che l'accesso degli utenti esistenti di Lake Formation non venga interrotto quando hai aggiornato le proprietà di registrazione della posizione. Accedi alla console Athena come principale di Lake Formation ed esegui una query di esempio su una tabella che punta alla posizione aggiornata.
Allo stesso modo, verifica l'accesso degli AWS Glue utenti che utilizzano le policy di autorizzazione IAM per accedere al database e alle tabelle.
------
#### [ AWS CLI ]
Di seguito è riportato un esempio di registrazione di una posizione dati con Lake Formation HybridAccessEnabled con:true/false. Il valore predefinito per il parametro è false. `HybridAccessEnabled` Sostituisci il percorso, il nome del ruolo e l'ID AWS account di Amazon S3 con valori validi.
```
aws lakeformation update-resource --cli-input-json file://file path
json:
{
"ResourceArn": "arn:aws:s3:::",
"RoleArn": "arn:aws:iam::<123456789012>:role/",
"HybridAccessEnabled": true
}
```
------
# Condivisione di una AWS Glue risorsa utilizzando la modalità di accesso ibrida
Condividi i dati con un altro Account AWS o con un responsabile di un altro richiedente Account AWS applicando le autorizzazioni di Lake Formation senza interrompere l'accesso basato su IAM degli utenti di Data Catalog esistenti.
Descrizione dello scenario: l'account produttore dispone di un database Data Catalog il cui accesso è controllato tramite le politiche e AWS Glue le azioni principali di IAM per Amazon S3. La posizione dei dati del database non è registrata con Lake Formation. Per impostazione predefinita, il `IAMAllowedPrincipals` gruppo dispone `Super` delle autorizzazioni per il database e tutte le relative tabelle.
**Concessione di autorizzazioni Lake Formation per più account in modalità di accesso ibrida**
1.
**Configurazione dell'account Producer**
1. Accedi alla console di Lake Formation utilizzando un ruolo con autorizzazione `lakeformation:PutDataLakeSettings` IAM.
1. Vai alle **impostazioni di Data Catalog** e scegli `Version 4` le **impostazioni della versione dell'account Cross**.
Se attualmente utilizzi la versione 1 o 2, consulta [Aggiornamento delle impostazioni della versione di condivisione dei dati tra account](optimize-ram.md) le istruzioni per l'aggiornamento alla versione 3.
Non sono necessarie modifiche alla politica di autorizzazione per l'aggiornamento dalla versione 3 alla 4.
1. Registra la posizione Amazon S3 del database o della tabella che intendi condividere in modalità di accesso ibrido.
1. Verifica che l'`Super`autorizzazione al `IAMAllowedPrincipals` gruppo esista sui database e sulle tabelle di cui hai registrato la posizione dei dati in modalità di accesso ibrida nel passaggio precedente.
1. Concedi le autorizzazioni di Lake Formation a AWS organizzazioni, unità organizzative (OUs) o direttamente con un responsabile IAM in un altro account.
1. Se concedi le autorizzazioni direttamente a un principale IAM, scegli l'indirizzo principale dall'account consumer per applicare le autorizzazioni di Lake Formation in modalità di accesso ibrido abilitando l'opzione Rendi le autorizzazioni di **Lake Formation effettive** immediatamente.
Se concedi autorizzazioni per più account a un altro AWS account, quando attivi l'account, le autorizzazioni di Lake Formation vengono applicate solo agli amministratori di quell'account. L'amministratore del data lake dell'account destinatario deve ripartire a cascata le autorizzazioni e attivare i principali dell'account per applicare le autorizzazioni di Lake Formation per le risorse condivise che si trovano in modalità di accesso ibrido.
Se scegli l'opzione **Resources matched by LF-Tags** per concedere le autorizzazioni su più account, devi prima completare la fase di concessione delle autorizzazioni. Puoi impostare i principali e le risorse per la modalità di accesso ibrido in un passaggio separato selezionando la **modalità di accesso ibrida** in Autorizzazioni nella barra di navigazione a sinistra della console Lake Formation. Quindi scegli **Aggiungi** per aggiungere le risorse e i presidi a cui desideri applicare le autorizzazioni di Lake Formation.
1.
**Configurazione dell'account consumatore**
1. Accedi alla console di Lake Formation [https://console.aws.amazon.com/lakeformation/](https://console.aws.amazon.com/lakeformation/)come amministratore del data lake.
1. Vai alla [https://console.aws.amazon.com/ram/home page](https://console.aws.amazon.com/ram/home) e accetta l'invito alla condivisione delle risorse. La scheda **Condivisi con me** nella AWS RAM console mostra il database e le tabelle condivise con il tuo account.
1. Crea un link di risorsa alla and/or tabella del database condivisa in Lake Formation.
1. Concedi `Describe` l'autorizzazione sul link alla risorsa e l'`Grant on target`autorizzazione (sulla risorsa condivisa originale) ai principali IAM del tuo account (consumatore).
1. Concedi le autorizzazioni di Lake Formation sul database o sulla tabella condivisa con te ai responsabili del tuo account. Scegli i principi e le risorse per applicare le autorizzazioni di Lake Formation in modalità di accesso ibrida abilitando l'opzione Rendi immediatamente effettive le **autorizzazioni di Lake Formation**.
1. Verifica le autorizzazioni Lake Formation del preside eseguendo query Athena di esempio. Testa l'accesso esistente dei tuoi AWS Glue utenti con le policy principali di IAM per Amazon S3 e AWS Glue le azioni.
(Facoltativo) Rimuovi la policy del bucket di Amazon S3 per l'accesso ai dati e le politiche principali di IAM e l'accesso ai dati di Amazon S3 per AWS Glue i principali che hai configurato per utilizzare le autorizzazioni Lake Formation.
# Condivisione di una risorsa Lake Formation utilizzando la modalità di accesso ibrida
Consenti ai nuovi utenti di Data Catalog in un account esterno di accedere ai database e alle tabelle di Data Catalog utilizzando policy basate su IAM senza interrompere le autorizzazioni di condivisione tra account esistenti di Lake Formation.
Descrizione dello scenario: l'account produttore dispone di database e tabelle gestiti da Lake Formation condivisi con un account esterno (consumatore) a livello di account o principale IAM. La posizione dei dati del database è registrata presso Lake Formation. Il `IAMAllowedPrincipals` gruppo non dispone `Super` delle autorizzazioni per il database e le relative tabelle.
**Garantire l'accesso su più account ai nuovi utenti del Data Catalog tramite policy basate su IAM senza interrompere le autorizzazioni esistenti di Lake Formation**
1.
**Configurazione dell'account Producer**
1. Accedi alla console Lake Formation utilizzando un ruolo che`lakeformation:PutDataLakeSettings`.
1. In **Impostazioni Data Catalog**, scegli `Version 4` le **impostazioni della versione dell'account Cross**.
Se attualmente utilizzi la versione 1 o 2, consulta [Aggiornamento delle impostazioni della versione di condivisione dei dati tra account](optimize-ram.md) le istruzioni per l'aggiornamento alla versione 3.
Non sono necessarie modifiche alla politica di autorizzazione per l'aggiornamento dalla versione 3 alla 4.
1. Elenca le autorizzazioni che hai concesso ai principali su database e tabelle. Per ulteriori informazioni, consulta [Visualizzazione delle autorizzazioni per database e tabelle in Lake Formation](viewing-permissions.md).
1. Rigenera le autorizzazioni esistenti per più account di Lake Formation optando per i principali e le risorse.
**Nota**
Prima di aggiornare la registrazione di una posizione dati alla modalità di accesso ibrida per concedere le autorizzazioni tra più account, devi concedere nuovamente almeno una condivisione di dati tra account per account. Questo passaggio è necessario per aggiornare le autorizzazioni AWS RAM gestite allegate alla condivisione di risorse. AWS RAM
Nel luglio 2023, Lake Formation ha aggiornato le autorizzazioni AWS RAM gestite utilizzate per la condivisione di database e tabelle:
`arn:aws:ram::aws:permission/AWSRAMLFEnabledGlueAllTablesReadWriteForDatabase`(politica di condivisione a livello di database)
`arn:aws:ram::aws:permission/AWSRAMLFEnabledGlueTableReadWrite`(politica di condivisione a livello di tabella)
Le autorizzazioni per più account concesse prima di luglio 2023 non dispongono di queste autorizzazioni aggiornate. AWS RAM
Se hai concesso autorizzazioni per più account direttamente ai responsabili, devi concedere nuovamente tali autorizzazioni individualmente ai responsabili. Se salti questo passaggio, i principali che accedono alla risorsa condivisa potrebbero ricevere un errore di combinazione illegale.
1. [Vai a casa. https://console.aws.amazon.com/ram/](https://console.aws.amazon.com/ram/home)
1. La scheda **Condivisi da me** nella AWS RAM console mostra i nomi di database e tabelle che hai condiviso con un account o un principale esterno.
Assicurati che le autorizzazioni allegate alla risorsa condivisa abbiano l'ARN corretto.
1. Verifica che lo stato delle risorse nella AWS RAM condivisione sia attivo. `Associated` Se lo stato è uguale a`Associating`, attendi che entrino `Associated` nello stato. Se lo stato diventa`Failed`, fermati e contatta il team di assistenza di Lake Formation.
1. Scegli la **modalità di accesso ibrido** in **Autorizzazioni** dalla barra di navigazione a sinistra e scegli **Aggiungi**.
1. La pagina **Aggiungi principi e risorse** mostra i database, le and/or tabelle e i principali che hanno accesso. È possibile apportare gli aggiornamenti richiesti aggiungendo o rimuovendo i principali e le risorse.
1. Scegli i principali con autorizzazioni Lake Formation per il database e le tabelle che desideri modificare in modalità di accesso ibrida. Scegli i database e le tabelle.
1. Scegli **Aggiungi** per attivare i principali per applicare le autorizzazioni di Lake Formation in modalità di accesso ibrida.
1. Concedi `Super` l'autorizzazione al gruppo virtuale `IAMAllowedPrincipals` sul tuo database e sulle tabelle selezionate.
1. Modifica la registrazione della sede Amazon S3 Lake Formation in modalità di accesso ibrida.
1. Concedi le autorizzazioni agli AWS Glue utenti dell'account esterno (consumer) utilizzando le politiche di autorizzazione IAM per le azioni di Amazon AWS Glue S3.
1.
**Configurazione dell'account consumer**
1. Accedi alla console di Lake Formation [https://console.aws.amazon.com/lakeformation/](https://console.aws.amazon.com/lakeformation/)come amministratore del data lake.
1. Vai alla [https://console.aws.amazon.com/ram/home page](https://console.aws.amazon.com/ram/home) e accetta l'invito alla condivisione delle risorse. La scheda **Risorse condivise con me** della AWS RAM pagina mostra i nomi dei database e delle tabelle condivisi con il tuo account.
Per la AWS RAM condivisione, assicurati che l'autorizzazione allegata contenga l'ARN corretto dell'invito condiviso AWS RAM . Controlla se le risorse della AWS RAM condivisione sono in `Associated` stato. Se lo stato è uguale`Associating`, attendi che diventino `Associated` tali. Se lo stato diventa`Failed`, fermati e contatta il team di assistenza di Lake Formation.
1. Crea un link di risorsa alla and/or tabella del database condivisa in Lake Formation.
1. Concedi `Describe` l'autorizzazione sul link alla risorsa e l'`Grant on target`autorizzazione (sulla risorsa condivisa originale) ai principali IAM del tuo account (consumatore).
1. Successivamente, configura le autorizzazioni di Lake Formation per i principali del tuo account nel database o nella tabella condivisa.
Nella barra di navigazione a sinistra, in **Autorizzazioni**, scegli la modalità di accesso **ibrido**.
1. Scegli **Aggiungi** nella sezione inferiore della pagina della **modalità di accesso ibrido** per attivare i principali e il database o la tabella condivisi con te dall'account produttore.
1. Concedi le autorizzazioni agli AWS Glue utenti del tuo account utilizzando le politiche di autorizzazione IAM per le azioni di Amazon AWS Glue S3.
1. Verifica le autorizzazioni e AWS Glue le autorizzazioni di Lake Formation degli utenti eseguendo query di esempio separate sulla tabella utilizzando Athena
(Facoltativo) Pulisci le politiche di autorizzazione IAM per Amazon S3 per i principali che si trovano in modalità di accesso ibrido.
# Rimozione di principi e risorse dalla modalità di accesso ibrida
Segui questi passaggi per rimuovere database, tabelle e principali dalla modalità di accesso ibrido.
------
#### [ Console ]
1. Accedi alla console Lake Formation all'indirizzo [https://console.aws.amazon.com/lakeformation/](https://console.aws.amazon.com/lakeformation/).
1. In **Autorizzazioni**, scegli la **modalità di accesso ibrido**.
1. Nella pagina della **modalità di accesso ibrido**, seleziona la casella di controllo accanto al nome del database o della tabella e scegli. `Remove`
1. Un messaggio di avviso richiede di confermare l'azione. Scegli **Rimuovi**.
Lake Formation non impone più le autorizzazioni per tali risorse e l'accesso a questa risorsa sarà controllato tramite IAM e AWS Glue le autorizzazioni. Ciò potrebbe far sì che l'utente non abbia più accesso a questa risorsa se non dispone delle autorizzazioni IAM appropriate.
------
#### [ AWS CLI ]
L'esempio seguente mostra come rimuovere risorse dalla modalità di accesso ibrida.
```
aws lakeformation delete-lake-formation-opt-in --cli-input-json file://file path
json:
{
"Principal": {
"DataLakePrincipalIdentifier": "arn:aws:iam::<123456789012>:role/role name"
},
"Resource": {
"Table": {
"CatalogId": "<123456789012>",
"DatabaseName": "",
"Name": ""
}
}
}
```
------
# Visualizzazione dei principali e delle risorse in modalità di accesso ibrida
Segui questi passaggi per visualizzare database, tabelle e principali in modalità di accesso ibrido.
------
#### [ Console ]
1. Accedi alla console Lake Formation all'indirizzo [https://console.aws.amazon.com/lakeformation/](https://console.aws.amazon.com/lakeformation/).
1. In **Autorizzazioni**, scegli la **modalità di accesso ibrido**.
1. La pagina della **modalità di accesso ibrido** mostra le risorse e i principali attualmente in modalità di accesso ibrida.
------
#### [ AWS CLI ]
L'esempio seguente mostra come elencare tutti i principali e le risorse di opt-in che si trovano in modalità di accesso ibrida.
```
aws lakeformation list-lake-formation-opt-ins
```
L'esempio seguente mostra come elencare gli opt-in per una specifica coppia principale-risorsa.
```
aws lakeformation list-lake-formation-opt-ins --cli-input-json file://file path
json:
{
"Principal": {
"DataLakePrincipalIdentifier": "arn:aws:iam:::role/"
},
"Resource": {
"Table": {
"CatalogId": "",
"DatabaseName": "",
"Name": ""
}
}
}
```
------
# Risorse aggiuntive
Nel seguente post del blog, ti illustreremo le istruzioni per integrare le autorizzazioni di Lake Formation in modalità di accesso ibrida per utenti selezionati mentre il database è già accessibile ad altri utenti tramite le autorizzazioni IAM e Amazon S3. Esamineremo le istruzioni per configurare la modalità di accesso ibrida all'interno di un AWS account e tra due account.
+ [Presentazione della modalità di accesso AWS Glue Data Catalog ibrida per l'accesso sicuro utilizzando le policy di Lake Formation e IAM e Amazon S3.](https://aws.amazon.com/blogs/big-data/introducing-hybrid-access-mode-for-aws-glue-data-catalog-to-secure-access-using-aws-lake-formation-and-iam-and-amazon-s3-policies/)
# Creazione di oggetti in AWS Glue Data Catalog
AWS Lake Formation utilizza AWS Glue Data Catalog (Data Catalog) per archiviare metadati su data lake, origini dati, trasformazioni e destinazioni. I metadati sono dati relativi ai dati sottostanti nel set di dati. Ogni AWS account dispone di un catalogo dati per regione. AWS
I metadati nel Data Catalog sono organizzati in una gerarchia di dati a tre livelli che comprende cataloghi, database e tabelle. Organizza i dati provenienti da varie fonti in contenitori logici chiamati cataloghi. Ogni catalogo rappresenta dati provenienti da fonti come data warehouse Amazon Redshift, Amazon DynamoDB database e fonti di dati di terze parti come Snowflake, MySQL e oltre 30 fonti di dati esterne, integrate tramite connettori federati. Puoi anche creare nuovi cataloghi nel Data Catalog per archiviare i dati in S3 Table Bucket o Redshift Managed Storage (RMS).
Le tabelle memorizzano informazioni sui dati sottostanti, tra cui informazioni sullo schema, sulle partizioni e sulla posizione dei dati. I database sono raccolte di tabelle. Il Data Catalog contiene anche collegamenti a risorse, che sono collegamenti a cataloghi, database e tabelle condivisi in account esterni e vengono utilizzati per l'accesso tra account diversi ai dati nel data lake.
Il Data Catalog è un oggetto di catalogo annidato che contiene cataloghi, database e tabelle. È referenziato dall' Account AWS ID ed è il catalogo predefinito in un account e in un. Regione AWS Il Data Catalog utilizza una gerarchia a tre livelli (catalog.database.table) per organizzare le tabelle.
+ Catalogo: il livello più alto della gerarchia dei metadati a tre livelli di Data Catalog. È possibile aggiungere più cataloghi in un Data Catalog tramite la federazione.
+ Database: il secondo livello della gerarchia dei metadati che comprende tabelle e viste. Un database viene anche definito schema in molti sistemi di dati come Amazon Redshift e Trino.
+ Tabella e visualizzazione: il terzo livello della gerarchia dei dati a 3 livelli del Data Catalog.
Tutte le tabelle Iceberg in Amazon S3 sono archiviate nel Data Catalog predefinito con Catalog ID = ID Account AWS . Puoi creare cataloghi federati in AWS Glue Data Catalog cui archiviare le definizioni delle tabelle in Amazon Redshift, Amazon S3 Table Storage o altre fonti di dati di terze parti tramite la federazione.
**Topics**
+ [Creare un catalogo](creating-catalog.md)
+ [Creazione di un database](creating-database.md)
+ [Creazione di tabelle](creating-tables.md)
+ [AWS Glue Data Catalog Viste dell'edificio](working-with-views.md)
# Creare un catalogo
I cataloghi rappresentano il livello più alto o più alto nella gerarchia dei metadati a tre livelli di. AWS Glue Data CatalogÈ possibile utilizzare diversi metodi per inserire i dati nel Data Catalog e creare cataloghi a più livelli.
Per ulteriori informazioni sulla creazione di cataloghi da fonti di dati esterne, consulta. [Inserire i dati nel AWS Glue Data Catalog](bring-your-data-overview.md)
Per creare un catalogo utilizzando la console Lake Formation, devi accedere come amministratore del data lake o *creatore di cataloghi*. Un creatore di cataloghi è un preside a cui è stata concessa l'`CREATE_CATALOG`autorizzazione Lake Formation. Puoi vedere un elenco dei creatori del catalogo nella pagina **Ruoli e attività amministrative** della console Lake Formation. Per visualizzare questo elenco, devi disporre dell'autorizzazione `lakeformation:ListPermissions` IAM ed essere registrato come amministratore del data lake o come creatore di cataloghi con l'opzione di concessione sull'`CREATE_CATALOG`autorizzazione.
# Creazione di un database
Le tabelle di metadati nel Data Catalog sono archiviate all'interno di database. Puoi creare tutti i database di cui hai bisogno e puoi concedere diverse autorizzazioni Lake Formation su ciascun database.
I database possono avere una proprietà di localizzazione opzionale. Questa sede si trova in genere all'interno di una sede Amazon Simple Storage Service (Amazon S3) registrata presso Lake Formation. Quando specifichi una posizione, i responsabili non necessitano delle autorizzazioni per la localizzazione dei dati per creare tabelle Data Catalog che puntano a posizioni all'interno della posizione del database. Per ulteriori informazioni, consulta [Underlying data access control](access-control-underlying-data.md#data-location-permissions).
Per creare un database utilizzando la console Lake Formation, devi accedere come amministratore del data lake o *creatore del database*. Un creatore di database è un responsabile a cui è stata concessa l'`CREATE_DATABASE`autorizzazione Lake Formation. Puoi vedere un elenco dei creatori di database nella pagina **Ruoli e attività amministrative** della console Lake Formation. Per visualizzare questo elenco, è necessario disporre dell'autorizzazione `lakeformation:ListPermissions` IAM e accedere come amministratore del data lake o come creatore di database con l'opzione di concessione sull'`CREATE_DATABASE`autorizzazione.
**Come creare un database**
1. Apri la AWS Lake Formation console all'indirizzo [https://console.aws.amazon.com/lakeformation/](https://console.aws.amazon.com/lakeformation/)e accedi come amministratore del data lake o creatore di database.
1. Nel riquadro di navigazione, in **Catalogo dati**, scegli **Database**.
1. Scegliere **Crea database**.
1. Nella finestra di dialogo **Crea database**, inserisci un nome di database, una posizione opzionale e una descrizione facoltativa.
1. Facoltativamente, seleziona **Usa solo il controllo di accesso IAM per le nuove tabelle in questo database**.
Per ulteriori informazioni su questa opzione, consulta [Modifica delle impostazioni predefinite per il data lake](change-settings.md).
1. Scegliere **Crea database**.
# Creazione di tabelle
AWS Lake Formation le tabelle di metadati contengono informazioni sui dati nel data lake, incluse informazioni sullo schema, sulle partizioni e sulla posizione dei dati. Queste tabelle sono archiviate nel AWS Glue Data Catalog. Li usi per accedere ai dati sottostanti nel data lake e gestirli con le autorizzazioni di Lake Formation. Le tabelle vengono archiviate all'interno dei database del Data Catalog.
Esistono diversi modi per creare tabelle Data Catalog:
+ Esegui un crawler. AWS Glue *Vedi [Definizione dei crawler nella Guida per gli](https://docs.aws.amazon.com/glue/latest/dg/add-crawler.html) sviluppatori.AWS Glue *
+ Crea ed esegui un flusso di lavoro. Per informazioni, consulta [Importazione di dati utilizzando i flussi di lavoro in Lake Formation](workflows.md).
+ Crea una tabella manualmente utilizzando la console di Lake Formation, AWS Glue l'API o AWS Command Line Interface (AWS CLI).
+ Crea una tabella utilizzando Amazon Athena.
+ Crea un collegamento di risorsa a una tabella in un account esterno. Per informazioni, consulta [Creazione di collegamenti alle risorse](creating-resource-links.md).
# Creazione di tabelle Apache Iceberg
AWS Lake Formation supporta la creazione di tabelle Apache Iceberg che utilizzano il formato di dati Apache Parquet AWS Glue Data Catalog con dati che risiedono in Amazon S3. Una tabella nel catalogo dati è la definizione dei metadati che rappresenta i dati in un datastore. Per impostazione predefinita, Lake Formation crea tabelle Iceberg v2. Per la differenza tra le tabelle v1 e v2, consulta [Modifiche al tipo di formato](https://iceberg.apache.org/spec/#appendix-e-format-version-changes) nella documentazione di Apache Iceberg.
[Apache Iceberg](https://iceberg.apache.org/) è un formato a tabella aperta per set di dati analitici di dimensioni molto grandi. Iceberg consente di modificare facilmente lo schema, operazione nota anche come evoluzione dello schema, il che significa che gli utenti possono aggiungere, rinominare o rimuovere colonne da una tabella di dati senza pregiudicare i dati sottostanti. Iceberg fornisce anche supporto per il controllo delle versioni dei dati, che consente agli utenti di tenere traccia delle modifiche apportate ai dati nel tempo. Ciò abilita la funzionalità di query temporale, che consente agli utenti di accedere e interrogare le versioni storiche dei dati e analizzare le modifiche ai dati tra aggiornamenti ed eliminazioni.
Puoi utilizzare la console Lake Formation o l'`CreateTable`operazione nell' AWS Glue API per creare una tabella Iceberg nel Data Catalog. Per ulteriori informazioni, vedere [CreateTable action (Python: create\$1table](https://docs.aws.amazon.com/glue/latest/dg/aws-glue-api-catalog-tables.html#aws-glue-api-catalog-tables-CreateTable)).
Quando si crea una tabella Iceberg nel catalogo dati, occorre specificare il formato della tabella e il percorso del file dei metadati in Amazon S3 per poter eseguire letture e scritture.
Puoi usare Lake Formation per proteggere la tua tabella Iceberg utilizzando autorizzazioni di controllo degli accessi granulari quando registri la posizione dati di Amazon S3 con. AWS Lake Formation Per i dati di origine in Amazon S3 e i metadati non registrati con Lake Formation, l'accesso è determinato dalle politiche di autorizzazione IAM per Amazon S3 e dalle azioni. AWS Glue Per ulteriori informazioni, consulta [Gestione delle autorizzazioni di Lake Formation](managing-permissions.md).
**Nota**
Il catalogo dati non supporta la creazione di partizioni e l'aggiunta di proprietà delle tabelle Iceberg.
**Topics**
+ [Prerequisiti](#iceberg-prerequisites)
+ [Creazione di una tabella Iceberg](#create-iceberg-table)
## Prerequisiti
Per creare tabelle Iceberg nel catalogo dati e configurare le autorizzazioni di accesso ai dati di Lake Formation, occorre soddisfare i seguenti requisiti:
1.
**Autorizzazioni richieste per creare tabelle Iceberg senza i dati registrati con Lake Formation.**
Oltre alle autorizzazioni richieste per creare una tabella nel catalogo dati, il creatore della tabella richiede le seguenti autorizzazioni:
+ `s3:PutObject` sulla risorsa arn:aws:s3:::\$1bucketName\$1
+ `s3:GetObject` sulla risorsa arn:aws:s3:::\$1bucketName\$1
+ `s3:DeleteObject` sulla risorsa arn:aws:s3:::\$1bucketName\$1
1.
**Autorizzazioni richieste per creare tabelle Iceberg con dati registrati con Lake Formation:**
Per utilizzare Lake Formation per gestire e proteggere i dati nel data lake, registrare la posizione Amazon S3 che contiene i dati per le tabelle con Lake Formation. In questo modo Lake Formation può fornire credenziali a servizi di AWS analisi come Athena, Redshift Spectrum e Amazon EMR per accedere ai dati. Per ulteriori informazioni sulla registrazione di una sede Amazon S3, consulta. [Aggiungere una posizione Amazon S3 al tuo data lake](register-data-lake.md)
Un principale che legge e scrive i dati sottostanti registrati con Lake Formation richiede le seguenti autorizzazioni:
+ `lakeformation:GetDataAccess`
+ `DATA_LOCATION_ACCESS`
Un principale che dispone di autorizzazioni di localizzazione dei dati in una sede dispone anche delle autorizzazioni di localizzazione su tutte le sedi secondarie.
Per ulteriori informazioni sulle autorizzazioni relative alla localizzazione dei dati, consulta. [Controllo sottostante dell'accesso ai dati](access-control-underlying-data.md)
Per abilitare la compattazione, il servizio deve assumere un ruolo IAM con le autorizzazioni per aggiornare le tabelle nel catalogo dati. Per i dettagli, consulta [Prerequisiti per l'ottimizzazione delle tabelle](https://docs.aws.amazon.com/glue/latest/dg/optimization-prerequisites.html).
## Creazione di una tabella Iceberg
Puoi creare tabelle Iceberg v1 e v2 utilizzando la console Lake Formation o AWS Command Line Interface come documentato in questa pagina. Puoi anche creare tabelle Iceberg usando la console o. AWS Glue Crawler di AWS Glue Per ulteriori informazioni, consultare [Catalogo dati e crawler](https://docs.aws.amazon.com/glue/latest/dg/catalog-and-crawler.html) nella Guida per gli sviluppatori di AWS Glue .
**Per creare una tabella Iceberg**
------
#### [ Console ]
1. Accedi a Console di gestione AWS, e apri la console Lake Formation all'indirizzo [https://console.aws.amazon.com/lakeformation/](https://console.aws.amazon.com/lakeformation/).
1. In catalogo dati, scegliere **Tabelle** e utilizzare il pulsante **Crea tabella** per specificare i seguenti attributi:
+ **Nome tabella**: inserisci un nome per la tabella. Se si utilizza Athena per accedere alle tabelle, utilizzare questi [suggerimenti per la denominazione](https://docs.aws.amazon.com/athena/latest/ug/tables-databases-columns-names.html) della Guida per l'utente di Amazon Athena.
+ **Database**: scegli un database esistente o creane uno nuovo.
+ **Descrizione: la descrizione della** tabella. È possibile scrivere una descrizione per aiutare a comprendere i contenuti della tabella.
+ **Formato tabella: per il formato** **tabella**, scegli Apache Iceberg.
![\[Opzione di tabella Apache Iceberg selezionata con opzioni di ottimizzazione della tabella.\]](http://docs.aws.amazon.com/it_it/lake-formation/latest/dg/images/table-optimization.png)
+ **Ottimizzazione della tabella**
+ **Compattazione**: I file di dati vengono uniti e riscritti per rimuovere i dati obsoleti e consolidare i dati frammentati in file più grandi ed efficienti.
+ **Conservazione degli snapshot**: gli snapshot sono versioni con data e ora di una tabella Iceberg. Le configurazioni di conservazione degli snapshot consentono ai clienti di stabilire per quanto tempo conservare gli snapshot e quanti snapshot conservare. La configurazione di un ottimizzatore di conservazione degli snapshot può aiutare a gestire il sovraccarico di archiviazione rimuovendo gli snapshot più vecchi e non necessari e i relativi file sottostanti.
+ **Eliminazione di file orfani**: i file orfani sono file a cui non fanno più riferimento i metadati della tabella Iceberg. Questi file possono accumularsi nel tempo, soprattutto dopo operazioni come l'eliminazione di tabelle o i processi ETL non riusciti. L'abilitazione dell'eliminazione dei file orfani AWS Glue consente di identificare e rimuovere periodicamente questi file non necessari, liberando spazio di archiviazione.
Per ulteriori informazioni, consulta [Ottimizzazione delle tabelle Iceberg](https://docs.aws.amazon.com/glue/latest/dg/table-optimizers.html).
+ **Ruolo IAM**: per eseguire la compattazione, il servizio assume un ruolo IAM per conto dell'utente. Puoi scegliere un ruolo IAM utilizzando il menu a discesa. Assicurati che il ruolo disponga delle autorizzazioni necessarie per abilitare la compattazione.
Per ulteriori informazioni sulle autorizzazioni richieste, consulta Prerequisiti per l'ottimizzazione delle [tabelle.](https://docs.aws.amazon.com/glue/latest/dg/optimization-prerequisites.html)
+ **Posizione**: specifica il percorso della cartella in Amazon S3 che memorizza la tabella dei metadati. Iceberg ha bisogno di un file di metadati e di una posizione nel catalogo dati per poter eseguire letture e scritture.
+ **Schema**: scegli **Aggiungi colonne** per aggiungere colonne e tipi di dati delle colonne. Si dispone della possibilità di creare una tabella vuota e di aggiornare lo schema in un secondo momento. Il catalogo dati supporta i tipi di dati Hive. Per ulteriori informazioni, consultare [Tipi di dati Hive](https://cwiki.apache.org/confluence/plugins/servlet/mobile?contentId=27838462#content/view/27838462).
Iceberg consente di evolvere lo schema e la partizione dopo aver creato la tabella. È possibile usare le [query di Athena](https://docs.aws.amazon.com/athena/latest/ug/querying-iceberg-evolving-table-schema.html) per aggiornare lo schema della tabella e le [query Spark](https://iceberg.apache.org/docs/latest/spark-ddl/#alter-table-sql-extensions) per aggiornare le partizioni.
------
#### [ AWS CLI ]
```
aws glue create-table \
--database-name iceberg-db \
--region us-west-2 \
--open-table-format-input '{
"IcebergInput": {
"MetadataOperation": "CREATE",
"Version": "2"
}
}' \
--table-input '{"Name":"test-iceberg-input-demo",
"TableType": "EXTERNAL_TABLE",
"StorageDescriptor":{
"Columns":[
{"Name":"col1", "Type":"int"},
{"Name":"col2", "Type":"int"},
{"Name":"col3", "Type":"string"}
],
"Location":"s3://DOC_EXAMPLE_BUCKET_ICEBERG/"
}
}'
```
------
# Ottimizzazione delle tabelle Iceberg
Lake Formation supporta diverse opzioni di ottimizzazione delle tabelle per migliorare la gestione e le prestazioni delle tabelle Apache Iceberg utilizzate dai motori AWS analitici e dai job ETL. Questi ottimizzatori offrono un utilizzo efficiente dello storage, prestazioni di query migliorate e una gestione efficace dei dati. In Lake Formation sono disponibili tre tipi di ottimizzatori di tabelle:
+ **Compattazione**: la compattazione dei dati compatta file di dati di piccole dimensioni per ridurre l'utilizzo dell'archiviazione e migliorare le prestazioni di lettura. I file di dati vengono uniti e riscritti per rimuovere i dati obsoleti e consolidare i dati frammentati in file più grandi ed efficienti. La compattazione può essere configurata per funzionare automaticamente o attivata manualmente secondo necessità.
+ **Conservazione degli snapshot**: gli snapshot sono versioni con data e ora di una tabella Iceberg. Le configurazioni di conservazione degli snapshot consentono ai clienti di stabilire per quanto tempo conservare gli snapshot e quanti snapshot conservare. La configurazione di un ottimizzatore di conservazione degli snapshot può aiutare a gestire il sovraccarico di archiviazione rimuovendo gli snapshot più vecchi e non necessari e i relativi file sottostanti.
+ **Eliminazione di file orfani**: i file orfani sono file a cui non fanno più riferimento i metadati della tabella Iceberg. Questi file possono accumularsi nel tempo, soprattutto dopo operazioni come l'eliminazione di tabelle o i processi ETL non riusciti. L'abilitazione dell'eliminazione dei file orfani consente di AWS Glue identificare e rimuovere periodicamente questi file non necessari, liberando spazio di archiviazione.
Puoi abilitare o disabilitare gli ottimizzatori di compattazione, conservazione delle istantanee e eliminazione dei file orfani per le singole tabelle Iceberg nel Data Catalog utilizzando la console o le AWS Glue operazioni API. AWS CLI AWS Glue
Per ulteriori informazioni, consulta [Optimizing Iceberg](https://docs.aws.amazon.com/glue/latest/dg/table-optimizers.html) tables nella Developer Guide. AWS Glue
# Ricerca di tabelle
Puoi usare la AWS Lake Formation console per cercare le tabelle del Data Catalog per nome, posizione, database contenente e altro. I risultati della ricerca mostrano solo le tabelle per le quali disponi delle autorizzazioni Lake Formation.
**Per cercare tabelle (console)**
1. Accedi a Console di gestione AWS e apri la console Lake Formation all'indirizzo [https://console.aws.amazon.com/lakeformation/](https://console.aws.amazon.com/lakeformation/).
1. Nel pannello di navigazione, seleziona **Tabelle**.
1. Posiziona il cursore nel campo di ricerca nella parte superiore della pagina. Il campo ha il testo segnaposto *Trova tabella per proprietà.*
Viene visualizzato il menu **Proprietà**, che mostra le varie proprietà della tabella in base alle quali effettuare la ricerca.
![\[Il menu delle proprietà viene visualizzato dal campo di ricerca e contiene le seguenti voci: Nome, Classificazione, Database, Ubicazione, ID catalogo\]](http://docs.aws.amazon.com/it_it/lake-formation/latest/dg/images/search-for-tables.png)
1. Esegui una delle seguenti operazioni:
+ Ricerca per database contenente.
1. Scegli **Database** dal menu **Proprietà**, quindi scegli un database dal menu **Database** visualizzato oppure digita il nome del database e premi **Invio**.
Vengono elencate le tabelle per le quali disponi delle autorizzazioni nel database.
1. **(Facoltativo) Per restringere l'elenco a una singola tabella del database, posizionate nuovamente il cursore nel campo di ricerca, scegliete **Nome** dal menu **Proprietà** e scegliete il nome di una tabella dal menu **Tabelle** visualizzato oppure digitate un nome di tabella e premete Invio.**
Viene elencata la singola tabella e sia il nome del database che il nome della tabella vengono visualizzati come riquadri sotto il campo di ricerca.
![\[Sotto il campo di ricerca ci sono due riquadri: uno etichettato Database, che include il nome del database selezionato, e uno etichettato Table, che include il nome della tabella selezionata. A destra dei riquadri c'è un pulsante Cancella filtro.\]](http://docs.aws.amazon.com/it_it/lake-formation/latest/dg/images/search-for-tables-with-filter.png)
Per regolare il filtro, chiudi uno dei riquadri o scegli **Cancella filtro**.
+ Cerca per altre proprietà.
1. Scegliete una proprietà di ricerca dal menu **Proprietà**.
**Per eseguire la ricerca in base all'ID AWS dell'account, scegliete **ID catalogo** dal menu **Proprietà**, immettete un ID AWS account valido (ad esempio, 111122223333) e premete Invio.**
Per effettuare una ricerca per località, scegli **Posizione** dal menu **Proprietà** e seleziona una località dal menu **Posizioni** visualizzato. Vengono restituite tutte le tabelle nella posizione principale della posizione selezionata (ad esempio, Amazon S3).
**Ricerca nelle tabelle utilizzando AWS CLI**
+ L'esempio seguente mostra come eseguire una ricerca parziale. Il `--search-text` parametro consente di cercare tabelle che contengono il testo specificato nei relativi metadati. In questo caso, restituisce tutte le tabelle che contengono «cliente» nel nome, nella descrizione o in altri campi di metadati.
```
aws glue search-tables
--search-text "customer"
--region Regione AWS
--max-results 10
--sort-criteria "FieldName=Name,Sort=ASC"
```
# Condivisione di tabelle e database del Data Catalog tra più account AWS
Puoi condividere le risorse del Data Catalog (database e tabelle) con AWS account esterni concedendo le autorizzazioni di Lake Formation sulle risorse agli account esterni. Gli utenti possono quindi eseguire query e lavori che uniscono e interrogano tabelle su più account. Con alcune restrizioni, quando condividi una risorsa del Catalogo dati con un altro account, i responsabili di quell'account possono utilizzare quella risorsa come se la risorsa fosse nel loro Catalogo dati.
Non condividi le risorse con responsabili specifici negli AWS account esterni, ma con un account o un'organizzazione. AWS Quando condividi una risorsa con un' AWS organizzazione, la condividi con tutti gli account a tutti i livelli dell'organizzazione. L'amministratore del data lake di ogni account esterno deve quindi concedere le autorizzazioni sulle risorse condivise ai responsabili del proprio account.
Per ulteriori informazioni, consultare [Condivisione dei dati tra account in Lake Formation](cross-account-permissions.md) e [Concessione delle autorizzazioni per le risorse del Data Catalog](granting-catalog-permissions.md).
**Consulta anche:**
[Accesso e visualizzazione di tabelle e database di Data Catalog condivisi](viewing-shared-resources.md)
[Prerequisiti](cross-account-prereqs.md)
# AWS Glue Data Catalog Viste dell'edificio
In AWS Glue Data Catalog, una *vista* è una tabella virtuale in cui i contenuti sono definiti da una query SQL che fa riferimento a una o più tabelle. Puoi creare una vista del catalogo dati che faccia riferimento a un massimo di 10 tabelle utilizzando editor SQL per Amazon Athena, Amazon Redshift o Apache Spark utilizzando EMR Serverless o la versione 5.0. AWS Glue Le tabelle di riferimento sottostanti per una vista possono appartenere allo stesso database o a database diversi all'interno dello stesso Data Catalog. Account AWS
Puoi fare riferimento a AWS Glue tabelle e tabelle standard in formati di tabelle aperte (OTF) come [Apache Hudi](https://hudi.incubator.apache.org/), Linux Foundation [Delta Lake](https://delta.io/) e [Apache Iceberg](https://iceberg.apache.org/), con i dati sottostanti archiviati in posizioni Amazon S3 registrati con. AWS Lake Formation Inoltre, puoi creare viste da tabelle federate da condivisioni di dati Amazon Redshift condivise con Lake Formation.
## Differenziazione delle viste del Data Catalog da altri tipi di visualizzazione
Le visualizzazioni del catalogo dati sono diverse da quelle di Apache Hive, Apache Spark e Amazon Athena. La visualizzazione Data Catalog è una funzionalità nativa di AWS Glue Data Catalog, ed è una visualizzazione multidialettale creata da un definitore. Puoi creare una vista del catalogo dati utilizzando uno dei servizi di analisi supportati, come Athena o Amazon Redshift Spectrum, e accedere alla stessa vista utilizzando altri servizi di analisi supportati. D'altra parte, le viste Apache Hive, Apache Spark e Athena vengono create indipendentemente in ogni servizio di analisi, come Athena e Amazon Redshift, e sono visibili e accessibili solo all'interno di tale servizio.
## Cos'è una vista più definita?
Una vista definente è una vista SQL che funziona in base alle autorizzazioni del principale che l'ha creata. Il ruolo definer dispone delle autorizzazioni necessarie per accedere alle tabelle di riferimento ed esegue l'istruzione SQL che definisce la vista. Il definitore crea la vista e la condivide con altri utenti tramite il controllo granulare degli AWS Lake Formation accessi.
Quando un utente interroga la vista del definitore, il motore di query utilizza le autorizzazioni del ruolo definer per accedere alle tabelle di riferimento sottostanti. Questo approccio consente agli utenti di interagire con la vista senza richiedere l'accesso diretto alle tabelle di origine, migliorando la sicurezza e semplificando la gestione dell'accesso ai dati.
Per configurare una vista di definizione, il ruolo IAM definer può trovarsi all'interno dello stesso AWS account delle tabelle di base o in un account diverso utilizzando ruoli di definizione tra account. Per ulteriori informazioni sulle autorizzazioni richieste per il ruolo definer, vedere. [Prerequisiti per la creazione di viste](views-prereqs.md)
## Un framework per visualizzazioni multidialettali
Il Data Catalog supporta la creazione di viste utilizzando più dialetti SQL (Structured Query Language). SQL è un linguaggio utilizzato per archiviare ed elaborare informazioni in un database relazionale e ogni motore AWS analitico utilizza la propria variante di SQL, o dialetto SQL.
È possibile creare una visualizzazione del catalogo dati in un dialetto SQL utilizzando uno dei motori di query di analisi supportati. Successivamente, puoi aggiornare la vista utilizzando l'`ALTER VIEW`istruzione in un dialetto SQL diverso all'interno di qualsiasi altro motore di analisi supportato. Tuttavia, ogni dialetto deve fare riferimento allo stesso set di tabelle, colonne e tipi di dati.
È possibile accedere ai diversi dialetti disponibili per la visualizzazione utilizzando l'`GetTable`API AWS CLI e AWS la console. Pertanto, la visualizzazione del catalogo dati è visibile e disponibile per le query su diversi motori di analisi supportati.
Definendo uno schema di visualizzazione e un oggetto di metadati comuni che è possibile interrogare da più motori, le viste del catalogo dati consentono di utilizzare viste uniformi su tutto il data lake.
Per maggiori dettagli su come viene risolto lo schema per ogni dialetto, consulta il [link al riferimento all'API](). Per maggiori dettagli sulle regole di abbinamento per i diversi tipi, consulta il [collegamento alla sezione pertinente nel documento API]().
## Integrazione con le autorizzazioni di Lake Formation
Puoi utilizzarlo AWS Lake Formation per centralizzare la gestione delle autorizzazioni sulle AWS Glue Data Catalog visualizzazioni per gli utenti. È possibile concedere autorizzazioni dettagliate per le viste del Data Catalog utilizzando il metodo delle risorse denominato o i tag LF e condividerle tra organizzazioni e unità organizzative. Account AWS AWS Puoi anche condividere e accedere alle viste del Data Catalog utilizzando i link alle risorse. Regioni AWS Ciò consente agli utenti di fornire l'accesso ai dati senza duplicare l'origine dei dati e condividere le tabelle sottostanti.
L'istruzione `CREATE VIEW` DDL di una vista Data Catalog può fare riferimento alle AWS Glue tabelle e alle tabelle standard in formati di tabelle aperte (OTF) come Hudi, Delta Lake e Iceberg con dati sottostanti archiviati in posizioni Amazon S3 registrate con Lake Formation, nonché alle tabelle federate del datashare Amazon Redshift condivise con Lake Formation. Le tabelle possono essere di qualsiasi formato di file purché il motore utilizzato per interrogare la vista supporti tale formato. È inoltre possibile fare riferimento alle funzioni integrate del motore su cui viene eseguito, ma potrebbero non essere consentite altre risorse specifiche del motore. Per ulteriori dettagli, consulta [Visualizzazioni, considerazioni e limitazioni di Data Catalog](views-notes.md).
## Casi d’uso
Di seguito sono riportati i casi d'uso importanti per le visualizzazioni del catalogo dati:
+ Crea e gestisci le autorizzazioni su uno schema a visualizzazione singola. Questo ti aiuta a evitare il rischio di autorizzazioni incoerenti su viste duplicate create in più motori.
+ Concedi le autorizzazioni agli utenti per una vista che fa riferimento a più tabelle senza concedere le autorizzazioni direttamente sulle tabelle di riferimento sottostanti.
+ Ottieni il filtraggio a livello di riga sulle tabelle utilizzando i tag LF (dove i tag LF si estendono a cascata solo fino al livello delle colonne) applicando i tag LF alle viste e concedendo autorizzazioni basate sui tag LF agli utenti.
## Servizi di analisi supportati per le visualizzazioni AWS
I seguenti servizi AWS di analisi supportano la creazione di viste del catalogo dati:
+ Amazon Redshift
+ Amazon Athena versione 3
+ Apache Spark su EMR Serverless
+ Apache Spark nella versione 5.0 AWS Glue
## Risorse aggiuntive
Puoi saperne di più sul Data Catalog in questa guida e utilizzare le seguenti risorse:
Il video seguente mostra come creare viste e interrogarle da Athena e Amazon Redshift.
[](http://www.youtube.com/watch?v=https://www.youtube.com/embed/rFO2OoxVYxE?si=Z0qsyuvTp2ZJg-PL)
**Topics**
+ [Differenziazione delle viste del Data Catalog da altri tipi di visualizzazione](#diff-views)
+ [Cos'è una vista più definita?](#definer-view)
+ [Un framework per visualizzazioni multidialettali](#multi-dialect)
+ [Integrazione con le autorizzazioni di Lake Formation](#lf-view-integ)
+ [Casi d’uso](#views-use-cases)
+ [Servizi di analisi supportati per le visualizzazioni AWS](#views-supported-engines)
+ [Risorse aggiuntive](#views-addtional-resources)
+ [Prerequisiti per la creazione di viste](views-prereqs.md)
+ [Creazione di viste del catalogo dati utilizzando istruzioni DDL](create-views.md)
+ [Creazione di viste del catalogo dati utilizzando AWS Glue APIs](views-api-usage.md)
+ [Concessione delle autorizzazioni per le visualizzazioni del catalogo dati](grant-perms-views.md)
+ [Viste materializzate](materialized-views.md)
# Prerequisiti per la creazione di viste
+ Per creare viste in Data Catalog, devi registrare le posizioni dei dati Amazon S3 sottostanti delle tabelle di riferimento con Lake Formation. Per i dettagli sulla registrazione dei dati con Lake Formation, vedere[Aggiungere una posizione Amazon S3 al tuo data lake](register-data-lake.md).
+ Solo i ruoli IAM possono creare viste del Data Catalog. Le altre identità IAM non possono creare viste del catalogo dati.
+ Il ruolo IAM che definisce la vista deve disporre delle seguenti autorizzazioni:
+ `SELECT`Autorizzazione Lake Formation con `Grantable` opzione su tutte le tabelle di riferimento, incluse tutte le colonne.
+ `CREATE_TABLE`Autorizzazione Lake Formation sul database di destinazione in cui vengono create le viste.
+ Una politica di fiducia affinché la Lake Formation e AWS Glue i servizi assumano il ruolo.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Sid": "DataCatalogViewDefinerAssumeRole1",
"Effect": "Allow",
"Principal": {
"Service": [
"glue.amazonaws.com",
"lakeformation.amazonaws.com"
]
},
"Action": "sts:AssumeRole"
}
]
}
```
------
+ Lo scopo: PassRole autorizzazione per AWS Glue e Lake Formation.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Sid": "DataCatalogViewDefinerPassRole1",
"Action": [
"iam:PassRole"
],
"Effect": "Allow",
"Resource": "*",
"Condition": {
"StringEquals": {
"iam:PassedToService": [
"glue.amazonaws.com",
"lakeformation.amazonaws.com"
]
}
}
}
]
}
```
------
+ AWS Glue e autorizzazioni Lake Formation.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"Glue:GetDatabase",
"Glue:GetDatabases",
"Glue:CreateTable",
"Glue:GetTable",
"Glue:GetTables",
"Glue:BatchGetPartition",
"Glue:GetPartitions",
"Glue:GetPartition",
"Glue:GetTableVersion",
"Glue:GetTableVersions",
"Glue:PassConnection",
"lakeFormation:GetDataAccess"
],
"Resource": "*"
}
]
}
```
------
+ Non è possibile creare viste in un database che dispone `Super` o ha `ALL` l'autorizzazione concessa al `IAMAllowedPrincipals` gruppo. Puoi revocare l'`Super`autorizzazione per il `IAMAllowedPrincipals` gruppo su un database[Passaggio 4: Passa i tuoi archivi dati al modello di autorizzazioni Lake Formation](upgrade-glue-lake-formation.md#upgrade-glue-lake-formation-step4), vedere o creare un nuovo database con la casella **Usa solo il controllo di accesso IAM per le nuove tabelle in questo database deselezionata in** **Autorizzazioni predefinite per le** tabelle appena create.
# Creazione di viste del catalogo dati utilizzando istruzioni DDL
Puoi creare AWS Glue Data Catalog viste utilizzando gli editor SQL per Athena, Amazon Redshift e utilizzando/. AWS Glue APIs AWS CLI
Per creare una vista del catalogo dati utilizzando gli editor SQL, scegli Athena o Redshift Spectrum e crea la vista utilizzando `CREATE VIEW` un'istruzione DDL (Data Definition Language). Dopo aver creato una vista nel dialetto del primo motore, puoi utilizzare un'istruzione `ALTER VIEW` DDL del secondo motore per aggiungere i dialetti aggiuntivi.
Quando si definiscono le viste, è importante considerare quanto segue:
+ **Definizione di viste multidialettali**: quando si definisce una vista con più dialetti, gli schemi dei diversi dialetti devono corrispondere. Ogni dialetto SQL avrà una specifica sintattica leggermente diversa. La sintassi della query che definisce la visualizzazione del catalogo dati dovrebbe corrispondere esattamente allo stesso elenco di colonne, inclusi sia i tipi che i nomi, in tutti i dialetti. Queste informazioni vengono memorizzate nella `StorageDescriptor` vista. I dialetti devono inoltre fare riferimento agli stessi oggetti della tabella sottostanti del Data Catalog.
Per aggiungere un altro dialetto a una vista utilizzando DDL, puoi usare l'istruzione. `ALTER VIEW` Se un'`ALTER VIEW`istruzione tenta di aggiornare la definizione della vista, ad esempio modificando il descrittore di archiviazione o le tabelle sottostanti della vista, l'istruzione restituisce un errore che dice «Input and existing storage descriptor mismatch». È possibile utilizzare le operazioni SQL cast per garantire che i tipi di colonne di visualizzazione corrispondano.
+ **Aggiornamento di una vista**: per aggiornare la vista, puoi utilizzare l'`UpdateTable`API. Se aggiorni la vista senza corrispondere ai descrittori di archiviazione o alle tabelle di riferimento, puoi fornire il `FORCE` flag (consulta la documentazione SQL del motore per la sintassi). Dopo un aggiornamento forzato, la visualizzazione assumerà le tabelle forzate `StorageDescriptor` e di riferimento. Qualsiasi ulteriore `ALTER VIEW` DDL deve corrispondere ai valori modificati. Una vista che è stata aggiornata per includere dialetti incompatibili avrà lo stato «Stale». Lo stato della vista è visibile nella console Lake Formation e utilizzando l'`GetTable`operazione.
+ **Riferimento a un tipo di colonna varchar come stringa: non è possibile inserire un** tipo di colonna varchar di Redshift Spectrum in una stringa. Se viene creata una vista in Redshift Spectrum con un tipo di colonna varchar e un dialetto successivo tenta di fare riferimento a quel campo come una stringa, il Data Catalog la tratterà come stringa senza la necessità del flag. `FORCE`
+ **Trattamento di campi di tipo complesso**: Amazon Redshift tratta tutti i tipi complessi come tipi [SUPER mentre](https://docs.aws.amazon.com/redshift/latest/dg/r_SUPER_type.html) Athena specifica il tipo complesso. Se una vista ha un campo `SUPER` di tipo e un altro motore fa riferimento a quella colonna come a un particolare tipo complesso, ad esempio struct (`>`), il Data Catalog presume che il campo sia il tipo complesso specifico e lo utilizza nel descrittore di archiviazione, senza richiedere il flag. `Force`
Per ulteriori informazioni sulla sintassi per la creazione e la gestione delle viste del catalogo dati, vedi:
+ [Utilizzo delle AWS Glue Data Catalog visualizzazioni](https://docs.aws.amazon.com/athena/latest/ug/views-glue.html) nella Guida per l'utente di Amazon Athena.
+ [Glue Data Catalog visualizza la sintassi delle query](https://docs.aws.amazon.com/athena/latest/ug/views-glue-ddl.html) nella Guida per l'utente di Amazon Athena.
+ [Creazione di viste AWS Glue Data Catalog nella](https://docs.aws.amazon.com/redshift/latest/dg/data-catalog-views-overview.html) Amazon Redshift Database Developer Guide.
Per ulteriori informazioni sui comandi SQL relativi alle viste nel Catalogo dati, consulta [CREATE EXTERNAL VIEW](https://docs.aws.amazon.com/redshift/latest/dg/r_CREATE_EXTERNAL_VIEW.html), [ALTER EXTERNAL VIEW](https://docs.aws.amazon.com/redshift/latest/dg/r_ALTER_EXTERNAL_VIEW.html) e [DROP EXTERNAL VIEW](https://docs.aws.amazon.com/redshift/latest/dg/r_DROP_EXTERNAL_VIEW.html).
Dopo aver creato una vista Data Catalog, i dettagli della vista sono disponibili nella console Lake Formation.
1. Scegli **Views** in Data Catalog nella console Lake Formation.
1. Nella pagina delle visualizzazioni viene visualizzato un elenco delle viste disponibili.
1. Scegliete una vista dall'elenco e la pagina dei dettagli mostra gli attributi della vista.
![\[La sezione inferiore contiene cinque schede disposte orizzontalmente, in cui ogni scheda include le informazioni corrispondenti.\]](http://docs.aws.amazon.com/it_it/lake-formation/latest/dg/images/view-definition.png)
Schema
Scegliete una `Column` riga e selezionate **Modifica tag LF per aggiornare i valori dei tag** o assegnare nuovi tag LF.
Definizioni SQL
È possibile visualizzare un elenco di definizioni SQL disponibili. Seleziona **Aggiungi definizione SQL** e scegli un motore di query per aggiungere una definizione SQL. Scegli un motore di query (Athena o Amazon Redshift) sotto `Edit definition` la colonna per aggiornare una definizione SQL.
Tag LF
Scegliete **Modifica tag LF** per modificare i valori di un tag o assegnare nuovi tag. È possibile utilizzare i tag LF per concedere autorizzazioni sulle viste.
Accesso multi-account
Puoi vedere un elenco di Account AWS organizzazioni e unità organizzative (OUs) con cui hai condiviso la visualizzazione del catalogo dati.
Tabelle sottostanti
Le tabelle sottostanti a cui si fa riferimento nella definizione SQL utilizzata per creare la vista sono mostrate in questa scheda.
# Creazione di viste del catalogo dati utilizzando AWS Glue APIs
È possibile utilizzare AWS Glue [CreateTable](https://docs.aws.amazon.com/glue/latest/webapi/API_CreateTable.html)e [UpdateTable](https://docs.aws.amazon.com/glue/latest/webapi/API_UpdateTable.html) APIs creare e aggiornare le viste nel Data Catalog. Le `UpdateTable` operazioni `CreateTable` and hanno una nuova `TableInput` struttura`ViewDefinition`, mentre,`SearchTables`,,`GetTable`, `GetTables``GetTableVersion`, `GetTableVersions` le operazioni forniscono la `ViewDefinition` sintassi di output per le viste. Inoltre, c'è un nuovo `Status` campo nell'output dell'`GetTable`API.
Sono disponibili due nuove AWS Glue connessioni per la convalida del dialetto SQL per ogni motore di query supportato Amazon Athena e Amazon Redshift.
Le `CreateTable` e `UpdateTable` APIs sono asincrone se utilizzate con le viste. Quando questi APIs vengono chiamati con più dialetti SQL, la chiamata viene convalidata con ciascun motore per determinare se il dialetto può essere eseguito su quel motore e se lo schema risultante della vista di ciascun dialetto corrisponde. Il AWS Glue servizio utilizza queste connessioni per effettuare chiamate interne ai motori di analisi. Queste chiamate simulano ciò che fa il motore per convalidare se sul motore è stata eseguita una DDL `CREATE VIEW` o `ALTER VIEW` SQL.
Se l'SQL fornito è valido e gli schemi corrispondono tra i dialetti di visualizzazione, l' AWS Glue API esegue il commit atomico del risultato. Atomicity consente di creare o modificare viste con più dialetti senza tempi di inattività.
**Topics**
+ [Creazione di connessioni per AWS Glue convalidare lo stato](views-api-usage-connection.md)
+ [Convalida dello stato di generazione della vista](views-api-usage-get-table.md)
+ [Stati e operazioni asincroni](views-api-usage-async-states.md)
+ [Visualizza gli scenari di errore di creazione durante le operazioni asincrone](views-api-usage-errors.md)
# Creazione di connessioni per AWS Glue convalidare lo stato
Per creare o aggiornare una AWS Glue Data Catalog vista utilizzando le `UpdateTable` operazioni `CreateTable` or, devi creare un nuovo tipo di AWS Glue connessione per la convalida e fornirlo al motore di analisi supportato. Queste connessioni sono necessarie per utilizzare le viste del catalogo dati con Athena o Amazon Redshift. Puoi creare queste connessioni solo utilizzando AWS CLI AWS SDKs, o. AWS Glue APIs Non è possibile utilizzare il Console di gestione AWS per creare la AWS Glue connessione.
**Nota**
Se il ruolo view definer e il role calling `CreateTable` or `UpdateTable` sono diversi, entrambi richiedono l'`glue:PassConnection`autorizzazione nella dichiarazione sulla politica IAM.
Per ulteriori informazioni, consulta la documentazione [create-connection](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/glue/create-connection.html) AWS CLI .
**AWS CLI comando per creare una connessione**
Di seguito è riportato un AWS CLI comando per creare una connessione:
```
aws glue create-connection --region us-east-1
--endpoint-url https://glue.us-east-1.amazonaws.com
--cli-input-json file:///root/path/to/create-connection.json
```
**AWS CLI input JSON**
Per Amazon Redshift:
```
{
"CatalogId": "123456789012",
"ConnectionInput": {
"ConnectionType": "VIEW_VALIDATION_REDSHIFT",
"Name": "views-preview-cluster-connection-2",
"Description": "My first Amazon Redshift validation connection",
"ConnectionProperties": {
"DATABASE": "dev",
"CLUSTER_IDENTIFIER": "glue-data-catalog-views-preview-cluster"
}
}
}
```
Per Amazon Athena:
```
{
"CatalogId": "123456789012",
"ConnectionInput": {
"ConnectionType": "VIEW_VALIDATION_ATHENA",
"Name": "views-preview-cluster-connection-3",
"Description": "My first Amazon Athena validation connection",
"ConnectionProperties": {
"WORKGROUP_NAME": "workgroup-name"
}
}
}
```
# Convalida dello stato di generazione della vista
Quando si eseguono le `UpdateTable` operazioni `CreateTable` or, il `Status` campo per l'output dell'`GetTable`API mostra i dettagli dello stato di creazione della vista. Per `create` le richieste in cui la tabella non esiste già, AWS Glue crea una tabella vuota per la durata del processo asincrono. Durante la chiamata`GetTable`, è possibile passare un flag booleano opzionale`IncludeStatusDetails`, che mostra le informazioni diagnostiche sulla richiesta. In caso di errore, questo flag mostra un messaggio di errore con gli stati individuali di ogni dialetto.
Gli errori durante le operazioni di visualizzazione, creazione, lettura, aggiornamento ed eliminazione (CRUD) possono verificarsi durante l'elaborazione nel servizio AWS Glue/Lake Formation o durante la convalida SQL della visualizzazione in Amazon Redshift o Athena. Quando si verifica un errore durante la convalida in un motore, il AWS Glue servizio fornisce il messaggio di errore restituito dal motore.
**Campi di stato**
I seguenti sono i campi di stato:
+ Status: uno stato generico, che è agnostico per diversi tipi di lavori:
+ IN CODA
+ IN\$1PROGRESS
+ RIUSCITO
+ NON RIUSCITO
+ Azione: indica quale azione è stata richiamata sulla tabella, attualmente solo `CREATE` o quali `UPDATE` operazioni sono disponibili.
La distinzione tra `UPDATE` e `CREATE` operazioni è importante quando si lavora con le viste. Il tipo di operazione determina come procedere con l'interrogazione delle tabelle.
Un'`UPDATE`operazione indica che la tabella esiste già nel Data Catalog. In questo caso, puoi continuare a interrogare la tabella creata in precedenza senza problemi. D'altra parte, un'`CREATE `operazione indica che la tabella non è mai stata creata correttamente prima. Se una tabella è contrassegnata per`CREATE`, il tentativo di interrogarla avrà esito negativo perché la tabella non esiste ancora nel sistema. Pertanto, è essenziale identificare il tipo di operazione (UPDATE o CREATE) prima di tentare di interrogare una tabella.
+ RequestedBy — L'ARN dell'utente che ha richiesto la modifica asincrona.
+ UpdatedBy — L'ARN dell'utente che per ultimo ha modificato manualmente il processo di modifica asincrono, ad esempio richiedendo una cancellazione o una modifica.
+ **Errore: questo campo viene visualizzato solo quando lo stato è FAILED.** Si tratta di un messaggio di eccezione a livello principale. Potrebbero esserci errori diversi per ogni dialetto.
+ ErrorCode — Il tipo di eccezione.
+ ErrorMessage — una breve descrizione dell'eccezione.
+ RequestTime — una stringa di data in formato ISO 8601 che indica l'ora in cui è stata avviata la modifica.
+ UpdateTime — una stringa di data in formato ISO 8601 che indica l'ora dell'ultimo aggiornamento dello stato.
# Stati e operazioni asincroni
Quando si esegue una `glue:CreateTable` richiesta, inizia la creazione asincrona della vista del catalogo dati. Nelle sezioni seguenti, questo documento descrive una `Status` AWS Glue vista disponibile in una risposta. `glue:GetTable` Per brevità, questa sezione omette la risposta completa.
```
{
"Table": {
...
"Status": {
...
"Action": "CREATE",
"State": "QUEUED",
}
}
}
```
Entrambi gli attributi precedenti rappresentano importanti informazioni diagnostiche che indicano lo stato dell'operazione asincrona e le azioni che possono essere eseguite su questa vista. Di seguito sono riportati i possibili valori che questi attributi possono assumere.
1. `Status.Action`
1. CREATE
1. UPDATE
1. `Status.State`
1. IN CODA
1. IN\$1PROGRESS
1. RIUSCITO
1. NON RIUSCITO
È inoltre importante notare che alcuni aggiornamenti su una visualizzazione del catalogo dati non richiedono un'operazione asincrona. Ad esempio, si potrebbe voler aggiornare l'`Description`attributo della tabella. Poiché ciò non richiede alcuna operazione asincrona, i metadati della tabella risultanti non ne `Status` avranno e l'attributo lo sarà. `NULL`
```
{
"Table": {
...,
"Description": "I changed this attribute!"
}
}
```
Successivamente, questo argomento esplora in che modo le informazioni sullo stato di cui sopra possono influire sulle operazioni che possono essere eseguite su una vista. AWS Glue
**colla: CreateTable**
Non ci sono modifiche per questa API rispetto al modo in cui `glue:CreateTable` funziona per qualsiasi tabella Glue. `CreateTable`può essere chiamato per qualsiasi nome di tabella che non esista già.
**colla: UpdateTable**
Questa operazione non può essere eseguita su una AWS Glue vista che contiene le seguenti informazioni di stato:
1. Azione == CREATE e State == IN CODA
1. Azione == CREATE e State == IN\$1PROGRESS
1. Azione == CREATE e state == FALLITO
1. Azione == AGGIORNAMENTO e stato == IN CODA
1. Azione == AGGIORNAMENTO e stato == IN\$1PROGRESS
Per riassumere, è possibile aggiornare una vista del catalogo dati solo quando soddisfa i seguenti requisiti.
1. È stata creata con successo per la prima volta.
1. Azione == CREATE e State == SUCCESS
1. Ha raggiunto lo stato terminale dopo un'operazione di aggiornamento asincrona.
1. Azione == AGGIORNAMENTO e stato == SUCCESSO
1. Azione == AGGIORNAMENTO e stato == FALLITO
1. Ha un attributo di `NULL` stato come risultato di un aggiornamento sincrono.
**colla: DeleteTable**
Questa operazione non presenta modifiche rispetto al `glue:DeleteTable` funzionamento di qualsiasi AWS Glue tabella. È possibile eliminare una vista del catalogo dati indipendentemente dal suo stato.
**colla: GetTable**
Questa operazione non presenta modifiche rispetto al `glue:GetTable` funzionamento di qualsiasi AWS Glue tabella. Tuttavia, non è possibile interrogare una vista del catalogo dati dai motori di analisi finché non è stata creata correttamente per la prima volta. `Action == CREATE and State == SUCCESS`. Dopo aver creato correttamente una vista del catalogo dati per la prima volta, è possibile interrogare la vista indipendentemente dal suo stato.
**Nota**
Tutte le informazioni contenute in questa sezione si applicano a tutte le tabelle lette`GetTable`, APIs ad esempio`GetTables`, e`SearchTables`.
# Visualizza gli scenari di errore di creazione durante le operazioni asincrone
Gli esempi seguenti sono rappresentativi dei tipi di errori che possono derivare `CreateTable` o `UpdateTable` visualizzare le chiamate API. Non sono esaustivi in quanto la superficie di errore degli errori delle query SQL è piuttosto ampia.
## Scenario 1: errore di interrogazione su Amazon Redshift
La query fornita per Amazon Redshift include un nome di tabella con errori di ortografia che non può essere trovato nel Data Catalog durante la convalida. L'errore risultante viene mostrato nel `Status` campo della `GetTable` risposta della vista.
`GetTable`richiesta:
```
{
"CatalogId": "123456789012",
"DatabaseName": "async-view-test-db",
"TableInput": {
"Name": "view-athena-redshift-72",
"Description": "This is an atomic operation",
"StorageDescriptor": {
"Columns": [
{ "Name": "col1", "Type": "int" },
{ "Name": "col2", "Type": "string" },
{ "Name": "col3", "Type": "double" }
]
},
"ViewDefinition": {
"Definer": "arn:aws:iam::123456789012:role/GDCViewDefiner",
"SubObjects": [ "arn:aws:glue:us-east-1:123456789012:table/gdc-view-playground-db/table_1" ],
"Representations": [
{
"Dialect": "ATHENA",
"DialectVersion": "3",
"ViewOriginalText": "SELECT * FROM \"gdc-view-playground-db\".\"table_1\"",
"ValidationConnection": "athena-connection"
},
{
"Dialect": "REDSHIFT",
"DialectVersion": "1.0",
"ViewOriginalText": "SELECT * FROM \"gdc-view-playground-external-schema\".\"table__1\";",
"ValidationConnection": "redshift-connection"
}
]
}
}
}
```
`GetTable`risposta:
```
IncludeStatusDetails = FALSE
{
"Table": {
"Name": "view-athena-redshift-72",
"DatabaseName": "async-view-test-db",
"Description": "",
"CreateTime": "2024-07-11T11:39:19-07:00",
"UpdateTime": "2024-07-11T11:39:19-07:00",
"Retention": 0,
"ViewOriginalText": "",
"ViewExpandedText": "",
"TableType": "",
"CreatedBy": "arn:aws:iam::123456789012:user/zcaisse",
"IsRegisteredWithLakeFormation": false,
"CatalogId": "123456789012",
"IsRowFilteringEnabled": false,
"VersionId": "-1",
"DatabaseId": "",
"IsMultiDialectView": false,
"Status": {
"RequestedBy": "arn:aws:iam::123456789012:user/zcaisse",
"UpdatedBy": "arn:aws:iam::123456789012:user/zcaisse",
"RequestTime": "2024-07-11T11:39:19-07:00",
"UpdateTime": "2024-07-11T11:40:06-07:00",
"Action": "CREATE",
"State": "FAILED"
}
}
}
IncludeStatusDetails = TRUE
{
"Table": {
"Name": "view-athena-redshift-72",
"DatabaseName": "async-view-test-db",
"Description": "",
"CreateTime": "2024-07-11T11:39:19-07:00",
"UpdateTime": "2024-07-11T11:39:19-07:00",
"Retention": 0,
"ViewOriginalText": "",
"ViewExpandedText": "",
"TableType": "",
"CreatedBy": "arn:aws:iam::123456789012:user/zcaisse",
"IsRegisteredWithLakeFormation": false,
"CatalogId": "123456789012",
"IsRowFilteringEnabled": false,
"VersionId": "-1",
"DatabaseId": "",
"IsMultiDialectView": false,
"Status": {
"RequestedBy": "arn:aws:iam::123456789012:user/zcaisse",
"UpdatedBy": "arn:aws:iam::123456789012:user/zcaisse",
"RequestTime": "2024-07-11T11:39:19-07:00",
"UpdateTime": "2024-07-11T11:40:06-07:00",
"Action": "CREATE",
"State": "FAILED",
"Error": {
"ErrorCode": "QueryExecutionException",
"ErrorMessage": "Error received during view SQL validation using a connection: [Connection Name: redshift-connection | Query Execution Id: ddb711d3-2415-4aa9-b251-6a76ab4f41b1 | Timestamp: Thu Jul 11 18:39:37 UTC 2024]: Redshift returned error for the statement: ERROR: AwsClientException: EntityNotFoundException from glue - Entity Not Found"
},
"Details": {
"RequestedChange": {
"Name": "view-athena-redshift-72",
"DatabaseName": "async-view-test-db",
"Description": "This is an atomic operation",
"Retention": 0,
"StorageDescriptor": {
"Columns": [
{
"Name": "col1",
"Type": "int"
},
{
"Name": "col2",
"Type": "string"
},
{
"Name": "col3",
"Type": "double"
}
],
"Compressed": false,
"NumberOfBuckets": 0,
"SortColumns": [],
"StoredAsSubDirectories": false
},
"TableType": "VIRTUAL_VIEW",
"IsRegisteredWithLakeFormation": false,
"CatalogId": "123456789012",
"IsRowFilteringEnabled": false,
"VersionId": "-1",
"DatabaseId": "",
"ViewDefinition": {
"IsProtected": true,
"Definer": "arn:aws:iam::123456789012:role/GDCViewDefiner",
"SubObjects": [
"arn:aws:glue:us-east-1:123456789012:table/gdc-view-playground-db/table_1"
],
"Representations": [
{
"Dialect": "ATHENA",
"DialectVersion": "3",
"ViewOriginalText": "SELECT * FROM \"gdc-view-playground-db\".\"table_1\"",
"IsStale": false
},
{
"Dialect": "REDSHIFT",
"DialectVersion": "1.0",
"ViewOriginalText": "SELECT * FROM \"gdc-view-playground-external-schema\".\"table__1\";",
"IsStale": false
}
]
},
"IsMultiDialectView": true
},
"ViewValidations": [
{
"Dialect": "ATHENA",
"DialectVersion": "3",
"ViewValidationText": "SELECT * FROM \"gdc-view-playground-db\".\"table_1\"",
"UpdateTime": "2024-07-11T11:40:06-07:00",
"State": "SUCCESS"
},
{
"Dialect": "REDSHIFT",
"DialectVersion": "1.0",
"ViewValidationText": "SELECT * FROM \"gdc-view-playground-external-schema\".\"table__1\";",
"UpdateTime": "2024-07-11T11:39:37-07:00",
"State": "FAILED",
"Error": {
"ErrorCode": "QueryExecutionException",
"ErrorMessage": "Error received during view SQL validation using a connection: [Connection Name: redshift-connection | Query Execution Id: ddb711d3-2415-4aa9-b251-6a76ab4f41b1 | Timestamp: Thu
Jul 11 18:39:37 UTC 2024]: Redshift returned error for the statement: ERROR: AwsClientException: EntityNotFoundException from glue - Entity Not Found"
}
}
]
}
}
}
}
```
## Scenario 2: connessione Amazon Redshift non valida
La connessione Amazon Redshift nell'esempio seguente non è valida perché fa riferimento a un database Amazon Redshift che non esiste nell'endpoint fornito. cluster/serverless Amazon Redshift non è in grado di convalidare la vista e il `Status` campo nella `GetTable` risposta mostra l'errore (da Amazon `"State": "FAILED"` Redshift).
`GetTable`richiesta:
```
{
"CatalogId": "123456789012",
"DatabaseName": "async-view-test-db",
"TableInput": {
"Name": "view-athena-redshift-73",
"Description": "This is an atomic operation",
"StorageDescriptor": {
"Columns": [
{ "Name": "col1", "Type": "int" },
{ "Name": "col2", "Type": "string" },
{ "Name": "col3", "Type": "double" }
]
},
"ViewDefinition": {
"Definer": "arn:aws:iam::123456789012:role/GDCViewDefiner",
"SubObjects": [ "arn:aws:glue:us-east-1:123456789012:table/gdc-view-playground-db/table_1" ],
"Representations": [
{
"Dialect": "ATHENA",
"DialectVersion": "3",
"ViewOriginalText": "SELECT * FROM \"gdc-view-playground-db\".\"table_1\"",
"ValidationConnection": "athena-connection"
},
{
"Dialect": "REDSHIFT",
"DialectVersion": "1.0",
"ViewOriginalText": "SELECT * FROM \"gdc-view-playground-external-schema\".\"table_1\";",
"ValidationConnection": "redshift-connection-malformed"
}
]
}
}
}
```
`GetTable`risposta:
```
IncludeStatusDetails = FALSE
{
"Table": {
"Name": "view-athena-redshift-73",
"DatabaseName": "async-view-test-db",
"Description": "",
"CreateTime": "2024-07-11T11:43:27-07:00",
"UpdateTime": "2024-07-11T11:43:27-07:00",
"Retention": 0,
"ViewOriginalText": "",
"ViewExpandedText": "",
"TableType": "",
"CreatedBy": "arn:aws:iam::123456789012:user/zcaisse",
"IsRegisteredWithLakeFormation": false,
"CatalogId": "123456789012",
"IsRowFilteringEnabled": false,
"VersionId": "-1",
"DatabaseId": "",
"IsMultiDialectView": false,
"Status": {
"RequestedBy": "arn:aws:iam::123456789012:user/zcaisse",
"UpdatedBy": "arn:aws:iam::123456789012:user/zcaisse",
"RequestTime": "2024-07-11T11:43:27-07:00",
"UpdateTime": "2024-07-11T11:43:40-07:00",
"Action": "CREATE",
"State": "FAILED"
}
}
}
IncludeStatusDetails = TRUE
{
"Table": {
"Name": "view-athena-redshift-73",
"DatabaseName": "async-view-test-db",
"Description": "",
"CreateTime": "2024-07-11T11:43:27-07:00",
"UpdateTime": "2024-07-11T11:43:27-07:00",
"Retention": 0,
"ViewOriginalText": "",
"ViewExpandedText": "",
"TableType": "",
"CreatedBy": "arn:aws:iam::123456789012:user/zcaisse",
"IsRegisteredWithLakeFormation": false,
"CatalogId": "123456789012",
"IsRowFilteringEnabled": false,
"VersionId": "-1",
"DatabaseId": "",
"IsMultiDialectView": false,
"Status": {
"RequestedBy": "arn:aws:iam::123456789012:user/zcaisse",
"UpdatedBy": "arn:aws:iam::123456789012:user/zcaisse",
"RequestTime": "2024-07-11T11:43:27-07:00",
"UpdateTime": "2024-07-11T11:43:40-07:00",
"Action": "CREATE",
"State": "FAILED",
"Error": {
"ErrorCode": "QueryExecutionException",
"ErrorMessage": "Error received during view SQL validation using a connection: [Connection Name: redshift-connection-malformed | Query Execution Id: 69bfafd4-3d51-4cb0-9320-7ce5404b1809 | Timestamp: Thu Jul 11 18:43:38 UTC 2024]: Redshift returned error for the statement: FATAL: database \"devooo\" does not exist"
},
"Details": {
"RequestedChange": {
"Name": "view-athena-redshift-73",
"DatabaseName": "async-view-test-db",
"Description": "This is an atomic operation",
"Retention": 0,
"StorageDescriptor": {
"Columns": [
{
"Name": "col1",
"Type": "int"
},
{
"Name": "col2",
"Type": "string"
},
{
"Name": "col3",
"Type": "double"
}
],
"Compressed": false,
"NumberOfBuckets": 0,
"SortColumns": [],
"StoredAsSubDirectories": false
},
"TableType": "VIRTUAL_VIEW",
"IsRegisteredWithLakeFormation": false,
"CatalogId": "123456789012",
"IsRowFilteringEnabled": false,
"VersionId": "-1",
"DatabaseId": "",
"ViewDefinition": {
"IsProtected": true,
"Definer": "arn:aws:iam::123456789012:role/GDCViewDefiner",
"SubObjects": [
"arn:aws:glue:us-east-1:123456789012:table/gdc-view-playground-db/table_1"
],
"Representations": [
{
"Dialect": "ATHENA",
"DialectVersion": "3",
"ViewOriginalText": "SELECT * FROM \"gdc-view-playground-db\".\"table_1\"",
"IsStale": false
},
{
"Dialect": "REDSHIFT",
"DialectVersion": "1.0",
"ViewOriginalText": "SELECT * FROM \"gdc-view-playground-external-schema\".\"table_1\";",
"IsStale": false
}
]
},
"IsMultiDialectView": true
},
"ViewValidations": [
{
"Dialect": "ATHENA",
"DialectVersion": "3",
"ViewValidationText": "SELECT * FROM \"gdc-view-playground-db\".\"table_1\"",
"UpdateTime": "2024-07-11T11:43:40-07:00",
"State": "SUCCESS"
},
{
"Dialect": "REDSHIFT",
"DialectVersion": "1.0",
"ViewValidationText": "SELECT * FROM \"gdc-view-playground-external-schema\".\"table_1\";",
"UpdateTime": "2024-07-11T11:43:38-07:00",
"State": "FAILED",
"Error": {
"ErrorCode": "QueryExecutionException",
"ErrorMessage": "Error received during view SQL validation using a connection: [Connection Name: redshift-connection-malformed | Query Execution Id: 69bfafd4-3d51-4cb0-9320-7ce5404b1809 | Time
stamp: Thu Jul 11 18:43:38 UTC 2024]: Redshift returned error for the statement: FATAL: database \"devooo\" does not exist"
}
}
]
}
}
}
}
```
## Scenario 3: interrogazione Athena non riuscita
L'SQL per Athena qui non è valido perché la query digita erroneamente il nome del database. La convalida della query Athena rileva questo problema e l'errore risultante viene visualizzato attraverso l'`Status`oggetto in una chiamata. `GetTable`
`GetTable`richiesta:
```
{
"CatalogId": "123456789012",
"DatabaseName": "async-view-test-db",
"TableInput": {
"Name": "view-athena-redshift-70",
"Description": "This is an atomic operation",
"StorageDescriptor": {
"Columns": [
{ "Name": "col1", "Type": "int" },
{ "Name": "col2", "Type": "string" },
{ "Name": "col3", "Type": "double" }
]
},
"ViewDefinition": {
"Definer": "arn:aws:iam::123456789012:role/GDCViewDefiner",
"SubObjects": [ "arn:aws:glue:us-east-1:123456789012:table/gdc-view-playground-db/table_1" ],
"Representations": [
{
"Dialect": "ATHENA",
"DialectVersion": "3",
"ViewOriginalText": "SELECT * FROM \"gdc--view-playground-db\".\"table_1\"",
"ValidationConnection": "athena-connection"
},
{
"Dialect": "REDSHIFT",
"DialectVersion": "1.0",
"ViewOriginalText": "SELECT * FROM \"gdc-view-playground-external-schema\".\"table_1\";",
"ValidationConnection": "redshift-connection"
}
]
}
}
}
```
`GetTable`risposta:
```
IncludeStatusDetails = FALSE
{
"Table": {
"Name": "view-athena-redshift-70",
"DatabaseName": "async-view-test-db",
"Description": "",
"CreateTime": "2024-07-11T11:09:53-07:00",
"UpdateTime": "2024-07-11T11:09:53-07:00",
"Retention": 0,
"ViewOriginalText": "",
"ViewExpandedText": "",
"TableType": "",
"CreatedBy": "arn:aws:iam::123456789012:user/",
"IsRegisteredWithLakeFormation": false,
"CatalogId": "123456789012",
"IsRowFilteringEnabled": false,
"VersionId": "-1",
"DatabaseId": "",
"IsMultiDialectView": false,
"Status": {
"RequestedBy": "arn:aws:iam::123456789012:user/zcaisse",
"UpdatedBy": "arn:aws:iam::123456789012:user/zcaisse",
"RequestTime": "2024-07-11T11:09:54-07:00",
"UpdateTime": "2024-07-11T11:10:41-07:00",
"Action": "CREATE",
"State": "FAILED",
}
}
}
IncludeStatusDetails = TRUE
{
"Table": {
"Name": "view-athena-redshift-70",
"DatabaseName": "async-view-test-db",
"Description": "",
"CreateTime": "2024-07-11T11:09:53-07:00",
"UpdateTime": "2024-07-11T11:09:53-07:00",
"Retention": 0,
"ViewOriginalText": "",
"ViewExpandedText": "",
"TableType": "",
"CreatedBy": "arn:aws:iam::123456789012:user/zcaisse",
"IsRegisteredWithLakeFormation": false,
"CatalogId": "123456789012",
"IsRowFilteringEnabled": false,
"VersionId": "-1",
"DatabaseId": "",
"IsMultiDialectView": false,
"Status": {
"RequestedBy": "arn:aws:iam::123456789012:user/zcaisse",
"UpdatedBy": "arn:aws:iam::123456789012:user/zcaisse",
"RequestTime": "2024-07-11T11:09:54-07:00",
"UpdateTime": "2024-07-11T11:10:41-07:00",
"Action": "CREATE",
"State": "FAILED",
"Error": {
"ErrorCode": "QueryExecutionException",
"ErrorMessage": "Error received during view SQL validation using a connection: [Connection Name: athena-connection | Query Execution Id: d9bb1e6d-ce26-4b35-8276-8a199af966aa | Timestamp: Thu Jul 11 18:10:
41 UTC 2024]: Athena validation FAILED: {ErrorCategory: 2,ErrorType: 1301,Retryable: false,ErrorMessage: line 1:118: Schema 'gdc--view-playground-db' does not exist}"
},
"Details": {
"RequestedChange": {
"Name": "view-athena-redshift-70",
"DatabaseName": "async-view-test-db",
"Description": "This is an atomic operation",
"Retention": 0,
"StorageDescriptor": {
"Columns": [
{
"Name": "col1",
"Type": "int"
},
{
"Name": "col2",
"Type": "string"
},
{
"Name": "col3",
"Type": "double"
}
],
"Compressed": false,
"NumberOfBuckets": 0,
"SortColumns": [],
"StoredAsSubDirectories": false
},
"TableType": "VIRTUAL_VIEW",
"IsRegisteredWithLakeFormation": false,
"CatalogId": "123456789012",
"IsRowFilteringEnabled": false,
"VersionId": "-1",
"DatabaseId": "",
"ViewDefinition": {
"IsProtected": true,
"Definer": "arn:aws:iam::123456789012:role/GDCViewDefiner",
"SubObjects": [
"arn:aws:glue:us-east-1:123456789012:table/gdc-view-playground-db/table_1"
],
"Representations": [
{
"Dialect": "ATHENA",
"DialectVersion": "3",
"ViewOriginalText": "SELECT * FROM \"gdc--view-playground-db\".\"table_1\"",
"IsStale": false
},
{
"Dialect": "REDSHIFT",
"DialectVersion": "1.0",
"ViewOriginalText": "SELECT * FROM \"gdc-view-playground-external-schema\".\"table_1\";",
"IsStale": false
}
]
},
"IsMultiDialectView": true
},
"ViewValidations": [
{
"Dialect": "ATHENA",
"DialectVersion": "3",
"ViewValidationText": "SELECT * FROM \"gdc--view-playground-db\".\"table_1\"",
"UpdateTime": "2024-07-11T11:10:41-07:00",
"State": "FAILED",
"Error": {
"ErrorCode": "QueryExecutionException",
"ErrorMessage": "Error received during view SQL validation using a connection: [Connection Name: athena-connection | Query Execution Id: d9bb1e6d-ce26-4b35-8276-8a199af966aa | Timestamp: Thu J
ul 11 18:10:41 UTC 2024]: Athena validation FAILED: {ErrorCategory: 2,ErrorType: 1301,Retryable: false,ErrorMessage: line 1:118: Schema 'gdc--view-playground-db' does not exist}"
}
},
{
"Dialect": "REDSHIFT",
"DialectVersion": "1.0",
"ViewValidationText": "SELECT * FROM \"gdc-view-playground-external-schema\".\"table_1\";",
"UpdateTime": "2024-07-11T11:10:41-07:00",
"State": "SUCCESS"
}
]
}
}
}
}
```
## Scenario 4: descrittori di archiviazione non corrispondenti
L'SQL fornito per il dialetto Athena seleziona`col1`, `col2` mentre l'SQL per Redshift seleziona solo. `col1` Ciò porta a un errore di mancata corrispondenza del descrittore di archiviazione.
`GetTable`richiesta:
```
{
"CatalogId": "123456789012",
"DatabaseName": "async-view-test-db",
"TableInput": {
"Name": "view-athena-redshift-71",
"Description": "This is an atomic operation",
"StorageDescriptor": {
"Columns": [
{ "Name": "col1", "Type": "int" },
{ "Name": "col2", "Type": "string" },
{ "Name": "col3", "Type": "double" }
]
},
"ViewDefinition": {
"Definer": "arn:aws:iam::123456789012:role/GDCViewDefiner",
"SubObjects": [ "arn:aws:glue:us-east-1:123456789012:table/gdc-view-playground-db/table_1" ],
"Representations": [
{
"Dialect": "ATHENA",
"DialectVersion": "3",
"ViewOriginalText": "SELECT col1, col2 FROM \"gdc-view-playground-db\".\"table_1\"",
"ValidationConnection": "athena-connection"
},
{
"Dialect": "REDSHIFT",
"DialectVersion": "1.0",
"ViewOriginalText": "SELECT col1 FROM \"gdc-view-playground-external-schema\".\"table_1\";",
"ValidationConnection": "redshift-connection"
}
]
}
}
}
```
`GetTable`risposta:
```
IncludeStatusDetails = FALSE
{
"Table": {
"Name": "view-athena-redshift-71",
"DatabaseName": "async-view-test-db",
"Description": "",
"CreateTime": "2024-07-11T11:22:02-07:00",
"UpdateTime": "2024-07-11T11:22:02-07:00",
"Retention": 0,
"ViewOriginalText": "",
"ViewExpandedText": "",
"TableType": "",
"CreatedBy": "arn:aws:iam::123456789012:user/zcaisse",
"IsRegisteredWithLakeFormation": false,
"CatalogId": "123456789012",
"IsRowFilteringEnabled": false,
"VersionId": "-1",
"DatabaseId": "",
"IsMultiDialectView": false,
"Status": {
"RequestedBy": "arn:aws:iam::123456789012:user/zcaisse",
"UpdatedBy": "arn:aws:iam::123456789012:user/zcaisse",
"RequestTime": "2024-07-11T11:22:02-07:00",
"UpdateTime": "2024-07-11T11:23:19-07:00",
"Action": "CREATE",
"State": "FAILED"
}
}
}
IncludeStatusDetails = TRUE
{
"Table": {
"Name": "view-athena-redshift-71",
"DatabaseName": "async-view-test-db",
"Description": "",
"CreateTime": "2024-07-11T11:22:02-07:00",
"UpdateTime": "2024-07-11T11:22:02-07:00",
"Retention": 0,
"ViewOriginalText": "",
"ViewExpandedText": "",
"TableType": "",
"CreatedBy": "arn:aws:iam::123456789012:user/zcaisse",
"IsRegisteredWithLakeFormation": false,
"CatalogId": "123456789012",
"IsRowFilteringEnabled": false,
"VersionId": "-1",
"DatabaseId": "",
"IsMultiDialectView": false,
"Status": {
"RequestedBy": "arn:aws:iam::123456789012:user/zcaisse",
"UpdatedBy": "arn:aws:iam::123456789012:user/zcaisse",
"RequestTime": "2024-07-11T11:22:02-07:00",
"UpdateTime": "2024-07-11T11:23:19-07:00",
"Action": "CREATE",
"State": "FAILED",
"Error": {
"ErrorCode": "InvalidInputException",
"ErrorMessage": "Engine and existing storage descriptor mismatch"
},
"Details": {
"RequestedChange": {
"Name": "view-athena-redshift-71",
"DatabaseName": "async-view-test-db",
"Description": "This is an atomic operation",
"Retention": 0,
"StorageDescriptor": {
"Columns": [
{
"Name": "col1",
"Type": "int"
},
{
"Name": "col2",
"Type": "string"
},
{
"Name": "col3",
"Type": "double"
}
],
"Compressed": false,
"NumberOfBuckets": 0,
"SortColumns": [],
"StoredAsSubDirectories": false
},
"TableType": "VIRTUAL_VIEW",
"IsRegisteredWithLakeFormation": false,
"CatalogId": "123456789012",
"IsRowFilteringEnabled": false,
"VersionId": "-1",
"DatabaseId": "",
"ViewDefinition": {
"IsProtected": true,
"Definer": "arn:aws:iam::123456789012:role/GDCViewDefiner",
"SubObjects": [
"arn:aws:glue:us-east-1:123456789012:table/gdc-view-playground-db/table_1"
],
"Representations": [
{
"Dialect": "ATHENA",
"DialectVersion": "3",
"ViewOriginalText": "SELECT col1, col2 FROM \"gdc-view-playground-db\".\"table_1\"",
"IsStale": false
},
{
"Dialect": "REDSHIFT",
"DialectVersion": "1.0",
"ViewOriginalText": "SELECT col1 FROM \"gdc-view-playground-external-schema\".\"table_1\";",
"IsStale": false
}
]
},
"IsMultiDialectView": true
},
"ViewValidations": [
{
"Dialect": "ATHENA",
"DialectVersion": "3",
"ViewValidationText": "SELECT col1, col2 FROM \"gdc-view-playground-db\".\"table_1\"",
"UpdateTime": "2024-07-11T11:23:19-07:00",
"State": "FAILED",
"Error": {
"ErrorCode": "InvalidInputException",
"ErrorMessage": "Engine and existing storage descriptor mismatch"
}
},
{
"Dialect": "REDSHIFT",
"DialectVersion": "1.0",
"ViewValidationText": "SELECT col1 FROM \"gdc-view-playground-external-schema\".\"table_1\";",
"UpdateTime": "2024-07-11T11:22:49-07:00",
"State": "FAILED",
"Error": {
"ErrorCode": "InvalidInputException",
"ErrorMessage": "Engine and existing storage descriptor mismatch"
}
}
]
}
}
}
}
```
# Concessione delle autorizzazioni per le visualizzazioni del catalogo dati
Dopo aver creato le viste in AWS Glue Data Catalog, puoi concedere le autorizzazioni per le visualizzazioni del data lake ai responsabili di tutte Account AWS le organizzazioni e le unità organizzative. È possibile concedere le autorizzazioni utilizzando i tag LF o il metodo di risorsa denominato. Per ulteriori informazioni sull'etichettatura delle risorse, vedere. [Controllo degli accessi basato su tag Lake Formation](tag-based-access-control.md) Per ulteriori informazioni sulla concessione diretta delle autorizzazioni per le viste, consulta. [Concessione delle autorizzazioni sulle viste utilizzando il metodo di risorsa denominato](granting-view-permissions.md)
# Viste materializzate
**Topics**
+ [Differenziazione delle viste materializzate da altri tipi di viste](#materialized-views-differentiating)
+ [Casi d’uso](#materialized-views-use-cases)
+ [Concetti chiave](#materialized-views-key-concepts)
+ [Autorizzazioni per le viste materializzate](#materialized-views-permissions)
+ [Creazione e gestione di viste materializzate](#materialized-views-creating-managing)
+ [Archiviazione e accesso ai dati](#materialized-views-storage-access)
+ [AWS Lake Formation Integrazione con le autorizzazioni](#materialized-views-lake-formation)
+ [Monitoraggio e debug](#materialized-views-monitoring-debugging)
+ [Gestione dei processi di aggiornamento](#materialized-views-managing-refresh-jobs)
+ [Monitoraggio e risoluzione dei problemi](#materialized-views-monitoring-troubleshooting)
+ [Considerazioni e limitazioni](#materialized-views-considerations-limitations)
Nel AWS Glue Data Catalog, una vista materializzata è una tabella gestita che memorizza il risultato precalcolato di una query SQL in formato Apache Iceberg. A differenza delle viste standard del Data Catalog che eseguono la query ogni volta che vi si accede, le viste materializzate archiviano fisicamente i risultati della query e li aggiornano man mano che le tabelle di origine sottostanti cambiano. Puoi creare viste materializzate utilizzando Apache Spark versione 3.5.6\$1 in Amazon Athena, Amazon EMR o. AWS Glue
Le viste materializzate fanno riferimento alle tabelle Apache Iceberg registrate nel AWS Glue Data Catalog, con dati precalcolati archiviati come tabelle Apache Iceberg in bucket Amazon S3 Tables o bucket Amazon S3 per uso generico, rendendole accessibili da più motori di query tra cui Amazon Athena, Amazon Redshift e motori di terze parti compatibili con Iceberg.
## Differenziazione delle viste materializzate da altri tipi di viste
Le viste materializzate differiscono dalle viste AWS Glue Data Catalog, dalle viste Apache Spark e dalle viste Amazon Athena per alcuni aspetti fondamentali. Sebbene le viste del catalogo dati siano tabelle virtuali che eseguono la definizione della query SQL ogni volta che vi si accede, le viste materializzate archiviano fisicamente i risultati delle query precalcolate. Ciò elimina il calcolo ridondante e migliora significativamente le prestazioni delle query per le trasformazioni complesse a cui si accede di frequente.
Le viste materializzate differiscono anche dalle tradizionali pipeline di trasformazione dei dati create con AWS Glue ETL o job Spark personalizzati. Invece di scrivere codice personalizzato per gestire il rilevamento delle modifiche, gli aggiornamenti incrementali e l'orchestrazione del flusso di lavoro, definisci le viste materializzate utilizzando la sintassi SQL standard. Il AWS Glue Data Catalog monitora automaticamente le tabelle di origine, rileva le modifiche e aggiorna le viste materializzate utilizzando un'infrastruttura di elaborazione completamente gestita.
## Casi d’uso
Di seguito sono riportati importanti casi d'uso per le viste materializzate:
+ **Accelera le query analitiche complesse**: crea viste materializzate che precalcolano giunzioni, aggregazioni e funzioni di finestra costose. I motori Spark riscrivono automaticamente le query successive per utilizzare i risultati precalcolati, riducendo la latenza delle query e i costi di elaborazione.
+ **Semplifica le pipeline di trasformazione dei dati**: sostituisci i complessi job ETL che gestiscono il rilevamento delle modifiche, gli aggiornamenti incrementali e l'orchestrazione del flusso di lavoro con semplici definizioni di viste materializzate basate su SQL. Il Data Catalog gestisce automaticamente tutta la complessità operativa. AWS Glue
+ **Abilita l'analisi self-service con accesso regolamentato ai dati**: crea viste materializzate curate che trasformano i dati grezzi in set di dati pronti per l'uso. Concedi agli utenti l'accesso alle viste materializzate senza esporre le tabelle di origine sottostanti, semplificando la gestione della sicurezza e potenziando l'analisi self-service.
+ **Ottimizza la progettazione delle funzionalità per l'apprendimento automatico**: definisci viste materializzate che implementano le trasformazioni delle funzionalità per i modelli ML. La funzionalità di aggiornamento automatico assicura che gli archivi di funzionalità rimangano aggiornati man mano che i dati di origine si evolvono, mentre l'aggiornamento incrementale riduce al minimo i costi di elaborazione.
+ **Implementa una condivisione efficiente dei dati**: crea viste materializzate che filtrano e trasformano i dati per consumatori specifici. Condividi le viste materializzate tra account e aree geografiche utilizzando AWS Lake Formation, eliminando la necessità di duplicazione dei dati e mantenendo al contempo una governance centralizzata.
## Concetti chiave
### Aggiornamento automatico
L'aggiornamento automatico è una funzionalità che monitora continuamente le tabelle di origine e aggiorna le viste materializzate in base a una pianificazione definita dall'utente. Quando si crea una vista materializzata, è possibile specificare una frequenza di aggiornamento utilizzando una pianificazione basata sul tempo con intervalli frequenti fino a un'ora. Il AWS Glue Data Catalog utilizza l'infrastruttura di elaborazione Spark gestita per eseguire operazioni di aggiornamento in background, gestendo in modo trasparente tutti gli aspetti del rilevamento delle modifiche e degli aggiornamenti incrementali.
Quando i dati di origine cambiano tra gli intervalli di aggiornamento, la vista materializzata diventa temporaneamente obsoleta. Le query che accedono direttamente alla vista materializzata possono restituire risultati obsoleti fino al completamento del successivo aggiornamento pianificato. Per gli scenari che richiedono l'accesso immediato ai dati più recenti, è possibile eseguire un aggiornamento manuale utilizzando il comando SQL. `REFRESH MATERIALIZED VIEW`
### Aggiornamento incrementale
L'aggiornamento incrementale è una tecnica di ottimizzazione che elabora solo i dati modificati nelle tabelle di origine dall'ultimo aggiornamento, anziché ricalcolare l'intera vista materializzata. Il AWS Glue Data Catalog sfrutta il livello di metadati di Apache Iceberg per tracciare in modo efficiente le modifiche nelle tabelle di origine e determinare quali parti della vista materializzata richiedono aggiornamenti.
Questo approccio riduce in modo significativo i costi di elaborazione e la durata dell'aggiornamento rispetto alle operazioni di aggiornamento complete, in particolare per set di dati di grandi dimensioni in cui solo una piccola percentuale di dati cambia tra i cicli di aggiornamento. Il meccanismo di aggiornamento incrementale funziona automaticamente; non è necessario scrivere una logica personalizzata per rilevare o elaborare i dati modificati.
### Riscrittura automatica delle interrogazioni
La riscrittura automatica delle query è una funzionalità di ottimizzazione delle query disponibile nei motori Spark di Amazon Athena, Amazon EMR e. AWS Glue Quando esegui una query su tabelle di base, l'ottimizzatore Spark analizza il tuo piano di query e determina automaticamente se le viste materializzate disponibili possono soddisfare la query in modo più efficiente. Se esiste una vista materializzata adatta, l'ottimizzatore riscrive in modo trasparente la query per utilizzare i risultati precalcolati anziché elaborare le tabelle di base.
Questa ottimizzazione avviene senza richiedere alcuna modifica al codice dell'applicazione o alle istruzioni di query. L'ottimizzatore Spark assicura che la riscrittura automatica delle query si applichi solo quando la vista materializzata è attuale e può produrre risultati accurati. Se una vista materializzata è obsoleta o non soddisfa completamente i requisiti della query, l'ottimizzatore esegue il piano di query originale sulla base delle tabelle di base, dando priorità alla correttezza rispetto alle prestazioni.
### Visualizza il ruolo del definitore
Una vista materializzata funziona in base alle autorizzazioni del ruolo IAM che l'ha creata, noto come ruolo view definer. Il ruolo definer deve avere accesso in lettura a tutte le tabelle di base a cui si fa riferimento nella definizione della vista materializzata e creare i permessi per le tabelle sul database di destinazione. Quando il AWS Glue Data Catalog aggiorna una vista materializzata, assume il ruolo di definitore di accedere alle tabelle di origine e scrivere risultati aggiornati.
Questo modello di sicurezza consente di concedere agli utenti l'accesso alle viste materializzate senza concedere loro autorizzazioni dirette sulle tabelle di origine sottostanti. Se il ruolo View Definer perde l'accesso a qualsiasi tabella di base, le successive operazioni di aggiornamento avranno esito negativo fino al ripristino delle autorizzazioni.
## Autorizzazioni per le viste materializzate
Per creare e gestire le viste materializzate, è necessario configurare le autorizzazioni. AWS Lake Formation Il ruolo IAM che crea la vista materializzata (il ruolo definer) richiede autorizzazioni specifiche sulle tabelle di origine e sui database di destinazione.
### Autorizzazioni richieste per il ruolo di definitore
Il ruolo che definisce deve avere i seguenti permessi di Lake Formation:
+ Nelle tabelle di origine: autorizzazioni SELECT o ALL senza filtri di riga, colonna o cella
+ Sul database di destinazione: autorizzazione CREATE\$1TABLE
+ Sul AWS Glue Data Catalog e sulle autorizzazioni API GetTable CreateTable
Quando si crea una vista materializzata, l'ARN del ruolo definitore viene memorizzato nella definizione della vista. Il AWS Glue Data Catalog assume questo ruolo durante l'esecuzione di operazioni di aggiornamento automatico. Se il ruolo del definitore perde l'accesso alle tabelle di origine, le operazioni di aggiornamento avranno esito negativo fino al ripristino delle autorizzazioni.
### Autorizzazioni IAM per i lavori AWS Glue
Il ruolo IAM del tuo AWS Glue lavoro richiede le seguenti autorizzazioni:
```
{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"glue:GetCatalog",
"glue:GetCatalogs",
"glue:GetTable",
"glue:GetTables",
"glue:CreateTable",
"glue:UpdateTable",
"glue:DeleteTable",
"glue:GetDatabase",
"glue:GetDatabases",
"cloudwatch:PutMetricData"
],
"Resource": "*"
},
{
"Effect": "Allow",
"Action": [
"s3:GetObject",
"s3:PutObject",
"s3:DeleteObject"
],
"Resource": [
"arn:aws:s3:::amzn-s3-demo-bucket/*"
]
},
{
"Effect": "Allow",
"Action": [
"s3:ListBucket"
],
"Resource": [
"arn:aws:s3:::amzn-s3-demo-bucket"
]
},
{
"Effect": "Allow",
"Action": [
"logs:CreateLogGroup",
"logs:CreateLogStream",
"logs:PutLogEvents"
],
"Resource": [
"arn:aws:logs:*:*:*:/aws-glue/*"
]
},
{
"Effect": "Allow",
"Action": [
"lakeformation:GetDataAccess"
],
"Resource": "*"
}
]
}
```
Il ruolo che usi per l'aggiornamento automatico di Materialized View deve avere l'PassRole autorizzazione iam: sul ruolo.
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"iam:PassRole"
],
"Resource": [
"arn:aws:iam::111122223333:role/materialized-view-role-name"
]
}
]
}
```
Affinché Glue aggiorni automaticamente la vista materializzata, il ruolo deve inoltre avere la seguente politica di attendibilità che consenta al servizio di assumere il ruolo.
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Principal": {
"Service": "glue.amazonaws.com"
},
"Action": "sts:AssumeRole"
}
]
}
```
Se la vista materializzata è archiviata in S3 Tables Bucket, devi anche aggiungere la seguente autorizzazione al ruolo.
```
{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"s3tables:PutTableMaintenanceConfiguration"
],
"Resource": "arn:aws:s3tables:*:123456789012:*"
}
]
}
```
### Concessione dell'accesso alle viste materializzate
Per concedere ad altri utenti l'accesso all'interrogazione di una vista materializzata, utilizzare questa opzione AWS Lake Formation per concedere l'autorizzazione SELECT sulla tabella delle viste materializzate. Gli utenti possono interrogare la vista materializzata senza richiedere l'accesso diretto alle tabelle di origine sottostanti.
Per informazioni dettagliate sulla configurazione delle autorizzazioni di Lake Formation, consulta Concessione e revoca delle autorizzazioni sulle risorse di Data Catalog nella Developer Guide. AWS Lake Formation
## Creazione e gestione di viste materializzate
Puoi creare viste materializzate utilizzando l'`CREATE MATERIALIZED VIEW`istruzione SQL nei motori Spark. La definizione della vista specifica la query SQL che definisce la logica di trasformazione, il database di destinazione e il nome della tabella e la configurazione di aggiornamento opzionale. È possibile definire trasformazioni complesse tra cui aggregazioni, join tra più tabelle, filtri e funzioni di finestra.
```
CREATE MATERIALIZED VIEW sales_summary
AS
SELECT
region,
product_category,
SUM(sales_amount) as total_sales,
COUNT(DISTINCT customer_id) as unique_customers
FROM sales_transactions
WHERE transaction_date >= current_date - interval '90' day
GROUP BY region, product_category;
```
Per configurare l'aggiornamento automatico, includi la pianificazione dell'aggiornamento nella definizione della vista:
```
CREATE MATERIALIZED VIEW sales_summary
SCHEDULE REFRESH EVERY 1 HOUR
AS
SELECT region, product_category, SUM(sales_amount) as total_sales
FROM sales_transactions
GROUP BY region, product_category;
```
È possibile aggiornare manualmente una vista materializzata in qualsiasi momento utilizzando il comando: `REFRESH MATERIALIZED VIEW`
```
REFRESH MATERIALIZED VIEW sales_summary;
```
Per modificare la pianificazione di aggiornamento di una vista materializzata esistente, utilizza l'istruzione: `ALTER MATERIALIZED VIEW`
```
ALTER MATERIALIZED VIEW sales_summary
ADD SCHEDULE REFRESH EVERY 2 HOURS;
```
### Viste materializzate annidate
È possibile creare viste materializzate che fanno riferimento ad altre viste materializzate come tabelle di base, abilitando trasformazioni dei dati in più fasi. Quando si creano viste materializzate annidate, il AWS Glue Data Catalog tiene traccia delle dipendenze e propaga automaticamente gli aggiornamenti attraverso la gerarchia delle viste materializzate. Quando una vista materializzata di base viene aggiornata, tutte le viste materializzate a valle che dipendono da essa vengono aggiornate di conseguenza.
Questa funzionalità consente di scomporre trasformazioni complesse in fasi logiche, migliorando la manutenibilità e abilitando l'aggiornamento selettivo dei livelli di trasformazione in base ai requisiti di freschezza dei dati.
## Archiviazione e accesso ai dati
Le viste materializzate archiviano i risultati precalcolati come tabelle Apache Iceberg in bucket S3 Tables o bucket S3 per uso generico all'interno del tuo account. AWS Il AWS Glue Data Catalog gestisce tutti gli aspetti della manutenzione delle tabelle Iceberg, tra cui la compattazione e la conservazione delle istantanee, attraverso le funzionalità di ottimizzazione automatizzata di S3 Tables.
Poiché le viste materializzate vengono archiviate come tabelle Iceberg, puoi leggerle direttamente da qualsiasi motore compatibile con Iceberg, tra cui Amazon Athena, Amazon Redshift e piattaforme di analisi di terze parti. Questa accessibilità multi-motore garantisce che i dati precalcolati rimangano accessibili in tutto l'ecosistema di analisi senza duplicazione dei dati o conversione del formato.
## AWS Lake Formation Integrazione con le autorizzazioni
Puoi utilizzarlo AWS Lake Formation per gestire autorizzazioni granulari sulle viste materializzate. Il creatore della vista diventa automaticamente il proprietario della vista materializzata e può concedere le autorizzazioni ad altri utenti o ruoli utilizzando AWS Lake Formation il metodo named resource o i tag LF.
Quando concedi l'`SELECT`autorizzazione a un utente per una vista materializzata, quest'ultimo può interrogare i risultati precalcolati senza richiedere l'accesso alle tabelle di origine sottostanti. Questo modello di sicurezza semplifica la gestione dell'accesso ai dati e consente di implementare il principio del privilegio minimo, fornendo agli utenti l'accesso solo alle trasformazioni di dati specifiche di cui hanno bisogno.
È possibile condividere viste materializzate tra AWS account, AWS organizzazioni e unità organizzative utilizzando le funzionalità di condivisione tra account AWS Lake Formation di cui dispone. È inoltre possibile accedere alle viste materializzate in tutte AWS le regioni utilizzando collegamenti alle risorse, abilitando una governance centralizzata dei dati con accesso distribuito ai dati.
## Monitoraggio e debug
Il AWS Glue Data Catalog pubblica tutte le operazioni di aggiornamento delle viste materializzate e le metriche associate su Amazon. CloudWatch Puoi monitorare l'ora di inizio dell'aggiornamento, l'ora di fine, la durata, il volume di dati elaborati e lo stato dell'aggiornamento tramite metriche. CloudWatch Quando le operazioni di aggiornamento falliscono, i messaggi di errore e le informazioni di diagnostica vengono acquisiti nei registri. CloudWatch
È possibile impostare CloudWatch allarmi per ricevere notifiche quando i processi di aggiornamento superano la durata prevista o falliscono ripetutamente. Il AWS Glue Data Catalog pubblica anche eventi di modifica in caso di esecuzioni di aggiornamento riuscite e non riuscite, consentendoti di integrare le operazioni di visualizzazione materializzata in un'automazione più ampia del flusso di lavoro.
Per verificare lo stato corrente di una vista materializzata, utilizza il comando `DESCRIBE MATERIALIZED VIEW` SQL, che restituisce i metadati tra cui lo stato di inattività, il timestamp dell'ultimo aggiornamento e la configurazione della pianificazione dell'aggiornamento.
## Gestione dei processi di aggiornamento
### Avvio di un aggiornamento manuale
Attiva un aggiornamento immediato al di fuori dell'intervallo pianificato.
Autorizzazione richiesta: AWS le credenziali utilizzate per effettuare la chiamata API devono disporre dell'`glue:GetTable`autorizzazione per la vista materializzata.
Per S3 Tables Catalog:
```
aws glue start-materialized-view-refresh-task-run \
--catalog-id :s3tablescatalog/ \
--database-name \
--table-name
```
Per Root Catalog:
```
aws glue start-materialized-view-refresh-task-run \
--catalog-id \
--database-name \
--table-name
```
### Verifica dello stato di aggiornamento
Ottieni lo stato di un processo di aggiornamento specifico:
```
aws glue get-materialized-view-refresh-task-run \
--catalog-id \
--materialized-view-refresh-task-run-id
```
### Cronologia degli aggiornamenti degli elenchi
Visualizza tutti i lavori di aggiornamento per una vista materializzata:
```
aws glue list-materialized-view-refresh-task-runs \
--catalog-id \
--database-name \
--table-name
```
**Nota**
Utilizzare `:s3tablescatalog/` per le tabelle S3 o `` per il catalogo principale.
### Interruzione di un aggiornamento in esecuzione
Annullare un processo di aggiornamento in corso:
```
aws glue stop-materialized-view-refresh-task-run \
--catalog-id \
--database-name \
--table-name
```
## Monitoraggio e risoluzione dei problemi
Esistono tre modi per monitorare i processi di aggiornamento delle viste materializzate:
### CloudWatch Metriche
Visualizza le metriche aggregate per tutti i tuoi lavori di aggiornamento delle viste materializzate in: CloudWatch
Metriche disponibili:
+ AWS/Namespace Glue con dimensioni:
+ CatalogId: il tuo identificatore del catalogo
+ DatabaseName: database contenente la vista materializzata
+ TableName: nome della vista materializzata
+ TaskType: Imposta su "» MaterializedViewRefresh
Visualizzazione in console:
1. Vai a CloudWatch Console → Metriche
1. Seleziona lo spazio dei AWS nomi /Glue
1. Filtra per dimensioni: CatalogId,,, DatabaseName TableName TaskType
1. Visualizza le metriche relative al successo, al fallimento e alla durata del lavoro
Esempio di interrogazione CloudWatch sulle metriche:
```
{AWS/Glue,CatalogId,DatabaseName,TableName,TaskType} MaterializedViewRefresh
```
Usando AWS CLI:
```
aws cloudwatch get-metric-statistics \
--namespace AWS/Glue \
--metric-name \
--dimensions Name=CatalogId,Value= \
Name=DatabaseName,Value= \
Name=TableName,Value= \
Name=TaskType,Value=MaterializedViewRefresh \
--start-time \
--end-time \
--period 3600 \
--statistics Sum \
--region
```
### CloudWatch Registri
Visualizza i registri di esecuzione dettagliati per le singole operazioni di aggiornamento:
Gruppo di log: `/aws-glue/materialized-views/`
``Dov'è un UUID (ad esempio, abc12345-def6-7890-ghij-klmnopqrstuv).
Visualizzazione dei registri:
```
# List log streams for a task run
aws logs describe-log-streams \
--log-group-name /aws-glue/materialized-views/ \
--region
# Get log events
aws logs get-log-events \
--log-group-name /aws-glue/materialized-views/ \
--log-stream-name \
--region
```
Nella CloudWatch console:
1. Vai a CloudWatch → Gruppi di log
1. Cerca /aws-glue/materialized-views/
1. Seleziona il gruppo di log con il tuo ID di esecuzione dell'attività
1. Visualizza i log di esecuzione dettagliati, gli errori e l'output del job Spark
### Notifications
Iscriviti agli eventi per ricevere notifiche in tempo reale sulle modifiche allo stato del processo di aggiornamento:
Tipi di eventi disponibili:
+ Attività di aggiornamento di Glue Materialized View iniziata
+ Attività di aggiornamento di Glue Materialized View riuscita
+ Task di aggiornamento di Glue Materialized View non riuscita
+ Errore di invocazione dell'aggiornamento automatico di Glue Materialized View
Creazione di una regola:
```
aws events put-rule \
--name materialized-view-refresh-notifications \
--event-pattern '{
"source": ["aws.glue"],
"detail-type": [
"Glue Materialized View Refresh Task Started",
"Glue Materialized View Refresh Task Succeeded",
"Glue Materialized View Refresh Task Failed",
"Glue Materialized View Auto-Refresh Invocation Failure"
]
}' \
--region
```
Aggiungere una destinazione (ad esempio, argomento SNS):
```
aws events put-targets \
--rule materialized-view-refresh-notifications \
--targets "Id"="1","Arn"="arn:aws:sns:::" \
--region
```
### Visualizzazione dello stato di aggiornamento
Controlla lo stato dei tuoi lavori di aggiornamento delle viste materializzate utilizzando l'API: AWS Glue
```
aws glue get-materialized-view-refresh-task-run \
--catalog-id \
--materialized-view-refresh-task-run-id \
--region
```
Oppure elenca tutte le esecuzioni di aggiornamento recenti:
```
aws glue list-materialized-view-refresh-task-runs \
--catalog-id \
--database-name \
--table-name \
--region
```
Questo mostra:
+ Ora dell'ultimo aggiornamento
+ Stato di aggiornamento (RIUSCITO, FALLITO, IN ESECUZIONE, INTERROTTO)
+ ID di esecuzione dell'attività
+ Messaggi di errore (se falliti)
Stati di aggiornamento comuni:
+ IN ESECUZIONE: il processo di aggiornamento è attualmente in esecuzione
+ RIUSCITO: aggiornamento completato con successo
+ FALLITO: l'aggiornamento ha rilevato un errore
+ INTERROTTO: l'aggiornamento è stato annullato manualmente
Risoluzione dei problemi relativi agli aggiornamenti non riusciti:
Se un aggiornamento fallisce, controlla:
1. Autorizzazioni IAM: assicurati che il ruolo che definisce abbia accesso a tutte le tabelle di base e alla posizione della vista materializzata
1. Disponibilità della tabella di base: verifica che tutte le tabelle di riferimento esistano e siano accessibili
1. Validità della query: conferma che la query SQL è valida per il dialetto SQL di Spark
1. Limiti delle risorse: verifica se hai raggiunto i limiti di aggiornamento simultanei per il tuo account
Utilizza l' GetMaterializedViewRefreshTaskRun API per recuperare messaggi di errore dettagliati.
## Considerazioni e limitazioni
+ Le viste materializzate possono fare riferimento solo alle tabelle Apache Iceberg registrate nel AWS Glue Data Catalog come tabelle di base.
+ La creazione di viste e la riscrittura automatica delle query sono disponibili solo dai motori Spark in Apache Spark versione 3.5.6 e successive su Amazon Athena, Amazon EMR e (versione 5.1). AWS Glue
+ Le viste materializzate alla fine sono coerenti con le tabelle di base. Durante la finestra di aggiornamento, le query che accedono direttamente alla vista materializzata possono restituire dati obsoleti. Per un accesso immediato ai dati correnti, esegui un aggiornamento manuale.
+ L'intervallo minimo di aggiornamento automatico è di un'ora. Per i casi d'uso che richiedono aggiornamenti più frequenti, esegui gli aggiornamenti manuali a livello di codice utilizzando il comando. `REFRESH MATERIALIZED VIEW`
+ La riscrittura delle query dà priorità alla correttezza rispetto alle prestazioni. Se una vista materializzata è obsoleta o non è in grado di soddisfare con precisione i requisiti di query, i motori Spark eseguono la query originale sulle tabelle di base.
# Importazione di dati utilizzando i flussi di lavoro in Lake Formation
Con AWS Lake Formation, puoi importare i tuoi dati utilizzando i flussi *di lavoro*. Un flusso di lavoro definisce l'origine dei dati e la pianificazione per l'importazione dei dati nel data lake. È un contenitore per AWS Glue crawler, job e trigger che viene utilizzato per orchestrare i processi per caricare e aggiornare il data lake.
**Topics**
+ [Progetti e flussi di lavoro in Lake Formation](workflows-about.md)
+ [Creazione di un flusso di lavoro](workflows-creating.md)
+ [Esecuzione di un workflow](workflows-running.md)
# Progetti e flussi di lavoro in Lake Formation
Un flusso di lavoro racchiude una complessa attività di estrazione, trasformazione e caricamento (ETL) che coinvolge più processi. I flussi di lavoro generano AWS Glue crawler, job e trigger per orchestrare il caricamento e l'aggiornamento dei dati. Lake Formation esegue e traccia un flusso di lavoro come un'unica entità. È possibile configurare un flusso di lavoro in modo che venga eseguito su richiesta o in base a una pianificazione.
**Nota**
Spark parquet writer non supporta caratteri speciali nei nomi delle colonne. Questa è una limitazione tecnica dello scrittore stesso, non un problema di configurazione.
I flussi di lavoro creati in Lake Formation sono visibili nella AWS Glue console come grafo aciclico diretto (DAG). Ogni nodo DAG è un job, un crawler o un trigger. Per monitorare l'avanzamento e risolvere i problemi, è possibile tenere traccia dello stato di ogni nodo del flusso di lavoro.
Una volta completato un flusso di lavoro Lake Formation, all'utente che lo ha eseguito viene concessa l'`SELECT`autorizzazione Lake Formation per le tabelle del Data Catalog create dal flusso di lavoro.
Puoi anche creare flussi di lavoro inAWS Glue. Tuttavia, poiché Lake Formation consente di creare un flusso di lavoro a partire da un progetto, la creazione di flussi di lavoro è molto più semplice e automatizzata in Lake Formation. Lake Formation fornisce i seguenti tipi di progetti:
+ **Istantanea del database**: carica o ricarica i dati da tutte le tabelle nel data lake da una fonte JDBC. È possibile escludere alcuni dati dall'origine in base a uno schema di esclusione.
+ **Database incrementale**: carica nel data lake solo nuovi dati da una fonte JDBC, in base ai segnalibri impostati in precedenza. Si specificano le singole tabelle da includere nel database di origine JDBC. Per ogni tabella, scegli le colonne dei segnalibri e l'ordinamento dei segnalibri per tenere traccia dei dati che sono stati caricati in precedenza. La prima volta che si esegue un blueprint di database incrementale su un set di tabelle, il flusso di lavoro carica tutti i dati dalle tabelle e imposta i segnalibri per la successiva esecuzione del blueprint di database incrementale. È quindi possibile utilizzare un blueprint di database incrementale anziché il blueprint di snapshot del database per caricare tutti i dati, a condizione di specificare ogni tabella nell'origine dati come parametro.
+ **File di registro**: carica in blocco i dati da fonti di file di registro AWS CloudTrail, inclusi i log di Elastic Load Balancing e i log di Application Load Balancer.
Utilizza la tabella seguente per decidere se utilizzare uno snapshot del database o un blueprint di database incrementale.
| Usa lo snapshot del database quando... | Usa il database incrementale quando... |
| --- | --- |
| [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/lake-formation/latest/dg/workflows-about.html) | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/lake-formation/latest/dg/workflows-about.html) |
**Nota**
Gli utenti non possono modificare i progetti e i flussi di lavoro creati da Lake Formation.
# Creazione di un flusso di lavoro
Prima di iniziare, assicurati di aver concesso al ruolo le autorizzazioni necessarie per i dati e le autorizzazioni per la localizzazione dei dati. `LakeFormationWorkflowRole` In questo modo il flusso di lavoro può creare tabelle di metadati nel Data Catalog e scrivere dati nelle posizioni di destinazione in Amazon S3. Per ulteriori informazioni, consultare [(Facoltativo) Crea un ruolo IAM per i flussi di lavoro](initial-lf-config.md#iam-create-blueprint-role) e [Panoramica delle autorizzazioni di Lake Formation](lf-permissions-overview.md).
**Nota**
Lake Formation utilizza `GetTemplateInstance` e `InstantiateTemplate` opera per creare flussi di lavoro a partire dai progetti. `GetTemplateInstances` Queste operazioni non sono disponibili al pubblico e vengono utilizzate solo internamente per creare risorse per conto dell'utente. Ricevi CloudTrail eventi per la creazione di flussi di lavoro.
**Per creare un flusso di lavoro da un blueprint**
1. Apri la AWS Lake Formation console all'indirizzo [https://console.aws.amazon.com/lakeformation/](https://console.aws.amazon.com/lakeformation/). Accedi come amministratore del data lake o come utente con autorizzazioni di data engineer. Per ulteriori informazioni, consulta [Riferimento ai personaggi di Lake Formation e alle autorizzazioni IAM](permissions-reference.md).
1. Nel riquadro di navigazione, scegli **Blueprint**, quindi scegli **Usa** blueprint.
1. Nella pagina **Usa un blueprint**, scegli un riquadro per selezionare il tipo di blueprint.
1. In **Origine di importazione**, specifica l'origine dati.
Se state importando da una fonte JDBC, specificate quanto segue:
+ ****Connessione al database****: scegliere una connessione dall'elenco. Crea connessioni aggiuntive utilizzando la AWS Glue console. Il nome utente e la password JDBC nella connessione determinano gli oggetti del database a cui il flusso di lavoro ha accesso.
+ ****Percorso dei dati di origine****: immettere**/**/**o**/**, a seconda del prodotto del database. Oracle Database e MySQL non supportano lo schema nel percorso. È possibile sostituire o con il carattere percentuale (%). ** ** Ad esempio, per un database Oracle con un identificatore di sistema (SID) di`orcl`, immettere `orcl/%` per importare tutte le tabelle a cui ha accesso l'utente indicato nella connessione.
**Importante**
Questo campo distingue tra maiuscole e minuscole. Il flusso di lavoro avrà esito negativo in caso di mancata corrispondenza tra maiuscole e minuscole per uno qualsiasi dei componenti.
Se si specifica un database MySQL AWS Glue , ETL utilizza il driver JDBC Mysql5 per impostazione predefinita, quindi My non è supportato nativamente. SQL8 È possibile modificare lo script di lavoro ETL per utilizzare un `customJdbcDriverS3Path` parametro come descritto in [JDBC ConnectionType](https://docs.aws.amazon.com/glue/latest/dg/aws-glue-programming-etl-connect.html#aws-glue-programming-etl-connect-jdbc) Values nella *AWS Glue Developer* Guide per utilizzare un driver JDBC diverso che supporti My. SQL8
Se stai importando da un file di registro, assicurati che il ruolo specificato per il flusso di lavoro (il «ruolo del flusso di lavoro») disponga delle autorizzazioni IAM necessarie per accedere all'origine dati. Ad esempio, per importare AWS CloudTrail i log, l'utente deve disporre `cloudtrail:LookupEvents` delle autorizzazioni `cloudtrail:DescribeTrails` e per visualizzare l'elenco dei CloudTrail log durante la creazione del flusso di lavoro e il ruolo del flusso di lavoro deve disporre delle autorizzazioni sulla posizione in CloudTrail Amazon S3.
1. Esegui una di queste operazioni:
+ Per il tipo di blueprint **Database snapshot**, identifica facoltativamente un sottoinsieme di dati da importare specificando uno o più modelli di esclusione. Questi modelli di esclusione sono modelli in stile Unix. `glob` Vengono memorizzati come proprietà delle tabelle create dal flusso di lavoro.
Per i dettagli sui modelli di esclusione disponibili, consulta [Includi ed escludi i modelli](https://docs.aws.amazon.com/glue/latest/dg/define-crawler.html#crawler-data-stores-exclude) nella *Guida per gli AWS Glue sviluppatori*.
+ Per il tipo di blueprint **del database incrementale**, specificare i seguenti campi. Aggiungere una riga per ogni tabella da importare.
**Nome tabella**
Tabella da importare. Deve essere tutto in minuscolo.
**Tasti per segnalibri**
Elenco delimitato da virgole di nomi di colonne che definiscono le chiavi dei segnalibri. Se vuoto, la chiave primaria viene utilizzata per determinare nuovi dati. Le maiuscole e le minuscole per ogni colonna devono corrispondere a quelle definite nell'origine dati.
La chiave primaria si qualifica come chiave predefinita per i segnalibri solo se è crescente o decrescente in sequenza (senza spazi vuoti). Se desideri utilizzare la chiave primaria come chiave del segnalibro e presenta degli spazi vuoti, devi denominare la colonna della chiave primaria come chiave del segnalibro.
**Ordine dei segnalibri**
Quando scegli **Crescente**, le righe con valori superiori ai valori contrassegnati dai segnalibri vengono identificate come nuove righe. Quando scegli **Decrescente**, le righe con valori inferiori ai valori contrassegnati dai segnalibri vengono identificate come nuove righe.
**Schema di partizionamento**
(Facoltativo) Elenco delle colonne chiave di partizionamento, delimitate da barre (/). Esempio:. ` year/month/day`
![\[La sezione dei dati incrementali della console include questi campi: nome della tabella, chiavi dei segnalibri, ordine dei segnalibri, schema di partizionamento. È possibile aggiungere o rimuovere righe, dove ogni riga appartiene a una tabella diversa.\]](http://docs.aws.amazon.com/it_it/lake-formation/latest/dg/images/incremental-data.png)
Per ulteriori informazioni, consulta [Tracciamento dei dati elaborati utilizzando i Job Bookmarks](https://docs.aws.amazon.com/glue/latest/dg/monitor-continuations.html) nella *AWS Glue Developer Guide*.
1. In **Import target**, specifica il database di destinazione, la posizione Amazon S3 di destinazione e il formato dei dati.
Assicurati che il ruolo del workflow disponga delle autorizzazioni Lake Formation richieste sul database e sulla posizione di destinazione di Amazon S3.
**Nota**
Attualmente, i blueprint non supportano la crittografia dei dati sulla destinazione.
1. Scegliete una frequenza di importazione.
È possibile specificare un'`cron`espressione con l'opzione **Personalizzata**.
1. In **Opzioni di importazione**:
1. Inserisci un nome per il flusso di lavoro.
1. Per ruolo, scegli il ruolo `LakeFormationWorkflowRole` in cui hai creato[(Facoltativo) Crea un ruolo IAM per i flussi di lavoro](initial-lf-config.md#iam-create-blueprint-role).
1. Specificate facoltativamente un prefisso per la tabella. Il prefisso viene aggiunto ai nomi delle tabelle del catalogo dati create dal flusso di lavoro.
1. Scegli **Crea** e attendi che la console segnali che il flusso di lavoro è stato creato correttamente.
**Suggerimento**
Hai ricevuto il seguente messaggio di errore?
`User: arn:aws:iam:::user/ is not authorized to perform: iam:PassRole on resource:arn:aws:iam:::role/...`
In tal caso, verifica di aver inserito ** un numero di AWS account valido in tutte le politiche.
**Consulta anche:**
[Progetti e flussi di lavoro in Lake Formation](workflows-about.md)
# Esecuzione di un workflow
Puoi eseguire un flusso di lavoro utilizzando la console Lake Formation, la AWS Glue console o la AWS Glue Command Line Interface (AWS CLI) o l'API.
**Per eseguire un flusso di lavoro (console Lake Formation)**
1. Apri la AWS Lake Formation console all'indirizzo [https://console.aws.amazon.com/lakeformation/](https://console.aws.amazon.com/lakeformation/). Accedi come amministratore del data lake o come utente con autorizzazioni di data engineer. Per ulteriori informazioni, consulta [Riferimento ai personaggi di Lake Formation e alle autorizzazioni IAM](permissions-reference.md).
1. Nel pannello di navigazione scegli **Blueprints (Progetti)**.
1. Nella pagina **Blueprints**, seleziona il flusso di lavoro. Quindi, nel menu **Azioni**, scegli **Avvia**.
1. Durante l'esecuzione del flusso di lavoro, visualizzane l'avanzamento nella colonna **Stato dell'ultima esecuzione**. Scegli il pulsante di aggiornamento di tanto in tanto.
**Lo stato va da **RUNNING**, a **Discovering**, a **Importing**, a COMPLETED.**
Quando il flusso di lavoro è completo:
+ Il Data Catalog ha nuove tabelle di metadati.
+ I tuoi dati vengono inseriti nel data lake.
Se il flusso di lavoro fallisce, procedi come segue:
1. Seleziona un flusso di lavoro. Scegliete **Azioni**, quindi scegliete **Visualizza grafico**.
Il flusso di lavoro si apre nella AWS Glue console.
1. Verifica che il flusso di lavoro sia selezionato e scegli la scheda **History** (Cronologia).
1. In **Cronologia**, seleziona l'esecuzione più recente e scegli **Visualizza i dettagli dell'esecuzione**.
1. Seleziona un processo o un crawler non riuscito nel grafico dinamico (di runtime) ed esamina il messaggio di errore. I nodi con errori sono rossi o gialli.
**Consulta anche:**
[Progetti e flussi di lavoro in Lake Formation](workflows-about.md)