Amazon Redshift non supporterà più la creazione di nuovi Python UDFs a partire dalla Patch 198. Python esistente UDFs continuerà a funzionare fino al 30 giugno 2026. Per ulteriori informazioni, consulta il [post del blog](https://aws.amazon.com/blogs/big-data/amazon-redshift-python-user-defined-functions-will-reach-end-of-support-after-june-30-2026/).
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à.
# Concatenazione di ruoli IAM in Amazon Redshift
Quando associ un ruolo al cluster, quest'ultimo può assumere quel ruolo per accedere ad Amazon S3, Amazon Athena AWS Glue AWS Lambda e per tuo conto. Se un ruolo collegato al cluster non ha accesso alle risorse necessarie, è possibile concatenare un altro ruolo, possibilmente appartenente a un altro account. Il cluster quindi può assumere temporaneamente il ruolo concatenato per accedere ai dati. Concatenando i ruoli è anche possibile concedere l'accesso a più account. Ogni ruolo nella catena assume il ruolo successivo nella catena, fino a quando il cluster non assume il ruolo alla fine della catena. Il numero massimo di ruoli IAM che è possibile associare è soggetto a una quota. Per ulteriori informazioni, consulta la quota «Cluster IAM roles for Amazon Redshift to access other AWS services» in. [Quote per gli oggetti Amazon Redshift](amazon-redshift-limits.md#amazon-redshift-limits-quota)
**Nota**
Devi specificare i ruoli IAM affinché la catena funzioni correttamente.
Ad esempio, supponiamo che l'azienda A desideri accedere ai dati in un bucket Amazon S3 appartenente all'azienda B. La società A AWS crei un ruolo di servizio `RoleA` denominato per Amazon Redshift e lo alleghi al proprio cluster. L'Azienda B crea un ruolo denominato `RoleB` autorizzato ad accedere ai dati nel bucket dell'Azienda B. Per accedere ai dati nel bucket dell'Azienda B, l'Azienda A esegue un comando COPY con un parametro `iam_role` che concatena `RoleA` e `RoleB`. Per l'intera durata dell'operazione COPY, `RoleA` assume temporaneamente `RoleB` per accedere al bucket Amazon S3.
Per concatenare i ruoli, stabilisci una relazione di trust tra di essi. Un ruolo che assume un altro ruolo (ad esempio, `RoleA`) deve avere una policy di autorizzazioni che gli permette di assumere il ruolo concatenato successivo (ad esempio, `RoleB`). A sua volta, il ruolo che passa le autorizzazioni (`RoleB`) deve avere una policy di trust che gli permette di passare le autorizzazioni al ruolo concatenato precedente (`RoleA`). Per ulteriori informazioni, consultare [Utilizzo di ruoli IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_use.html) nella Guida per l'utente di IAM.
Il primo ruolo nella catena deve essere un ruolo collegato al cluster. Il primo ruolo e ogni ruolo successivo che assume il ruolo seguente nella catena devono avere una policy che include un'istruzione specifica. Questa istruzione ha l'effetto `Allow` sull'operazione `sts:AssumeRole `e l'Amazon Resource Name (ARN) del ruolo successivo in un elemento `Resource`. Nell'esempio, `RoleA` ha la policy di autorizzazione seguente che gli permette di assumere `RoleB`, di proprietà dell'account AWS `210987654321`.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Sid": "Stmt1487639602000",
"Effect": "Allow",
"Action": [
"sts:AssumeRole"
],
"Resource": "arn:aws:iam::111122223333:role/RoleB"
}
]
}
```
------
Un ruolo che passa a un altro ruolo deve stabilire una relazione di fiducia con il ruolo che assume il ruolo o con l'account che possiede il AWS ruolo. Nell'esempio, `RoleB` ha la policy di trust seguente per stabilire una relazione di trust con `RoleA`.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": "sts:AssumeRole",
"Principal": {
"AWS": "arn:aws:iam::111122223333:role/RoleA"
}
}
]
}
```
------
La seguente politica di fiducia stabilisce una relazione di fiducia con il proprietario dell'account`RoleA`. AWS `123456789012`
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": "sts:AssumeRole",
"Principal": {
"AWS": "arn:aws:iam::123456789012:root"
}
}
]
}
```
------
**Nota**
Per limitare l'autorizzazione del concatenamento dei ruoli a utenti specifici, puoi definire una condizione. Per ulteriori informazioni, consulta [Limitazione dell'accesso a ruoli IAM](authorizing-redshift-service-database-users.md).
Quando si esegue un comando UNLOAD, COPY, CREATE EXTERNAL FUNCTION o CREATE EXTERNAL SCHEMA, si concatenano i ruoli includendo un elenco di ruoli separati da virgole nel parametro. ARNs `iam_role` Di seguito è illustrata la sintassi per la concatenazione di ruoli nel parametro `iam_role`.
```
unload ('select * from venue limit 10')
to 's3://acmedata/redshift/venue_pipe_'
IAM_ROLE 'arn:aws:iam:::role/[,arn:aws:iam:::role/][,...]';
```
**Nota**
L'intera catena di ruoli è racchiusa tra virgolette singole e non deve contenere spazi.
Negli esempi seguenti, `RoleA` è collegato al cluster che appartiene all'account AWS `123456789012`. `RoleB`, che appartiene all'account `210987654321`, dispone dell'autorizzazione per accedere al bucket denominato `s3://companyb/redshift/`. L'esempio seguente concatena `RoleA` e `RoleB` per eseguire il comando UNLOAD per scaricare i dati nel bucket s3://companyb/redshift/.
```
unload ('select * from venue limit 10')
to 's3://companyb/redshift/venue_pipe_'
iam_role 'arn:aws:iam::123456789012:role/RoleA,arn:aws:iam::210987654321:role/RoleB';
```
L'esempio seguente usa il comando COPY per caricare i dati scaricati nell'esempio precedente.
```
copy venue
from 's3://companyb/redshift/venue_pipe_'
iam_role 'arn:aws:iam::123456789012:role/RoleA,arn:aws:iam::210987654321:role/RoleB';
```
Nell'esempio seguente CREATE EXTERNAL SCHEMA usa ruoli concatenati per assumere il ruolo `RoleB`.
```
create external schema spectrumexample from data catalog
database 'exampledb' region 'us-west-2'
iam_role 'arn:aws:iam::123456789012:role/RoleA,arn:aws:iam::210987654321:role/RoleB';
```
Nell'esempio seguente CREATE EXTERNAL FUNCTION usa ruoli concatenati per assumere il ruolo `RoleB`.
```
create external function lambda_example(varchar)
returns varchar
volatile
lambda 'exampleLambdaFunction'
iam_role 'arn:aws:iam::123456789012:role/RoleA,arn:aws:iam::210987654321:role/RoleB';
```