Le traduzioni sono generate tramite traduzione automatica. In caso di conflitto tra il contenuto di una traduzione e la versione originale in Inglese, quest'ultima prevarrà.
# Utilizzo di una propagazione affidabile delle identità con Amazon SageMaker Unified Studio
Questo tutorial mostra come configurare un'applicazione EMR Serverless con Trusted Identity Propagation (TIP). Quindi interroghi una tabella di esempio utilizzando i controlli di accesso basati sull'identità tramite Amazon Unified Studio. SageMaker Con questa configurazione, EMR Serverless esegue le query Spark di ogni utente con la propria identità IAM Identity Center e Lake Formation applica le autorizzazioni per utente sulle tabelle del Glue Data Catalog. AWS
**TIP non supportato nei carichi di lavoro interattivi di EMR Studio**
I carichi di lavoro interattivi tramite EMR Studio non supportano la propagazione affidabile delle identità con EMR Serverless. Usa Amazon SageMaker Unified Studio come applicazione rivolta al cliente per carichi di lavoro interattivi. TIP-enabled
**Costi**
Questo tutorial utilizza AWS servizi che potrebbero comportare costi, tra cui EMR Serverless AWS Lake Formation Centro identità AWS IAM, Amazon Simple Storage Service e Amazon Unified Studio. SageMaker Per evitare addebiti continui, segui i passaggi di pulizia alla fine di questo tutorial. Per informazioni sui prezzi, consulta la pagina dei prezzi di ciascun servizio.
## Prerequisiti e configurazione
Completa i passaggi seguenti per configurare tutte le risorse necessarie prima di interrogare i dati con una propagazione affidabile dell'identità.
### Passaggio 1: configura IAM Identity Center
1. [Abilita IAM Identity Center ](https://docs.aws.amazon.com/singlesignon/latest/userguide/enable-identity-center.html) nel tuo AWS account. Un'istanza di IAM Identity Center può esistere solo in una singola regione per account.
**Importante**
Annota in quale regione è distribuito il tuo IAM Identity Center. Tutte le risorse successive (Lake Formation, EMR Serverless, AWS Glue) devono essere create nella stessa regione. Ad esempio, se il tuo IAM Identity Center è in us-west-2, anche tutte le risorse devono trovarsi in us-west-2.
1. [Effettua il provisioning di utenti e gruppi ](https://docs.aws.amazon.com/singlesignon/latest/userguide/tutorials.html) in IAM Identity Center, manualmente o tramite la sincronizzazione da un provider di identità esterno (come Okta o Microsoft Entra ID).
1. Annota l'ARN della tua istanza IAM Identity Center. Ti servirà nei passaggi successivi. Trovalo nella console IAM Identity Center in ** Impostazioni**.
Per trovare la tua istanza a livello di codice, esegui:
```
aws sso-admin list-instances --region {{your-region}}
```
Output di esempio:
```
{
"Instances": [
{
"InstanceArn": "arn:aws:sso:::instance/ssoins-1234567890abcdef",
"IdentityStoreId": "d-1234567890",
"OwnerAccountId": "123456789012",
"Status": "ACTIVE"
}
]
}
```
### Passaggio 2: configura Lake Formation con IAM Identity Center
1. Apri la console di Lake Formation.
1. Configura un amministratore del [ data lake](https://docs.aws.amazon.com/lake-formation/latest/dg/admins-setup.html).
**Importante**
Assicurati che il ruolo o l'utente IAM che stai utilizzando per eseguire questi comandi sia aggiunto come amministratore di Data Lake in Lake Formation. Altrimenti, riceverai l'errore «Autorizzazioni di Lake Formation insufficienti» durante la creazione di database o tabelle. Per aggiungere il tuo ruolo di amministratore:
```
aws lakeformation put-data-lake-settings \
--data-lake-settings '{
"DataLakeAdmins": [
{"DataLakePrincipalIdentifier": "arn:aws:iam::{{account-id}}:role/{{your-role}}"}
],
"CreateDatabaseDefaultPermissions": [],
"CreateTableDefaultPermissions": [],
"Parameters": {"CROSS_ACCOUNT_VERSION": "3", "SET_CONTEXT": "TRUE"}
}'
```
1. Crea l'integrazione IAM Identity Center per Lake Formation utilizzando l'ARN di istanza indicato nel passaggio 1:
```
aws lakeformation create-lake-formation-identity-center-configuration \
--catalog-id {{account-id}} \
--instance-arn "arn:aws:sso:::instance/ssoins-{{instance-id}}"
```
1. Crea un ruolo IAM per la registrazione della sede di Lake Formation. Non utilizzare il ruolo collegato al servizio per la propagazione affidabile delle identità. Per ulteriori informazioni, consulta [ Configurazione di AWS Lake Formation con IAM Identity Center. ](https://docs.aws.amazon.com/singlesignon/latest/userguide/tip-tutorial-lf.html)
**Politica di fiducia: **
```
{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Principal": {
"Service": "lakeformation.amazonaws.com"
},
"Action": [
"sts:AssumeRole",
"sts:SetContext"
]
}
]
}
```
**sts: SetContext è obbligatorio**
La politica di fiducia deve includere`sts:SetContext`, ciò che è necessario per la propagazione delle identità attendibili. Il ruolo IAM creato dalla procedura guidata predefinita è un ruolo collegato ai servizi e non include. `sts:SetContext` Se in precedenza hai registrato una sede con il ruolo collegato al servizio, devi registrarla nuovamente con un ruolo personalizzato che includa. `sts:SetContext`
**Politica di autorizzazione ** (concede l'accesso alla posizione dati di Amazon S3):
```
{
"Version": "2012-10-17",
"Statement": [
{
"Sid": "LakeFormationDataAccessPermissionsForS3",
"Effect": "Allow",
"Action": [
"s3:PutObject",
"s3:GetObject",
"s3:DeleteObject"
],
"Resource": [
"arn:aws:s3:::{{your-data-bucket}}/*"
]
},
{
"Sid": "LakeFormationDataAccessPermissionsForS3ListBucket",
"Effect": "Allow",
"Action": [
"s3:ListBucket"
],
"Resource": [
"arn:aws:s3:::{{your-data-bucket}}"
]
}
]
}
```
Crea il ruolo e allega la policy:
```
aws iam create-role \
--role-name LFLocationRegistrationRole \
--assume-role-policy-document file://lf-trust-policy.json \
--description "Lake Formation location registration role with sts:SetContext for TIP"
aws iam put-role-policy \
--role-name LFLocationRegistrationRole \
--policy-name LFDataAccessPolicy \
--policy-document file://lf-permissions-policy.json
```
1. Registra la tua posizione dati Amazon S3 con Lake Formation utilizzando il ruolo che hai creato:
```
aws lakeformation register-resource \
--resource-arn "arn:aws:s3:::{{your-data-bucket}}" \
--role-arn "arn:aws:iam::{{account-id}}:role/LFLocationRegistrationRole"
```
1. Crea un database e una tabella nel AWS Glue Data Catalog puntando ai tuoi dati di esempio.
1. Concedi agli utenti o ai gruppi di IAM Identity Center le autorizzazioni sia sul database che sulla tabella.
**Importante**
Devi concedere DESCRIBE sul database oltre a SELECT e DESCRIBE sulla tabella. Senza le autorizzazioni a livello di database, il database non verrà visualizzato nei risultati di SHOW DATABASES quando si utilizza l'accesso basato sull'identità.
**Utilizzo della console: **
1. Nella console di Lake Formation, scegli Autorizzazioni ** Data Lake ** > ** Concedi**.
1. In ** Principi**, scegli gli utenti e i gruppi di ** IAM Identity Center ** e seleziona il tuo utente o gruppo.
1. In Risorse del ** Named Data Catalog**, seleziona il tuo database.
1. In Autorizzazioni ** del database**, seleziona ** Descrivi**.
1. Scegliere **Concedi**.
1. Ripeti i passaggi da 1 a 5, questa volta selezionando la tabella e concedendo le autorizzazioni ** Seleziona ** e ** descrivi ** in ** Tabella. **
**Utilizzando: AWS CLI**
**Importante**
Il principale formato identificativo per gli utenti di IAM Identity Center nelle sovvenzioni Lake Formation è:. `arn:aws:identitystore:::user/` Nota i tre punti (:::). Non è stata specificata alcuna regione o account. Puoi UserId scaricarlo dall'Identity Store:
```
# List users to get their UserIds
aws identitystore list-users --identity-store-id {{identity-store-id}} --region {{your-region}}
# Grant DESCRIBE on the database
aws lakeformation grant-permissions \
--principal '{"DataLakePrincipalIdentifier": "arn:aws:identitystore:::user/{{UserId}}"}' \
--permissions '["DESCRIBE"]' \
--resource '{"Database": {"DatabaseName": "{{tip_tutorial_db}}", "CatalogId": "{{account-id}}"}}'
# Grant SELECT and DESCRIBE on the table
aws lakeformation grant-permissions \
--principal '{"DataLakePrincipalIdentifier": "arn:aws:identitystore:::user/{{UserId}}"}' \
--permissions '["SELECT","DESCRIBE"]' \
--resource '{"Table": {"DatabaseName": "{{tip_tutorial_db}}", "Name": "{{employees}}", "CatalogId": "{{account-id}}"}}'
```
### Fase 3: Creare l'applicazione TIP-enabled EMR Serverless
Assicurati che il tuo ruolo IAM disponga delle autorizzazioni IAM Identity Center richieste per creare l'applicazione:
```
"sso:DescribeInstance",
"sso:CreateApplication",
"sso:DeleteApplication",
"sso:PutApplicationAuthenticationMethod",
"sso:PutApplicationAssignmentConfiguration",
"sso:PutApplicationGrant",
"sso:PutApplicationAccessScope"
```
Crea l'applicazione con una propagazione delle identità affidabile, l'endpoint Apache Livy abilitato e il AWS Glue Data Catalog configurato come metastore:
```
aws emr-serverless create-application \
--release-label emr-7.8.0 \
--type "SPARK" \
--identity-center-configuration '{"identityCenterInstanceArn": "arn:aws:sso:::instance/ssoins-{{instance-id}}"}' \
--interactive-configuration '{"livyEndpointEnabled":true}' \
--runtime-configuration '[{"classification": "spark-defaults", "properties": {"spark.sql.catalogImplementation": "hive", "spark.hadoop.hive.metastore.client.factory.class": "com.amazonaws.glue.catalog.metastore.AWSGlueDataCatalogHiveClientFactory"}}]'
```
**Importante**
**AWS CLI requisito della versione: i flag`--identity-center-configuration`, `--interactive-configuration` e richiedono ** la versione 2.15\+. `--runtime-configuration` AWS CLI Se ricevi errori «Opzioni sconosciute», aggiorna il tuo AWS CLI o usa Python boto3 (v1.35\+) come alternativa:
```
import boto3
session = boto3.Session(profile_name='{{your-profile}}', region_name='{{your-region}}')
client = session.client('emr-serverless')
response = client.create_application(
name='tip-tutorial-app',
releaseLabel='emr-7.8.0',
type='SPARK',
identityCenterConfiguration={
'identityCenterInstanceArn': 'arn:aws:sso:::instance/ssoins-{{instance-id}}'
},
interactiveConfiguration={
'livyEndpointEnabled': True
},
runtimeConfiguration=[
{
'classification': 'spark-defaults',
'properties': {
'spark.sql.catalogImplementation': 'hive',
'spark.hadoop.hive.metastore.client.factory.class': 'com.amazonaws.glue.catalog.metastore.AWSGlueDataCatalogHiveClientFactory'
}
}
]
)
print(response['applicationId'])
```
**Configurazione del metastore di Glue Data Catalog**
L'`runtimeConfiguration`impostazione e la classe `spark.sql.catalogImplementation` AWS Glue metastore factory assicurano che le sessioni Spark possano accedere a tutti i tipi di tabella (CSV, Parquet, ORC, Iceberg) nel Glue Data Catalog. AWS Senza questa configurazione, potrebbero essere visibili solo le tabelle Iceberg.
**L'endpoint Apache Livy è richiesto per TIP**
La propagazione affidabile delle identità richiede. `--interactive-configuration '{"livyEndpointEnabled":true}'` TIP è abilitato solo per l'endpoint Apache Livy.
Se non disponi delle autorizzazioni IAM Identity Center richieste, crea l'applicazione senza il `--identity-center-configuration` parametro e chiedi all'amministratore di IAM Identity Center di abilitare TIP in un secondo momento utilizzando l'API di aggiornamento dell'applicazione:
```
aws emr-serverless update-application \
--application-id {{application-id}} \
--identity-center-configuration '{"identityCenterInstanceArn": "arn:aws:sso:::instance/ssoins-{{instance-id}}"}'
```
### Fase 4: Configurare il ruolo di esecuzione del job
La politica di fiducia del ruolo di esecuzione del lavoro deve includere `sts:SetContext` per consentire a EMR Serverless di migliorare le credenziali con l'identità dell'utente:
```
{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Principal": {
"Service": "emr-serverless.amazonaws.com"
},
"Action": ["sts:AssumeRole", "sts:SetContext"]
}
]
}
```
Crea il ruolo:
```
aws iam create-role \
--role-name emr-serverless-tip-job-role \
--assume-role-policy-document file://trust-policy.json \
--description "EMR Serverless job execution role with TIP support"
```
Allega le autorizzazioni per i servizi a valle a cui il lavoro accederà. Il ruolo richiede le autorizzazioni Lake Formation, AWS Glue, Amazon S3 e Amazon CloudWatch Logs:
```
{
"Version": "2012-10-17",
"Statement": [
{
"Sid": "LakeFormationAndGlueAccess",
"Effect": "Allow",
"Action": [
"lakeformation:GetDataAccess",
"glue:GetTable", "glue:GetTables",
"glue:GetDatabase", "glue:GetDatabases",
"glue:GetPartitions"
],
"Resource": "*"
},
{
"Sid": "S3DataAccess",
"Effect": "Allow",
"Action": [
"s3:GetObject",
"s3:PutObject",
"s3:ListBucket",
"s3:GetBucketLocation"
],
"Resource": [
"arn:aws:s3:::{{your-data-bucket}}",
"arn:aws:s3:::{{your-data-bucket}}/*"
]
},
{
"Sid": "CloudWatchLogsAccess",
"Effect": "Allow",
"Action": [
"logs:CreateLogGroup",
"logs:CreateLogStream",
"logs:PutLogEvents",
"logs:DescribeLogGroups",
"logs:DescribeLogStreams"
],
"Resource": "arn:aws:logs:{{us-east-1}}:{{111122223333}}:*"
}
]
}
```
**Le autorizzazioni S3 sono richieste in aggiunta alle autorizzazioni di Lake Formation**
Le autorizzazioni Amazon S3 (`s3:GetObject`,`s3:PutObject`,`s3:ListBucket`) sul tuo bucket di dati sono necessarie in aggiunta alle autorizzazioni Lake Formation e Glue. AWS L'`s3:PutObject`autorizzazione è necessaria per i dati scratch and shuffle di Spark. Senza le autorizzazioni di Amazon S3, i job Spark potrebbero fallire con errori di accesso negato durante la lettura dei file di dati sottostanti o la scrittura di dati temporanei.
**CloudWatch Le autorizzazioni relative ai log sono obbligatorie**
Le autorizzazioni Amazon CloudWatch Logs sono necessarie per la consegna dei log dei driver e degli executor di Spark. Senza di esse, le sessioni Spark potrebbero non avviarsi.
Collegare la policy al ruolo:
```
aws iam put-role-policy \
--role-name emr-serverless-tip-job-role \
--policy-name tip-lakeformation-access \
--policy-document file://permissions-policy.json
```
**Concedi a Lake Formation le autorizzazioni per il ruolo di esecuzione del lavoro: **
Il ruolo di esecuzione del lavoro richiede anche le autorizzazioni di Lake Formation sul database e sulla tabella. Ciò si aggiunge alle concessioni concesse all'utente dello IAM Identity Center.
```
# Grant DESCRIBE on the database to the job role
aws lakeformation grant-permissions \
--principal '{"DataLakePrincipalIdentifier": "arn:aws:iam::{{account-id}}:role/emr-serverless-tip-job-role"}' \
--permissions '["DESCRIBE"]' \
--resource '{"Database": {"DatabaseName": "{{tip_tutorial_db}}", "CatalogId": "{{account-id}}"}}'
# Grant SELECT and DESCRIBE on the table to the job role
aws lakeformation grant-permissions \
--principal '{"DataLakePrincipalIdentifier": "arn:aws:iam::{{account-id}}:role/emr-serverless-tip-job-role"}' \
--permissions '["SELECT","DESCRIBE"]' \
--resource '{"Table": {"DatabaseName": "{{tip_tutorial_db}}", "Name": "{{employees}}", "CatalogId": "{{account-id}}"}}'
```
Per ulteriori configurazioni dei servizi downstream, consulta [ Using Lake Formation with EMR Serverless ](lake-formation-section.html) e [ Using Amazon S3 Access Grants with EMR Serverless. ](access-grants.html)
## Interroga i dati con Trusted Identity Propagation tramite Amazon Unified Studio SageMaker
Dopo aver completato la configurazione, puoi interrogare i dati utilizzando l'applicazione TIP-enabled EMR Serverless come elaborazione in un progetto Amazon Unified Studio. SageMaker EMR Serverless esegue le query di ogni utente con la propria identità IAM Identity Center e Lake Formation applica le autorizzazioni per utente.
### Prerequisiti
+ Un'applicazione TIP-enabled EMR Serverless (completata nel passaggio 3 precedente).
+ Un dominio Amazon SageMaker Unified Studio configurato con l'autenticazione IAM Identity Center.
+ Autorizzazioni Lake Formation concesse all'utente o al gruppo IAM Identity Center sul database e sulla tabella di destinazione (completate nel passaggio 2 precedente).
### Fase 5: Creare un progetto Amazon SageMaker Unified Studio con TIP abilitato
1. Accedi ad Amazon SageMaker Unified Studio utilizzando le tue credenziali IAM Identity Center.
1. Crea un nuovo progetto o apri un progetto esistente.
1. Nelle impostazioni del progetto, assicurati che il profilo sia `enableTrustedIdentityPropagationPermissions` impostato su `true` nei parametri del blueprint.
### Fase 6: Aggiungere l'applicazione EMR Serverless come elaborazione
La configurazione di elaborazione del progetto Amazon SageMaker Unified Studio attualmente non supporta l'aggiunta di un'applicazione EMR Serverless esistente tramite la console. Usa il per creare la AWS CLI connessione:
```
aws datazone create-connection \
--domain-identifier {{domain-id}} \
--name "{{my-emr-serverless-connection}}" \
--environment-identifier {{environment-id}} \
--props '{
"sparkEmrProperties": {
"computeArn": "arn:aws:emr-serverless:{{region}}:{{account-id}}:/applications/{{application-id}}",
"runtimeRole": "arn:aws:iam::{{account-id}}:role/emr-serverless-tip-job-role"
}
}'
```
Sostituisci i valori seguenti:
+ `{{domain-id}}`: il tuo identificatore di dominio Amazon SageMaker Unified Studio.
+ `{{environment-id}}`: L'identificatore di ambiente per il tuo progetto (usa l'ambiente Tooling).
+ `{{application-id}}`: L'ID dell'applicazione EMR Serverless indicato nella Fase 3.
+ `{{emr-serverless-tip-job-role}}`: il ruolo di esecuzione del lavoro descritto nella Fase 4.
**Importante**
L'`create-connection`API richiede che il chiamante sia membro del DataZone progetto. Se ne ricevi uno`AccessDeniedException`, aggiungi il tuo ruolo IAM come collaboratore del progetto prima di creare la connessione:
```
import boto3
session = boto3.Session(profile_name='{{your-profile}}', region_name='{{your-region}}')
client = session.client('datazone')
client.create_project_membership(
domainIdentifier='{{domain-id}}',
projectIdentifier='{{project-id}}',
designation='PROJECT_CONTRIBUTOR',
member={'userIdentifier': 'arn:aws:iam::{{account-id}}:role/{{your-role}}'}
)
```
**Configura il ruolo DataZone utente del progetto per l'accesso EMR Serverless. **
Il ruolo DataZone utente per l'ambiente di progetto deve disporre delle autorizzazioni per interagire con l'applicazione EMR Serverless. Aggiungere la seguente politica in linea al ruolo (il nome del ruolo segue lo schema): `datazone_usr_role__`
```
{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"emr-serverless:GetApplication",
"emr-serverless:StartApplication",
"emr-serverless:StopApplication",
"emr-serverless:ListApplications",
"emr-serverless:AccessLivyEndpoints",
"emr-serverless:StartJobRun",
"emr-serverless:GetJobRun",
"emr-serverless:ListJobRuns",
"emr-serverless:CancelJobRun",
"emr-serverless:GetDashboardForJobRun"
],
"Resource": "*"
},
{
"Effect": "Allow",
"Action": "iam:PassRole",
"Resource": "arn:aws:iam::{{111122223333}}:role/emr-serverless-tip-job-role",
"Condition": {
"StringLike": {
"iam:PassedToService": "emr-serverless.amazonaws.com"
}
}
}
]
}
```
**Concedi a Lake Formation le autorizzazioni per il ruolo DataZone utente: **
```
# Grant DESCRIBE on the database
aws lakeformation grant-permissions \
--principal '{"DataLakePrincipalIdentifier": "arn:aws:iam::{{account-id}}:role/datazone_usr_role_{{project-id}}_{{environment-id}}"}' \
--permissions '["DESCRIBE"]' \
--resource '{"Database": {"DatabaseName": "{{tip_tutorial_db}}", "CatalogId": "{{account-id}}"}}'
# Grant SELECT and DESCRIBE on the table
aws lakeformation grant-permissions \
--principal '{"DataLakePrincipalIdentifier": "arn:aws:iam::{{account-id}}:role/datazone_usr_role_{{project-id}}_{{environment-id}}"}' \
--permissions '["SELECT","DESCRIBE"]' \
--resource '{"Table": {"DatabaseName": "{{tip_tutorial_db}}", "Name": "{{employees}}", "CatalogId": "{{account-id}}"}}'
```
**Limitazione della console per le connessioni EMR Serverless**
Amazon SageMaker Unified Studio attualmente supporta l'aggiunta di Amazon EMR esistente su cluster EC2 tramite la configurazione di elaborazione della console. Per le applicazioni EMR Serverless, utilizza il metodo mostrato sopra. AWS CLI
### Fase 7: Interroga una tabella di esempio
1. Apri uno spazio JupyterLab IDE nel tuo progetto Amazon SageMaker Unified Studio.
1. Seleziona la connessione EMR Serverless come elaborazione per l'esecuzione del notebook.
1. In una nuova cella del notebook, esegui le seguenti query: PySpark
```
%%pyspark my-emr-serverless-connection
spark.sql("SHOW DATABASES").show()
%%pyspark my-emr-serverless-connection
spark.sql("SELECT * FROM tip_tutorial_db.employees LIMIT 10").show()
```
1. Verificate che l'interrogazione restituisca dati. Ciò conferma che l'identità del tuo IAM Identity Center è stata propagata a Lake Formation e che l'accesso è stato concesso in base alla tua identità.
**Avvio a freddo dell'applicazione**
La prima volta che si esegue una cella dopo aver creato la connessione, EMR Serverless avvia l'applicazione (avvio a freddo). Questa operazione può richiedere da 2 a 3 minuti. Le celle successive vengono eseguite in pochi secondi mentre la sessione è attiva.
**Risoluzione dei problemi relativi agli errori di accesso negato**
Se ricevi un errore di accesso negato, verifica che:
L'utente o il gruppo del tuo IAM Identity Center ha ottenuto l'autorizzazione DESCRIBE nel database e SELECT/DESCRIBE nella tabella di Lake Formation.
Il ruolo di esecuzione del lavoro dispone delle autorizzazioni di `lakeformation:GetDataAccess` AWS Glue Data Catalog.
Il ruolo DataZone utente dispone delle autorizzazioni di Lake Formation sul database e sulla tabella.
La posizione Amazon S3 di Lake Formation è registrata con un ruolo personalizzato che include `sts:SetContext` (non il ruolo collegato al servizio).
## Risoluzione dei problemi
| Errore | Causa | Correzione |
| --- | --- | --- |
| AccessDeniedException: emr-serverless:GetApplication | Il ruolo DataZone utente non dispone delle autorizzazioni EMR Serverless. | Aggiungere la policy in linea EMR Serverless al ruolo DataZone utente (vedere il passaggio 6). |
| Scaduto il timeout in attesa che l'applicazione raggiunga lo stato STARTED | L'avvio a freddo dell'app EMR Serverless supera il timeout predefinito. | Re-run la cella. L'app continua ad avviarsi in background e sarà pronta al tentativo successivo. |
| Sessione non trovata. Pulito a causa di un timeout di inattività. | La sessione Spark non è stata avviata a causa di autorizzazioni insufficienti sul ruolo di esecuzione del lavoro. | Assicurati che il ruolo di esecuzione del lavoro disponga delle autorizzazioni Amazon S3, Amazon CloudWatch Logs, AWS Glue e Lake Formation (vedi Passaggio 4). |
| Autorizzazioni Lake Formation insufficienti: descrizione obbligatoria sul database | La tua identità o il tuo ruolo non dispone delle autorizzazioni Lake Formation a livello di database. | Concedi DESCRIBE sul database all'utente di IAM Identity Center, al ruolo di esecuzione del job e al ruolo utente. DataZone |
| TABLE\_OR\_VIEW\_NOT\_FOUND | La sessione Spark non è configurata per utilizzare il AWS Glue Data Catalog. | Assicurati che l'applicazione EMR Serverless includa la classe spark.sql.catalogImplementation=hive AWS Glue metastore factory inclusa runtimeConfiguration (vedi Fase 3). |
| AccessDeniedException: CreateConnection | Il chiamante non è un membro del progetto. DataZone | Aggiungi il tuo ruolo di collaboratore del progetto prima di chiamare create-connection (vedi il passaggio 6). |
## Eseguire la pulizia delle risorse
Per evitare addebiti continuativi, elimina le risorse create per questo tutorial:
1. Elimina l'applicazione EMR Serverless.
1. Rimuovi la connessione ad Amazon SageMaker Unified Studio ed elimina il progetto Amazon SageMaker Unified Studio (e il dominio, se lo hai creato solo per questo tutorial).
1. Revoca le autorizzazioni di Lake Formation che hai concesso e annulla la registrazione della posizione dati di Amazon S3.
1. Elimina i ruoli IAM che hai creato nelle fasi 2 e 4.
1. Elimina tutti i bucket Amazon S3 di test e i dati di esempio.
## Fasi successive
+ Per verificare la propagazione dell'identità in CloudTrail, cerca `AssumeRole` gli eventi con il servizio EMR `sts:SetContext` Serverless.
+ Per limitare l'accesso a utenti diversi, crea utenti IAM Identity Center aggiuntivi e concedi loro autorizzazioni Lake Formation diverse sulla stessa tabella (ad esempio, filtro a livello di colonna o di riga).
+ Per le distribuzioni di produzione, assegna le autorizzazioni Amazon S3 e AWS Glue del ruolo di esecuzione del lavoro a risorse specifiche anziché utilizzare caratteri jolly.
+ Per ulteriori informazioni sull'utilizzo di EMR Serverless con Amazon SageMaker Unified Studio, consulta [ EMR Serverless in Amazon Unified Studio. SageMaker ](https://docs.aws.amazon.com/next-generation-sagemaker/latest/userguide/emr-serverless.html)