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à.

# Ruoli IAM
<a name="id_roles"></a>

Un *ruolo* IAM è un'identità IAM che puoi creare nel tuo account e che dispone di autorizzazioni specifiche. Un ruolo IAM è simile a un utente IAM, in quanto è un'identità AWS con policy di autorizzazioni che determinano ciò che l'identità può e non può fare in AWS. Tuttavia, invece di essere associato in modo univoco a una persona, un ruolo è destinato a essere assunto da chiunque. Inoltre, un ruolo non ha credenziali a lungo termine standard associate (password o chiavi di accesso). Invece, quando assumi un ruolo, ti fornisce credenziali di sicurezza temporanee per la tua sessione di ruolo.

Puoi utilizzare i ruoli per delegare l'accesso a utenti, applicazioni o servizi che normalmente non hanno accesso alle tue AWS risorse. Ad esempio, potresti voler concedere agli utenti del tuo AWS account l'accesso a risorse che di solito non dispongono o concedere agli utenti di un account Account AWS l'accesso alle risorse di un altro account. Oppure potresti voler consentire a un'app mobile di utilizzare AWS le risorse, ma non incorporare AWS le chiavi all'interno dell'app (dove possono essere difficili da aggiornare e dove gli utenti possono potenzialmente estrarle). A volte si desidera AWS consentire l'accesso a utenti che hanno già identità definite all'esterno AWS, ad esempio nella directory aziendale. In alternativa, è possibile concedere l'accesso all'account a terze parti in modo che possano eseguire un controllo sulle proprie risorse.

Per questi scenari, puoi delegare l'accesso alle AWS risorse utilizzando un ruolo *IAM*. Questa sezione introduce i ruoli e i diversi modi in cui è possibile utilizzarli, quando e come selezionare gli approcci, come creare, gestire, cambiare (o assumere) ed eliminare i ruoli.

**Nota**  
Quando crei il tuo per la prima volta Account AWS, per impostazione predefinita non viene creato alcun ruolo. Man mano che aggiungi servizi al tuo account, questi possono aggiungere ruoli collegati ai servizi per supportarne i casi d'uso.  
 Un ruolo collegato al servizio è un tipo di ruolo di servizio collegato a un. Servizio AWS Il servizio può assumere il ruolo per eseguire un’operazione per tuo conto. I ruoli collegati al servizio vengono visualizzati nel tuo account Account AWS e sono di proprietà del servizio. Un amministratore IAM può visualizzare le autorizzazioni per i ruoli collegati al servizio, ma non modificarle.   
Prima di poter eliminare i ruoli collegati ai servizi, devi eliminare le risorse associate. Questa procedura protegge le risorse poiché impedisce la rimozione involontaria dell’autorizzazione ad accedere alle risorse.  
Per informazioni su quali servizi supportano i ruoli collegati ai servizi, consulta la pagina [AWS servizi che funzionano con IAM](reference_aws-services-that-work-with-iam.md) e cerca i servizi per cui è indicato **Sì **nella colonna **Ruolo collegato ai servizi**. Scegliere **Sì** in corrispondenza di un link per visualizzare la documentazione relativa al ruolo collegato al servizio per tale servizio.

**Topics**
+ [Quando creare un utente IAM invece di un ruolo](#id_which-to-choose)
+ [Termini e concetti dei ruoli](#id_roles_terms-and-concepts)
+ [Risorse aggiuntive](#id_roles_additional-resources)
+ [Problema del "confused deputy"](confused-deputy.md)
+ [Scenari comuni per i ruoli IAM](id_roles_common-scenarios.md)
+ [Creazione di ruoli IAM](id_roles_create.md)
+ [Gestione del ruolo IAM](id_roles_manage.md)
+ [Metodi per assumere un ruolo](id_roles_manage-assume.md)

## Quando creare un utente IAM invece di un ruolo
<a name="id_which-to-choose"></a>

Ti consigliamo di utilizzare gli utenti IAM solo per casi d’uso non supportati dalla federazione delle identità. Alcuni dei casi d'uso sono i seguenti:
+ **Carichi di lavoro che non possono utilizzare ruoli IAM**: è possibile eseguire un carico di lavoro da una posizione che deve accedere a AWS. In alcune situazioni, non puoi utilizzare i ruoli IAM per fornire credenziali temporanee, ad esempio per i plugin. WordPress In queste situazioni, per autenticarti a AWS usa le chiavi di accesso a lungo termine dell'utente IAM per quel carico di lavoro.
+ ** AWS Client di terze parti**: se utilizzi strumenti che non supportano l'accesso con IAM Identity Center, come AWS client o fornitori di terze parti che non sono ospitati su AWS, utilizza le chiavi di accesso a lungo termine degli utenti IAM.
+ **AWS CodeCommit accesso**: se utilizzi CodeCommit per archiviare il codice, puoi utilizzare un utente IAM con chiavi SSH o credenziali specifiche del servizio CodeCommit per l'autenticazione nei tuoi repository. Si consiglia di eseguire questa operazione oltre a utilizzare un utente di IAM Identity Center per l'autenticazione normale. Gli utenti di IAM Identity Center sono le persone della tua forza lavoro che hanno bisogno di accedere alle tue o alle tue applicazioni cloud. Account AWS Per consentire agli utenti di accedere ai tuoi CodeCommit repository senza configurare gli utenti IAM, puoi configurare l'utilità. **git-remote-codecommit** Per ulteriori informazioni su IAM e CodeCommit, consulta. [Credenziali IAM per CodeCommit: credenziali Git, chiavi SSH e chiavi di accesso AWS](id_credentials_ssh-keys.md) *Per ulteriori informazioni sulla configurazione dell'**git-remote-codecommit**utilità, consulta [Connessione ai AWS CodeCommit repository con credenziali rotanti](https://docs.aws.amazon.com/codecommit/latest/userguide/temporary-access.html#temporary-access-configure-credentials) nella Guida per l'utente.AWS CodeCommit *
+ **Accesso ad Amazon Keyspaces (per Apache Cassandra)**: in una situazione in cui non è possibile utilizzare gli utenti in IAM Identity Center, ad esempio per scopi di test per la compatibilità con Cassandra, puoi utilizzare un utente IAM con credenziali specifiche del servizio per l'autenticazione con Amazon Keyspaces. Gli utenti di IAM Identity Center sono le persone della tua forza lavoro che hanno bisogno di accedere alle tue applicazioni Account AWS o alle tue applicazioni cloud. Puoi anche connetterti ad Amazon Keyspaces utilizzando credenziali temporanee. Per ulteriori informazioni, consulta [Utilizzo di credenziali temporanee per connettersi ad Amazon Keyspaces utilizzando un ruolo IAM e il plugin SIGv4](https://docs.aws.amazon.com/keyspaces/latest/devguide/access.credentials.html#temporary.credentials.IAM) nella *Guida per gli sviluppatori di Amazon Keyspaces (per Apache Cassandra)*.
+ **Accesso di emergenza**: in una situazione in cui non puoi accedere al tuo provider di identità e devi intervenire nel tuo Account AWS. Stabilire l'accesso di emergenza per gli utenti IAM può far parte del tuo piano di resilienza. Si consiglia di controllare e proteggere le credenziali degli utenti di emergenza con l'autenticazione a più fattori (MFA).

## Termini e concetti dei ruoli
<a name="id_roles_terms-and-concepts"></a>

Di seguito sono elencati alcuni termini di base per aiutarti a iniziare a utilizzare i ruoli.

****Ruolo****  
UN'identità IAM che puoi creare nell'account che ha le autorizzazioni specifiche. Un ruolo IAM presenta alcune analogie con un utente IAM. Ruoli e utenti sono entrambi identità AWS con policy di autorizzazioni che determinano ciò che l'identità può o non può fare in AWS. Tuttavia, invece di essere associato in modo univoco a una persona, un ruolo è destinato a essere assunto da chiunque. Inoltre, un ruolo non ha credenziali a lungo termine standard associate (password o chiavi di accesso). Invece, quando assumi un ruolo, ti fornisce credenziali di sicurezza temporanee per la tua sessione di ruolo.  
I ruoli possono essere assunti da:  
+ Un utente IAM nello stesso Account AWS o in un altro Account AWS
+ Ruoli IAM nello stesso account
+ Service Principal, da utilizzare con AWS servizi e funzionalità come:
  + Servizi che consentono di eseguire codice su servizi di elaborazione, come Amazon EC2 o AWS Lambda
  + Funzionalità che eseguono azioni sulle tue risorse per tuo conto, come la replica di oggetti Amazon S3
  + Servizi che forniscono credenziali di sicurezza temporanee alle applicazioni eseguite all'esterno AWS, come IAM Roles Anywhere o Amazon ECS Anywhere
+ Un utente esterno autenticato da un gestore dell'identità digitale (IdP) compatibile con SAML 2.0 o OpenID Connect

****AWS ruolo del servizio****  
 Un ruolo di servizio è un [ruolo IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles.html) che un servizio assume per eseguire operazioni per tuo conto. Un amministratore IAM può creare, modificare ed eliminare un ruolo di servizio dall’interno di IAM. Per ulteriori informazioni, consulta [Create a role to delegate permissions to an Servizio AWS](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_create_for-service.html) nella *Guida per l’utente IAM*. 

****AWS ruolo collegato al servizio****  
 Un ruolo collegato al servizio è un tipo di ruolo di servizio collegato a un. Servizio AWS Il servizio può assumere il ruolo per eseguire un’operazione per tuo conto. I ruoli collegati al servizio vengono visualizzati nel tuo account Account AWS e sono di proprietà del servizio. Un amministratore IAM può visualizzare le autorizzazioni per i ruoli collegati al servizio, ma non modificarle.   
Se stai già utilizzando un servizio quando inizia a supportare i ruoli collegati al servizio, potresti ricevere un'e-mail che annuncia un nuovo ruolo nel tuo account. In questo caso, il servizio ha creato automaticamente il ruolo collegato al servizio nel tuo account. Non è necessario compiere alcuna operazione per supportare questo ruolo e non è necessario eliminarlo manualmente. Per ulteriori informazioni, consulta [Nel mio account è apparso un nuovo ruolo AWS](troubleshoot_roles.md#troubleshoot_roles_new-role-appeared).
Per informazioni su quali servizi supportano i ruoli collegati ai servizi, consulta la pagina [AWS servizi che funzionano con IAM](reference_aws-services-that-work-with-iam.md) e cerca i servizi per cui è indicato **Sì **nella colonna **Ruolo collegato ai servizi**. Scegliere **Sì** in corrispondenza di un link per visualizzare la documentazione relativa al ruolo collegato al servizio per tale servizio. Per ulteriori informazioni, consulta [Creare un ruolo collegato ai servizi](id_roles_create-service-linked-role.md).

****Concatenazione del ruolo****  
La concatenazione dei ruoli si verifica quando si utilizza un ruolo per assumere un secondo ruolo. È possibile eseguire il concatenamento dei ruoli tramite Console di gestione AWS cambiando ruolo AWS CLI, l'o l'API. Ad esempio, `RoleA` dispone dell'autorizzazione per assumere il ruolo `RoleB`. È possibile consentire a User1 di assumere `RoleA` utilizzando le proprie credenziali utente a lungo termine nell' AssumeRoleoperazione API. Questa restituisce le credenziali a breve termine del ruolo `RoleA`. Con la concatenazione del ruolo, puoi utilizzare le credenziali a breve termine del ruolo `RoleA` per abilitare l'Utente1 ad assumere il ruolo `RoleB`.  
Quando assumi un ruolo, puoi passare un tag di sessione e impostare il tag come transitivo. I tag di sessione transitivi vengono passati a tutte le sessioni successive in una concatenazione del ruolo. Per ulteriori informazioni sui tag di sessione, consulta [Passa i tag di sessione AWS STS](id_session-tags.md).  
Il concatenamento dei ruoli limita la Console di gestione AWS sessione di ruolo AWS dell'utente AWS CLI o dell'API a un massimo di un'ora. Si applica indipendentemente dalla durata massima della sessione configurata per i singoli ruoli. Quando si utilizza l'operazione [AssumeRole](https://docs.aws.amazon.com/STS/latest/APIReference/API_AssumeRole.html)API per assumere un ruolo, è possibile specificare la durata della sessione di ruolo con il `DurationSeconds` parametro. Puoi specificare un valore di parametro fino a 43200 secondi (12 ore), che dipende dall'[impostazione della durata massima della sessione](id_roles_update-role-settings.md#id_roles_update-session-duration) per il tuo ruolo. Tuttavia, se assumi un ruolo utilizzando la concatenazione dei ruoli e fornisci un valore del parametro `DurationSeconds` maggiore di un'ora, l'operazione ha esito negativo.  
Per informazioni sul passaggio a un ruolo in Console di gestione AWS, vedere[Passare da un utente a un ruolo IAM (console)](id_roles_use_switch-role-console.md).

****Delega****  
La concessione delle autorizzazioni a un altro utente per permettere l'accesso alle risorse di controllo. La delega comporta la configurazione di un trust tra due account. Il primo è l'account proprietario della risorsa (l'account che concede fiducia). Il secondo è l'account che contiene gli utenti che devono accedere alla risorsa (l'account attendibile). L'account a cui viene concessa fiducia e l'account che concede fiducia possono essere uno dei seguenti:  
+ Lo stesso account.
+ Account diversi che sono comunque sotto il controllo della tua organizzazione.
+ Due account di proprietà di organizzazioni diverse.
Per delegare l'autorizzazione per accedere a una risorsa,[ crea un ruolo IAM](id_roles_create_for-user.md) nell'account che concede fiducia che ha due policy collegate. Le *policy di autorizzazioni* concedono all'utente del ruolo le autorizzazioni necessarie per eseguire le attività previste sulla risorsa. La *policy di attendibilità* specifica quali membri degli account a cui viene concessa fiducia sono autorizzati ad assumere il ruolo.  
Quando si crea una politica di affidabilità, non è possibile specificare un carattere jolly (\$1) come parte di un ARN come elemento principale. La policy di affidabilità è associata al ruolo nell'account che concede fiducia e rappresenta una metà delle autorizzazioni. L'altra metà è una policy delle autorizzazioni collegata all'utente nell'account a cui viene concessa fiducia che [consente a quell'utente di passare al ruolo o di assumerlo](id_roles_use_permissions-to-switch.md). Un utente che assume un ruolo temporaneamente cede le proprie autorizzazioni e ottiene le autorizzazioni del ruolo. Quando l'utente esce o termina l'utilizzo del ruolo, le autorizzazioni originali dell'utente vengono ripristinate. Un parametro aggiuntivo chiamato [external ID](id_roles_common-scenarios_third-party.md#id_roles_third-party_external-id) contribuisce a garantire sicuro l'uso dei ruoli tra gli account che non vengono controllati dalla stessa organizzazione.

****Policy di trust****  
[Documento di policy JSON](reference_policies_grammar.md) in cui si definiscono i principali considerati *attendibili* per assumere il ruolo. Una policy di attendibilità del ruolo è una [policy basata sulle risorse](access_policies.md#policies_resource-based) collegata a un ruolo in IAM. I [principali](reference_policies_elements_principal.md) che è possibile specificare nella policy di attendibilità includono utenti, ruoli, account e servizi. Per ulteriori informazioni, consulta [How to use trust policies in IAM roles](https://aws.amazon.com/blogs//security/how-to-use-trust-policies-with-iam-roles/) nel *Blog sulla sicurezza di AWS *.

****Ruolo per l'accesso tra account****  
Un ruolo che concede l'accesso alle risorse in un account a un principale affidabile in un diverso account. I ruoli sono lo strumento principale per concedere l’accesso multi-account. Tuttavia, alcuni AWS servizi consentono di associare una policy direttamente a una risorsa (anziché utilizzare un ruolo come proxy). Queste sono chiamate politiche basate sulle risorse ed è possibile utilizzarle per concedere ai responsabili di un'altra persona l' Account AWS accesso alla risorsa. Alcune di queste risorse includono bucket Amazon Simple Storage Service (S3), vault Amazon Glacier, argomenti Amazon Simple Notification Service (SNS) e code Amazon Simple Queue Service (SQS). Per informazioni su quali servizi supportano le policy basate su risorse, consulta [AWS servizi che funzionano con IAM](reference_aws-services-that-work-with-iam.md). Per ulteriori informazioni sulle policy basate sulle risorse, consulta [Accesso alle risorse multi-account in IAM](access_policies-cross-account-resource-access.md).

## Risorse aggiuntive
<a name="id_roles_additional-resources"></a>

Le seguenti risorse possono rivelarsi utili per saperne di più sulla terminologia di IAM relativa ai ruoli IAM.
+ **I principali** sono entità in grado di eseguire azioni e AWS accedere alle risorse. Un principale può essere un Utente root dell'account AWS utente IAM o un ruolo. Un principio che rappresenta l'identità di un AWS servizio è un [principale di servizio](reference_policies_elements_principal.md#principal-services). Utilizza l'elemento Principal nelle policy di attendibilità per il ruolo per definire i principali attendibili per assumere il ruolo.

   Per ulteriori informazioni ed esempi di principali a cui è possibile consentire l'assunzione di un ruolo, consulta [AWS Elementi della policy JSON: Principal](reference_policies_elements_principal.md). 
+ La **federazione delle identità** crea una relazione di fiducia tra un provider di identità esterno e AWS. Puoi utilizzare il tuo provider OpenID Connect (OIDC) o Security Assertion Markup Language (SAML) 2.0 esistente per gestire chi può accedere alle risorse AWS . Quando utilizzi OIDC e SAML 2.0 per configurare una relazione di fiducia tra questi provider di identità esterni e AWS , all'utente viene assegnato un ruolo IAM. e riceve credenziali provvisorie che gli consentono di accedere alle tue risorse AWS .

  Per ulteriori informazioni sui principali federati, consulta [Provider di identità e federazione in AWS](id_roles_providers.md).
+ I **federated principal** sono identità esistenti provenienti dall'elenco degli utenti aziendali o da Directory Service un provider OIDC. AWS [assegna un ruolo a un principale federato quando l'accesso viene richiesto tramite un provider di identità.](id_roles_providers.md)

  Per ulteriori informazioni sui principali federati SAML e OIDC, consulta [Sessioni e ruoli dell’utente federato](introduction_access-management.md#intro-access-roles).
+ Le **policy di autorizzazione** sono policy basate sull'identità che definiscono le azioni e le risorse che il ruolo può utilizzare. Il documento è scritto in base alle regole del linguaggio della policy IAM. 

  Per ulteriori informazioni, consulta [Riferimento alla policy JSON IAM](reference_policies.md).
+ Il **limite delle autorizzazioni** è una funzione avanzata in cui le policy vengono utilizzate per limitare il numero massimo di autorizzazioni che una policy basata su identità può concedere a un ruolo. Non è possibile applicare un limite delle autorizzazioni a un ruolo collegato al servizio.

  Per ulteriori informazioni, consulta [Limiti delle autorizzazioni per le entità IAM](access_policies_boundaries.md).

# Problema del "confused deputy"
<a name="confused-deputy"></a>

Con "confused deputy" si intende un problema di sicurezza in cui un'entità che non dispone dell'autorizzazione per eseguire una certa operazione può costringere un'entità con più privilegi a eseguire tale operazione. Per evitare che ciò accada, AWS fornisce strumenti che ti aiutano a proteggere il tuo account se fornisci a terzi (i cosiddetti *cross-account*) o ad altri AWS servizi (noti come *cross-service*) l'accesso alle risorse del tuo account.

A volte, potresti dover concedere a terzi l'accesso alle tue AWS risorse (accesso delegato). Ad esempio, decidete di assumere una società terza chiamata Example Corp per monitorare Account AWS e ottimizzare i costi. Per tenere traccia delle vostre spese giornaliere, Example Corp deve accedere alle vostre AWS risorse. Example Corp controlla anche molti altri Account AWS per altri clienti. Puoi utilizzare un ruolo IAM per stabilire una relazione di fiducia tra il tuo account Account AWS e quello di Example Corp. Un aspetto importante di questo scenario è l’*ID esterno*, un identificativo facoltativo che è possibile utilizzare in una policy di attendibilità del ruolo IAM per indicare chi può assumere il ruolo. La funzione principale dell'ID esterno è quella di risolvere e prevenire il problema del "confused deputy" (delegato confuso).

Alcuni AWS servizi (servizi di chiamata) utilizzano il proprio AWS service principal per accedere alle AWS risorse di altri AWS servizi (chiamati servizi). In alcune di queste interazioni di servizio è possibile configurare i servizi di chiamata in modo che comunichino con le risorse di un servizio chiamato in un altro modo Account AWS. Un esempio di ciò è la configurazione AWS CloudTrail per la scrittura su un bucket Amazon S3 centrale che si trova in un altro. Account AWS Al servizio di chiamata CloudTrail viene concesso l'accesso al bucket S3 utilizzando la policy del bucket S3 aggiungendo un'istruzione allow for. `cloudtrail.amazonaws.com`

Quando un responsabile di un AWS servizio chiamante accede a una risorsa da un servizio chiamato, la politica delle risorse del servizio chiamato autorizza solo il responsabile del servizio e non l'attore che ha configurato il AWS servizio chiamante. Ad esempio, un bucket S3 che si fida del responsabile del CloudTrail servizio senza condizioni potrebbe ricevere CloudTrail i log configurati da un amministratore fidato, ma anche CloudTrail i log da un attore non autorizzato Account AWS che lo utilizza Account AWS, se conosce il nome del bucket S3.

Il confuso problema del vicedirettore sorge quando un attore sfrutta la fiducia del responsabile del AWS servizio per accedere a risorse a cui non dovrebbe avere accesso.

## Prevenzione del problema "confused deputy" tra account
<a name="mitigate-confused-deputy"></a>

Il seguente diagramma illustra il problema "confused deputy" tra account.

![\[Descrizione di un problema "confused deputy".\]](http://docs.aws.amazon.com/it_it/IAM/latest/UserGuide/images/confuseddeputyproblem2.png)


In questo scenario sono validi i requisiti riportati di seguito:
+ **AWS 1** è tuo Account AWS.
+ **AWS 1: ExampleRole** è un ruolo nel tuo account. La policy di affidabilità di questo ruolo considera attendibile Example Corp specificando l'account AWS di Example Corp come account che può assumere il ruolo.

Ecco che cosa succede:

1. Quando inizi a utilizzare il servizio di Example Corp, fornisci l'ARN **AWS di 1 ExampleRole**: a Example Corp.

1. Example Corp utilizza quel ruolo ARN per ottenere credenziali di sicurezza temporanee per accedere alle risorse del tuo. Account AWS In questo modo, l'Utente A considera Example Corp come "deputy" attendibile che può agire per conto dell'Utente A stesso.

1. Anche un altro AWS cliente inizia a utilizzare il servizio di Example Corp e fornisce anche l'ARN **AWS di 1 ExampleRole**: for Example Corp da utilizzare. Presumibilmente l'altro cliente ha imparato o indovinato il numero **AWS 1: ExampleRole**, che non è un segreto.

1. Quando l'altro cliente chiede a Example Corp di accedere alle AWS risorse del suo account (quello che afferma di essere), Example Corp utilizza **AWS 1: ExampleRole** per accedere alle risorse del tuo account.

Questo è il modo in cui altri clienti possono ottenere l'accesso non autorizzato alle risorse di un utente, in questo caso dell'Utente A. Poiché il cliente Utente B è stato in grado di ingannare Example Corp e lo ha indotto ad agire involontariamente sulle risorse, Example Corp è ora un "confused deputy".

Example Corp può risolvere il problema "confused deputy" chiedendo di includere la condizione di verifica `ExternalId` nella policy di affidabilità del ruolo. Example Corp genera un valore `ExternalId` univoco per ogni cliente e lo utilizza nella sua richiesta per assumere il ruolo. Il valore `ExternalId` deve essere univoco tra i clienti di Example Corp e controllato da Example Corp, non dai suoi clienti. Questo è il motivo per cui i clienti lo ricevono da Example Corp e non lo creano in autonomia. In questo modo si evita che Example Corp si comporti in modo confuso e consenta l'accesso alle risorse di un altro account. AWS 

In questo scenario, immagina che l'ID univoco di Example Corp per te sia 12345 e quello per l'altro cliente sia 67890. Questi ID sono semplificati per comodità in questo scenario. In genere, questi identificatori sono. GUIDs Supponendo che questi identificatori siano univoci tra i clienti di Example Corp, sono valori sensibili da utilizzare per l'ID esterno. 

Example Corp ti fornisce il valore ID esterno 12345. È necessario aggiungere un elemento `Condition` alla policy di attendibilità del ruolo che richieda che il valore [https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_iam-condition-keys.html#condition-keys-sts](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_iam-condition-keys.html#condition-keys-sts) sia 12345, come segue:

------
#### [ JSON ]

****  

```
{
  "Version":"2012-10-17",		 	 	 
  "Statement": {
    "Effect": "Allow",
    "Principal": {
      "AWS": "Example Corp's AWS Account ID"
    },
    "Action": "sts:AssumeRole",
    "Condition": {
      "StringEquals": {
        "sts:ExternalId": "12345"
      }
    }
  }
}
```

------

L'elemento Condition di questa politica consente a Example Corp di assumere il ruolo solo quando la chiamata AssumeRole API include il valore ID esterno 12345. Example Corp si assicura che, ogni volta che assume un ruolo per conto di un cliente, includa sempre il valore dell'ID esterno del cliente nella chiamata. AssumeRole Anche se un altro cliente fornisce a Example Corp il tuo ARN, non può controllare l'ID esterno che Example Corp include nella sua richiesta. AWS In questo modo è possibile evitare che un cliente non autorizzato acceda alle tue risorse.

Il diagramma seguente illustra tale processo.

![\[Come mitigare un problema "confused deputy".\]](http://docs.aws.amazon.com/it_it/IAM/latest/UserGuide/images/confuseddeputymitigation2.png)


1. Come in precedenza, quando si inizia a utilizzare il servizio di Example Corp, si fornisce l'ARN **AWS di 1 ExampleRole**: a Example Corp.

1.  Quando Example Corp utilizza quel ruolo ARN per assumere il **AWS ruolo 1 ExampleRole**:, Example Corp include l'ID esterno (12345) nella chiamata API. AssumeRole L'ID esterno corrisponde alla politica di fiducia del ruolo, quindi la chiamata AssumeRole API ha esito positivo e Example Corp ottiene le credenziali di sicurezza temporanee per accedere alle risorse del tuo. Account AWS

1. Anche un altro AWS cliente inizia a utilizzare il servizio di Example Corp e, come in precedenza, fornisce anche l'ARN **AWS di 1 ExampleRole**: for Example Corp da utilizzare. 

1. Ma questa volta, quando Example Corp tenta di assumere il ruolo **AWS 1: ExampleRole**, fornisce l'ID esterno associato all'altro cliente (67890). L'altro cliente non ha modo di modificare questa operazione. Example Corp opera in questo modo perché la richiesta di utilizzare il ruolo proviene dall'altro cliente, pertanto 67890 indica la circostanza in cui Example Corp sta operando. Poiché hai aggiunto una condizione con il tuo ID esterno (12345) alla politica di fiducia **AWS 1: ExampleRole**, la AssumeRole chiamata API ha esito negativo. All'altro cliente viene impedito di ottenere l'accesso non autorizzato alle risorse nel tuo account (indicato dalla "X" rossa nel diagramma).

L'ID esterno consente di impedire a qualsiasi altro cliente di ingannare Example Corp e indurre l'azienda ad accedere involontariamente alle risorse.

## Prevenzione del problema "confused deputy" tra servizi
<a name="cross-service-confused-deputy-prevention"></a>

Il diagramma seguente illustra il problema dell'assistente confuso tra servizi utilizzando l' CloudTrail esempio di interazione con Amazon S3, in cui un attore non autorizzato scrive i log su un bucket Amazon S3 CloudTrail a cui non è autorizzato ad accedere.

![\[A un attore non autorizzato viene concesso l'accesso a un bucket Amazon S3 in un altro account utilizzando CloudTrail il service principal.\]](http://docs.aws.amazon.com/it_it/IAM/latest/UserGuide/images/cross-service-confused-deputy1.png)


Per evitare che un attore non autorizzato utilizzi la fiducia di un AWS responsabile per accedere alle tue risorse, i responsabili del AWS servizio includono informazioni sulla AWS risorsa e sull' AWS organizzazione per cui agiscono. Account AWS

Queste informazioni sono disponibili in valori chiave globali che possono essere utilizzati in una politica delle risorse o in una politica di controllo delle risorse per le richieste effettuate dai responsabili del AWS servizio. Ti consigliamo di utilizzare[aws:SourceArn](reference_policies_condition-keys.md#condition-keys-sourcearn), [aws:SourceAccount](reference_policies_condition-keys.md#condition-keys-sourceaccount)[aws:SourceOrgID](reference_policies_condition-keys.md#condition-keys-sourceorgid), o [aws:SourceOrgPaths](reference_policies_condition-keys.md#condition-keys-sourceorgpaths) nelle politiche relative alle risorse laddove al responsabile del AWS servizio sia concessa l'autorizzazione ad accedere a una delle tue risorse. Queste chiavi di condizione consentono di verificare, nell'ambito delle politiche relative alle risorse o alle politiche di controllo delle risorse, che i responsabili dei AWS servizi che accedono alle risorse lo facciano per conto delle AWS risorse Account AWS, o come previsto dall' AWS Organizations utente.
+ `aws:SourceArn`Da utilizzare per consentire a un responsabile del AWS servizio di accedere alle risorse per conto di una risorsa specifica, ad esempio un AWS CloudTrail percorso o una AppStream flotta specifici.
+ `aws:SourceAccount`Da utilizzare per consentire a un responsabile del AWS servizio di accedere alle risorse per conto di una determinata persona Account AWS.
+ `aws:SourceOrgID`Da utilizzare per consentire a un responsabile AWS del servizio di accedere alle risorse dell'utente per conto di una persona specifica AWS Organizations.
+ `aws:SourceOrgPaths`Da utilizzare per consentire al responsabile del AWS servizio di accedere alle risorse per conto di un AWS Organizations percorso specifico.

Il diagramma seguente illustra lo scenario sostitutivo confuso tra diversi servizi in cui una risorsa viene configurata con la chiave di contesto della condizione `aws:SourceAccount` globale e un attore non autorizzato di un altro account tenta di accedere a AWS risorse a cui non dovrebbe avere accesso.

![\[A un attore non autorizzato viene negato l'accesso a un bucket Amazon S3 in un altro account utilizzando CloudTrail il service principal.\]](http://docs.aws.amazon.com/it_it/IAM/latest/UserGuide/images/cross-service-confused-deputy2.png)


L’utilizzo delle chiavi di condizione globali `aws:SourceArn`, `aws:SourceAccount`, `aws:SourceOrgID` e `aws:SourceOrgPaths` in una policy ti aiuta a garantire che i principali del servizio accedano alle tue risorse per tuo conto. Ti consigliamo di utilizzare queste chiavi di condizione ogni volta che l'accesso a una delle tue risorse viene concesso a un AWS responsabile del servizio. 

**Nota**  
Alcune Servizio AWS interazioni prevedono controlli aggiuntivi che aiutano a proteggersi da problemi amministrativi confusi tra diversi servizi che mettono alla prova l'accesso degli utenti a una risorsa. Ad esempio, quando la concessione di una chiave KMS viene concessa a un utente Servizio AWS, AWS KMS utilizza il contesto di crittografia associato alla risorsa e la concessione della chiave per contribuire alla protezione da problemi connessi alla confusione tra i vari servizi.  
Consulta la documentazione dei servizi in uso per ulteriori informazioni sui meccanismi specifici del servizio che possono aiutare a evitare rischi derivanti dal problema “confused deputy” tra servizi diversi e per scoprire se `aws:SourceArn`, `aws:SourceAccount`, `aws:SourceOrgID` e `aws:SourceOrgPaths` sono supportati.

## Protezione dal problema “confused deputy” tra servizi diversi con le policy basate su risorse
<a name="cross-service-confused-deputy-prevention-resource"></a>

La seguente politica di esempio concede l'`cloudtrail.amazonaws.com`accesso principale del servizio al bucket Amazon S3, arn:aws:s3: ::amzn-s3-demo-bucket1, solo quando il responsabile del servizio agisce per conto di 111122223333. Account AWS 

------
#### [ JSON ]

****  

```
{
    "Version":"2012-10-17",		 	 	 
    "Statement": [
        {
            "Sid": "CloudTrailAclCheck",
            "Effect": "Allow",
            "Principal": {"Service": "cloudtrail.amazonaws.com"},
            "Action": "s3:GetBucketAcl",
            "Resource": "arn:aws:s3:::amzn-s3-demo-bucket1",
            "Condition": {
                "StringEquals": {
                    "aws:SourceAccount": "111122223333"
                }
            }
        },
        {
            "Sid": "AWSCloudTrailWrite",
            "Effect": "Allow",
            "Principal": {"Service": "cloudtrail.amazonaws.com"},
            "Action": "s3:PutObject",
            "Resource": "arn:aws:s3:::amzn-s3-demo-bucket1/[optionalPrefix]/Logs/myAccountID/*",
            "Condition": {
                "StringEquals": {
                    "aws:SourceAccount": "111122223333"
                }
            }
        }
    ]
}
```

------

Questa policy bucket di esempio concede al servizio l'`appstream.amazonaws.com`accesso principale allo script powershell examplefile.psh all'interno di s3://amzn-s3-demo-bucket2 solo quando agisce per conto della AppStream flotta Amazon specificata, specificando la flotta con cui arn. `aws:SourceArn`

------
#### [ JSON ]

****  

```
{
    "Version":"2012-10-17",		 	 	 
    "Statement": [
        {
            "Effect": "Allow",
            "Principal": {
                "Service": [
                    "appstream.amazonaws.com"
                ]
            },
            "Action": "s3:GetObject",
            "Resource": "arn:aws:s3:::amzn-s3-demo-bucket2/examplefile.psh",
            "Condition": {
                "ArnEquals": {
                    "aws:SourceArn": "arn:aws:appstream:us-east-1:111122223333:fleet/ExampleFleetName"
                } 
            }
        }
    ]
}
```

------

## Protezione dal problema “confused deputy” tra servizi diversi con le policy di controllo delle risorse
<a name="cross-service-confused-deputy-prevention-resource-control"></a>

Puoi utilizzare le politiche di controllo delle risorse (RCP) per applicare controlli sostitutivi confusi tra diversi servizi alle risorse supportate. Servizi AWS RCPs consentono di applicare centralmente alle risorse controlli sostitutivi confusi tra diversi servizi. È possibile utilizzare chiavi di condizione AWS Organizations, `aws:SourceOrgId` analogamente a quelle `aws:SourceOrgPaths` RCPs associate alle unità organizzative (OU) o Account AWS all'interno dell'organizzazione, senza aggiungere dichiarazioni a politiche specifiche basate sulle risorse. *Per ulteriori informazioni sui RCPs servizi supportati, consulta [le politiche di controllo delle risorse (RCPs)](https://docs.aws.amazon.com/organizations/latest/userguide/orgs_manage_policies_rcps.html) nella Guida per l'AWS Organizations utente.*

L'esempio seguente RCP nega ai responsabili AWS del servizio l'accesso ai bucket Amazon S3 nei tuoi account membro quando non `aws:SourceOrgID` è uguale a o-. ExampleOrg Un'autorizzazione corrispondente deve essere presente nella policy basata sulle risorse del bucket S3 per consentire i principali con un valore pari a o-. Servizio AWS `SourceOrgID` ExampleOrg

Questa policy applica il controllo solo alle richieste dei principali del servizio (`"Bool": {"aws:PrincipalIsAWSService": "true"}`) che hanno la chiave `aws:SourceAccount` (`"Null": {"aws:SourceAccount": "false"}`), in modo che le integrazioni di servizi che non richiedono l’uso di questa chiave di condizione e le chiamate da parte dei principali non vengano influenzate. Se la chiave di condizione `aws:SourceAccount` è presente nel contesto della richiesta, la condizione Null verrà valutata come true, determinando l’applicazione della chiave `aws:SourceOrgID`. Utilizziamo invece `aws:SourceAccount` al posto di `aws:SourceOrgID` nell’operatore di condizione Null in modo che il controllo si applichi ancora se la richiesta proviene da un account che non appartiene a un’organizzazione.

------
#### [ JSON ]

****  

```
{
  "Version":"2012-10-17",		 	 	 
  "Statement": [
    {
      "Sid": "RCPEnforceConfusedDeputyProtectionForS3",
      "Effect": "Deny",
      "Principal": "*",
      "Action": [
        "s3:*"
      ],
      "Resource": "*",
      "Condition": {
        "StringNotEqualsIfExists": {
          "aws:SourceOrgID": "o-ExampleOrg"
        },
        "Null": {
          "aws:SourceAccount": "false"
        },
        "Bool": {
          "aws:PrincipalIsAWSService": "true"
        }
      }
    }
  ]
}
```

------

# Scenari comuni per i ruoli IAM
<a name="id_roles_common-scenarios"></a>

Come per la maggior parte delle AWS funzionalità, in genere hai due modi per utilizzare un ruolo: in modo interattivo nella console IAM o a livello di codice con gli AWS CLI strumenti per Windows PowerShell o l'API.
+ Gli utenti IAM nell'account che utilizza la console IAM possono *passare* a un ruolo per utilizzare temporaneamente le autorizzazioni del ruolo nella console. Gli utenti abbandonano le loro autorizzazioni originali e assumono le autorizzazioni assegnate al ruolo. Quando gli utenti escono dal ruolo, le autorizzazioni originali vengono ripristinate.
+ Un'applicazione o un servizio offerto da AWS (come Amazon EC2) può *assumere* un ruolo richiedendo credenziali di sicurezza temporanee per un ruolo a cui effettuare richieste programmatiche. AWSÈ possibile utilizzare un ruolo in questo modo per non dover condividere o gestire le credenziali di sicurezza a lungo termine (ad esempio creando un utente IAM) per ogni entità che richiede l'accesso a una risorsa.

**Nota**  
In questa guida le frasi *passare a un ruolo* e *assumere un ruolo* vengono utilizzate in modo intercambiabile.

Il modo più semplice per utilizzare i ruoli è quello di concedere agli utenti IAM le autorizzazioni per passare ai ruoli creati da te all'interno del tuo o di un altro Account AWS. È possibile passare da un ruolo all'altro facilmente utilizzando la console IAM per utilizzare le autorizzazioni che non si desidera abbiano normalmente e uscire dal ruolo per cedere a tali autorizzazioni. Ciò può aiutare a impedire l'accesso *accidentale* alle risorse sensibili o la loro modifica.

Per utilizzi più complessi di ruoli, ad esempio la concessione di accesso alle applicazioni e servizi, o gli utenti federati esterni, è possibile richiamare l'API `AssumeRole`. Questa chiamata API restituisce un set di credenziali temporanee che l'applicazione può utilizzare in successive chiamate API. Le operazioni tentate con le credenziali temporanee dispongono solo delle autorizzazioni concesse dal ruolo associato. Un'applicazione non deve "uscire" dal ruolo nello stesso modo di un utente nella console, ma l'applicazione smette semplicemente di utilizzare le credenziali temporanee e riprende le chiamate con le credenziali originali.

Gli utenti federati accedono utilizzando le credenziali di un provider di identità (IdP). AWS fornisce quindi credenziali temporanee all'IdP affidabile da trasmettere all'utente per includerle nelle AWS successive richieste di risorse. Queste credenziali forniscono le autorizzazioni concesse al ruolo assegnato.

Questa sezione fornisce una panoramica dei seguenti scenari:
+ [Fornisci l'accesso a un utente IAM in uno Account AWS di tua proprietà per accedere alle risorse di un altro account di tua proprietà](id_roles_common-scenarios_aws-accounts.md)
+ [Fornire l'accesso a carichi di lavoro non AWS](id_roles_common-scenarios_non-aws.md)
+ [Fornire l'accesso agli utenti IAM negli Account AWS di proprietà di terze parti](id_roles_common-scenarios_third-party.md)
+ [Fornisci l'accesso ai servizi offerti dalle AWSAWS risorse](id_roles_common-scenarios_services.md)
+ [Fornire l'accesso agli utenti autenticati esternamente (federazione delle identità)](id_roles_common-scenarios_federated-users.md)

# Accesso per un utente IAM in un altro Account AWS di tua proprietà
<a name="id_roles_common-scenarios_aws-accounts"></a>

Puoi concedere ai tuoi utenti IAM il permesso di passare a ruoli interni a te Account AWS o a ruoli definiti in altri ruoli Account AWS di tua proprietà. 

**Nota**  
Se desideri concedere l'accesso a un account che non possiedi né controlli, consulta [Accesso a Account AWS siti di proprietà di terzi](id_roles_common-scenarios_third-party.md) più avanti in questo argomento. 

Immaginiamo di avere delle istanze Amazon EC2 critiche per la tua organizzazione. Invece di concedere direttamente agli utenti l'autorizzazione a terminare le istanze, è possibile creare un ruolo con tali privilegi. Quindi consentire agli amministratori di passare al ruolo quando è necessario terminare un'istanza. In questo modo si aggiungono i seguenti livelli di protezione alle istanze:
+ È necessario concedere esplicitamente agli utenti il permesso di assumere quel ruolo.
+ I tuoi utenti devono passare attivamente al ruolo utilizzando Console di gestione AWS o assumere il ruolo utilizzando l' AWS API AWS CLI o.
+ È possibile aggiungere una Multi-Factor Authentication (MFA) al ruolo, in modo che solo gli utenti che accedono con un dispositivo MFA possano assumere quel ruolo. Per ulteriori informazioni su come configurare un ruolo in modo che gli utenti che assumono il ruolo debbano essere prima autenticati utilizzando l'autenticazione a più fattori (MFA), consulta [Accesso sicuro alle API con MFA](id_credentials_mfa_configure-api-require.md).

Consigliamo di utilizzare questo approccio per applicare il *principio di privilegio minimo*. Ciò significa limitare l'uso di autorizzazioni elevate unicamente a quelle volte in cui sono necessarie per operazioni specifiche. Per impedire le modifiche accidentali apportate agli ambienti sensibili, puoi utilizzare i ruoli, soprattutto se combinati con attività di [audit](cloudtrail-integration.md) per garantire che vengano utilizzati solo quando necessario.

Quando si crea un ruolo per questo scopo, è necessario specificare l'ID degli account da cui gli utenti devono accedere nell'elemento `Principal` della policy di affidabilità del ruolo. È quindi possibile concedere agli utenti specifici in tali altri account le autorizzazioni per passare al ruolo. Per capire se i principali negli account esterni alla zona di attendibilità (organizzazione o account attendibile) dispongono dell'accesso per assumere i ruoli, consulta [Cos'è IAM Access Analyzer?](https://docs.aws.amazon.com/IAM/latest/UserGuide/what-is-access-analyzer.html).

Un utente in un account può passare a un ruolo dello stesso o di un altro account. Mentre si usa il ruolo, l'utente è in grado di eseguire solo le azioni e accedere solo alle risorse consentite dal ruolo; le loro autorizzazioni utente originali sono sospese. Quando l'utente esce dal ruolo, le autorizzazioni utente originali vengono ripristinate.

## Esempio di uno scenario in cui si utilizzano account di sviluppo e produzione separati
<a name="id_roles_common-scenarios_aws-accounts-example"></a>

Immaginate che la vostra organizzazione disponga Account AWS di più elementi per isolare un ambiente di sviluppo da un ambiente di produzione. Gli utenti nell'account di sviluppo potrebbero occasionalmente aver bisogno di accedere alle risorse nell'account di produzione. Ad esempio, potrebbe essere necessario l'accesso a più account quando si sta richiedendo un aggiornamento dall'ambiente di sviluppo all'ambiente di produzione. Anche se è possibile creare identità separate (e password) per gli utenti che lavorano con entrambi gli account, la gestione delle credenziali per più account complica la gestione delle identità. Nell'illustrazione seguente, tutti gli utenti vengono gestiti nell'account di sviluppo, ma per alcuni sviluppatori è necessario un accesso limitato all'account di produzione. L'account di sviluppo dispone di due gruppi: collaudatori e sviluppatori, e ciascun gruppo ha la propria policy.

![\[Utilizzare un ruolo per delegare le autorizzazioni a un utente in un account diverso\]](http://docs.aws.amazon.com/it_it/IAM/latest/UserGuide/images/roles-usingroletodelegate.png)


1. Nell'account di produzione, un amministratore utilizza IAM per creare il ruolo `UpdateApp` in tale account. Nel ruolo, l'amministratore definisce una policy di affidabilità che specifica l'account di sviluppo come `Principal`; in tal modo gli utenti autorizzati dall'account di sviluppo possono utilizzare il ruolo `UpdateApp`. L'amministratore definisce inoltre una policy delle autorizzazioni per il ruolo che specifica le autorizzazioni in lettura e scrittura per il bucket Amazon S3 denominato `productionapp`.

   L'amministratore quindi condivide le informazioni appropriate con chiunque debba assumere quel ruolo. Tali informazioni sono il numero di account e il nome del ruolo (per gli utenti della AWS console) o l'Amazon Resource Name (ARN) (per AWS CLI l'accesso all' AWS API). L'ARN del ruolo può essere simile a `arn:aws:iam::123456789012:role/UpdateApp`, dove il ruolo è denominato `UpdateApp` ed è stato creato nel numero di account 123456789012.
**Nota**  
L'amministratore può eventualmente configurare il ruolo in modo che gli utenti che assumono il ruolo debbano essere prima autenticati utilizzando l'autenticazione a più fattori (MFA). Per ulteriori informazioni, consulta [Accesso sicuro alle API con MFA](id_credentials_mfa_configure-api-require.md). 

1. Nell'account di sviluppo, un amministratore concede ai membri del gruppo di sviluppatori l'autorizzazione a cambiare il ruolo. Ciò viene fatto concedendo al gruppo Developers l'autorizzazione a chiamare l'`AssumeRole`API AWS Security Token Service (AWS STS) per il `UpdateApp` ruolo. Qualsiasi utente IAM che appartiene al gruppo Sviluppatori nell'account di sviluppo può ora passare al ruolo `UpdateApp` nell'account di produzione. Gli altri utenti che non appartengono al gruppo di sviluppatori non hanno il permesso di passare al ruolo e pertanto non sono in grado di accedere al bucket S3 nell'account di produzione.

1. L'utente richiede di cambiare il ruolo:
   + AWS **console: l'utente sceglie il nome dell'account nella barra di navigazione e sceglie Switch Role.** L'utente specifica l'ID account (o alias) e il nome del ruolo. In alternativa, l'utente può fare clic su un collegamento inviato nell'e-mail dall'amministratore. Il link indirizza l'utente alla pagina **Switch Role (Cambia ruolo)** con i dettagli già compilati.
   + AWS API/AWS CLI: Un utente del gruppo Developers dell'account di sviluppo chiama la `AssumeRole` funzione per ottenere le credenziali per il ruolo. `UpdateApp` L'utente specifica l'ARN del ruolo `UpdateApp` come parte della chiamata. Se un utente nel gruppo di collaudatori inoltra la stessa richiesta, la richiesta ha esito negativo perché i collaudatori non hanno l'autorizzazione a chiamare `AssumeRole` per il `UpdateApp` ruolo ARN.

1. AWS STS restituisce credenziali temporanee:
   + AWS console: AWS STS verifica la richiesta con la politica di fiducia del ruolo per garantire che la richiesta provenga da un'entità attendibile (che è: l'account di sviluppo). Dopo la verifica, AWS STS restituisce [le credenziali di sicurezza temporanee](https://docs.aws.amazon.com/STS/latest/UsingSTS/Welcome.html) alla AWS console.
   + API/CLI: AWS STS verifica la richiesta rispetto alla politica di fiducia del ruolo per garantire che la richiesta provenga da un'entità attendibile (che è: l'account Development). Dopo la verifica, AWS STS restituisce le [credenziali di sicurezza temporanee](https://docs.aws.amazon.com/STS/latest/UsingSTS/Welcome.html) all'applicazione.

1. Le credenziali temporanee consentono l'accesso alla AWS risorsa:
   + AWS console: la AWS console utilizza le credenziali temporanee per conto dell'utente per tutte le azioni successive della console, in questo caso, per leggere e scrivere nel `productionapp` bucket. La console non è in grado di accedere ad altre risorse nell'account di produzione. Quando l'utente esce dal ruolo, le autorizzazioni dell'utente tornano a quelle originali detenute prima di cambiare il ruolo.
   + API/CLI: l'applicazione utilizza le credenziali di sicurezza provvisorie per aggiornare il bucket `productionapp`. Con le credenziali di sicurezza provvisorie, l'applicazione può solo leggere e scrivere al bucket `productionapp` e non è in grado di accedere a qualsiasi altra risorsa nell'account di produzione. L'applicazione non deve uscire dal ruolo, bensì cessa di utilizzare le credenziali provvisorie e utilizza le credenziali originali nelle successive chiamate API.

## Risorse aggiuntive
<a name="id_roles_common-scenarios_more-info"></a>

Per ulteriori informazioni, consulta gli argomenti seguenti:
+ [Tutorial IAM: delega l'accesso tra AWS account utilizzando i ruoli IAM](tutorial_cross-account-with-roles.md)

# Accesso per AWS carichi non di lavoro
<a name="id_roles_common-scenarios_non-aws"></a>

Un [ruolo IAM](id_roles.md) è un oggetto in AWS Identity and Access Management (IAM) a cui vengono assegnate le [autorizzazioni](access_policies.md). Quando [assumi quel ruolo](id_roles_manage-assume.md) utilizzando un'identità IAM o un'identità esterna a AWS, ti vengono fornite credenziali di sicurezza temporanee per la tua sessione di ruolo. Potresti avere carichi di lavoro in esecuzione nel tuo data center o in un'altra infrastruttura esterna AWS che deve accedere alle tue AWS risorse. Invece di creare, distribuire e gestire chiavi di accesso a lungo termine, puoi utilizzare AWS Identity and Access Management Roles Anywhere (IAM Roles Anywhere) per autenticare i tuoi carichi non di lavoro. AWS IAM Roles Anywhere utilizza i certificati X.509 dell'autorità di certificazione (CA) per autenticare le identità e fornire l'accesso in modo sicuro alle credenziali temporanee fornite da Servizi AWS un ruolo IAM.

**Per utilizzare IAM Roles Anywhere**

1. Configura una CA utilizzando [AWS Autorità di certificazione privata](https://docs.aws.amazon.com/privateca/latest/userguide/PcaWelcome.html) o utilizza una CA dalla propria infrastruttura PKI.

1. Dopo aver impostato una CA, viene creato un oggetto in IAM Roles Anywhere chiamato *ancoraggio di fiducia*. Questo ancoraggio stabilisce la fiducia tra IAM Roles Anywhere e la tua CA per l'autenticazione.

1. Puoi quindi configurare i ruoli IAM esistenti o creare nuovi ruoli che si fidino del servizio IAM Roles Anywhere.

1. Autentica i tuoi AWS carichi non di lavoro con IAM Roles Anywhere utilizzando il trust anchor. AWS concede le credenziali temporanee non legate al AWS carico di lavoro al ruolo IAM che ha accesso alle tue risorse. AWS 

## Risorse aggiuntive
<a name="id_roles_non-aws_additional_resources"></a>

Le risorse seguenti possono rivelarsi utili per fornire l'accesso a carichi di lavoro non AWS .
+ Per ulteriori informazioni sulla configurazione di Ruoli IAM Anywhere, consulta l'argomento [Cos'è AWS Identity and Access Management Ruoli Anywhere](https://docs.aws.amazon.com/rolesanywhere/latest/userguide/introduction.html) nella *Guida dell'utente di IAM Roles Anywhere*.
+ Per scoprire come configurare un'infrastruttura a chiave pubblica (PKI) per IAM Roles Anywhere, consulta [IAM Roles Anywhere con un'autorità di certificazione esterna](https://aws.amazon.com/blogs/) nel *Blog sulla sicurezza AWS *.

# Accesso a Account AWS siti di proprietà di terzi
<a name="id_roles_common-scenarios_third-party"></a>

Quando terze parti richiedono l'accesso alle AWS risorse dell'organizzazione, puoi utilizzare i ruoli per delegare l'accesso a tali risorse. Ad esempio, una terza parte potrebbe fornire un servizio per la gestione delle risorse AWS . Con i ruoli IAM, puoi concedere a queste terze parti l'accesso alle tue AWS risorse senza condividere le tue credenziali AWS di sicurezza. Invece, la terza parte può accedere alle tue AWS risorse assumendo un ruolo da te creato all'interno delle tue. Account AWS Per capire se i principali negli account esterni alla zona di attendibilità (organizzazione o account attendibile) dispongono dell'accesso per assumere i ruoli, consulta [Cos'è IAM Access Analyzer?](https://docs.aws.amazon.com/IAM/latest/UserGuide/what-is-access-analyzer.html).

Le terze parti devono fornirti le informazioni seguenti per permetterti di creare un ruolo che possa essere da loro assunto:
+ **L' Account AWS ID della terza parte**. Puoi specificare il loro ID dell' Account AWS come entità principale quando definisci la policy di affidabilità per il ruolo.
+ **Un ID esterno da associare in modo univoco con il ruolo.** L'ID esterno può essere qualsiasi identificatore noto a te e alla terza parte. Puoi ad esempio usare un ID di fattura tra te e la terza parte, ma non devi usare qualcosa che sia possibile indovinare, ad esempio il nome o il numero di telefono della terza parte. Devi specificare questo ID quando definisci la policy di affidabilità per il ruolo. La terza parte deve fornire questo ID quando assume il ruolo.
+ **Le autorizzazioni di cui la terza parte necessita per usare le risorse AWS ** Devi specificare queste autorizzazioni quando definisci la policy di autorizzazione del ruolo. Questa policy definisce le operazioni consentite e le risorse a cui è possibile accedere.

Dopo aver creato il ruolo, devi fornire l'Amazon Resource Name (ARN) del ruolo alla terza parte. L'ARN del ruolo è necessario per assumere il ruolo.

**Importante**  
Quando concedi a terze parti l'accesso alle tue AWS risorse, queste possono accedere a qualsiasi risorsa specificata nella politica. Le risorse usate dalla terza parte vengono fatturate a te. Assicurati di limitare l'uso delle risorse in modo appropriato.

## Esterno IDs per accesso da parte di terzi
<a name="id_roles_third-party_external-id"></a>

Un ID esterno consente all'utente che sta assumendo il ruolo di dichiarare le circostanze in cui sta operando. Fornisce inoltre un modo per il proprietario dell'account di consentire che il ruolo venga assunto solo in circostanze specifiche. La funzione principale dell'ID esterno è quella di risolvere e prevenire il [Problema del "confused deputy"](confused-deputy.md).

**Importante**  
AWS non considera l'ID esterno come segreto. Dopo aver creato un segreto, ad esempio una coppia di chiavi di accesso o una password AWS, non è possibile visualizzarli nuovamente. L'ID esterno di un ruolo può essere visualizzato da chiunque disponga dell'autorizzazione a visualizzarlo. 

## Quando si deve usare l'ID esterno?
<a name="external-id-use"></a>

Utilizzare un ID esterno nelle seguenti situazioni:
+ Sei un Account AWS proprietario e hai configurato un ruolo per una terza parte che accede ad altri ruoli oltre Account AWS al tuo. È opportuno chiedere alla terza parte un ID esterno da includere quando assume il ruolo fornito alla terza parte. Quindi verificare l'ID esterno tramite la policy di affidabilità del ruolo fornito alla terza parte. Ciò garantisce che la parte esterna possa assumere il tuo ruolo solo quando agisce per conto del proprietario.
+ Ci si trova in una posizione che comporta l'assunzione di ruoli per conto di diversi clienti in modo analogo a Example Corp nello scenario precedente. È opportuno assegnare un ID esterno univoco a ciascun cliente e fornire indicazioni per aggiungere l'ID esterno alla policy di affidabilità creata per il ruolo da fornire. È quindi necessario assicurarsi di includere sempre l'ID esterno corretto nelle richieste di assunzione dei ruoli.

  Probabilmente si dispone già di un identificativo univoco per ogni cliente e questo ID univoco è sufficiente per l'utilizzo come ID esterno. L'ID esterno non è un valore speciale da creare in modo esplicito o monitorare separatamente, solo per questo scopo.

  Si deve sempre specificare l'ID esterno nelle chiamate API `AssumeRole`. Inoltre, quando un cliente assegna un ARN del ruolo, verificare se è possibile assumere il ruolo con e senza l'ID esterno corretto. Se è possibile assumere il ruolo senza l'ID esterno corretto, non memorizzare l'ARN del ruolo del cliente nel sistema. Attendere fino a quando il cliente non ha aggiornato la policy di affidabilità del ruolo per richiedere l'ID esterno corretto. In questo modo è possibile aiutare i clienti a operare nel modo corretto e pertanto a garantire la sicurezza di entrambi rispetto al problema "confused deputy".

## Scenario di esempio che utilizza un ID esterno
<a name="id_roles_third-party_example"></a>

Ad esempio, supponiamo che tu decida di assumere una società terza chiamata Example Corp per monitorare Account AWS e ottimizzare i costi. Per tenere traccia delle spese giornaliere, Example Corp deve accedere alle tue AWS risorse. Example Corp controlla anche molti altri account AWS per altri clienti.

Non fornire l'accesso a Example Corp a un utente IAM e le relative credenziali a lungo termine nell'account AWS . Utilizza invece un ruolo IAM e le credenziali di sicurezza temporanee. Un ruolo IAM fornisce un meccanismo per consentire a terzi di accedere alle vostre AWS risorse senza dover condividere credenziali a lungo termine (come una chiave di accesso utente IAM).

Puoi utilizzare un ruolo IAM per stabilire una relazione di attendibilità tra il tuo Account AWS e l'account di Example Corp. Dopo aver stabilito questa relazione, un membro dell'account Example Corp può chiamare l' AWS Security Token Service [AssumeRole](https://docs.aws.amazon.com/STS/latest/APIReference/API_AssumeRole.html)API per ottenere credenziali di sicurezza temporanee. I membri di Example Corp possono quindi utilizzare le credenziali per accedere alle AWS risorse del tuo account. 

**Nota**  
Per ulteriori informazioni sulle AssumeRole e altre operazioni AWS API che è possibile chiamare per ottenere credenziali di sicurezza temporanee, vedere. [Confronta le AWS STS credenziali](id_credentials_sts-comparison.md)

Di seguito è illustrata un'analisi più dettagliata di questo scenario.

1. L'Utente A affida un incarico a Example Corp, che crea un identificatore univoco per l'Utente A. Ti forniscono questo ID cliente univoco e il loro Account AWS numero. Queste informazioni sono necessarie per creare un ruolo IAM nella fase successiva. 
**Nota**  
Example Corp può utilizzare qualsiasi valore di stringa desiderato per il ExternalId, purché sia unico per ogni cliente. È possibile che si tratti di un numero di account cliente o addirittura di una stringa di caratteri casuale, purché non esistano due clienti con lo stesso valore. Non si tratta di un "segreto". Example Corp deve fornire il ExternalId valore a ciascun cliente. L'aspetto cruciale è che l'ID deve essere generato da Example Corp e ***non*** dai clienti affinché ogni ID esterno sia univoco.

1. Accedi AWS e crei un ruolo IAM che consente a Example Corp di accedere alle tue risorse. Come per qualsiasi ruolo IAM, il ruolo dispone di due tipi di policy: una policy di autorizzazione e una policy di attendibilità. La policy di affidabilità del ruolo specifica chi può assumere il ruolo. Nel nostro scenario di esempio, la policy specifica il Account AWS numero di Example Corp come. `Principal` Ciò consente alle identità di tale account di assumere il ruolo. Inoltre, viene aggiunto un elemento `[Condition](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_elements.html#Condition)` alla policy di attendibilità. Questo elemento `Condition` verifica la chiave di contesto `ExternalId` per assicurarsi che corrisponda all'ID cliente univoco di Example Corp. Ad esempio:

   ```
       "Principal": {"AWS": "Example Corp's Account AWS ID"},
       "Condition": {"StringEquals": {"sts:ExternalId": "Unique ID Assigned by Example Corp"}}
   ```

1. La policy di autorizzazione per il ruolo specifica le operazioni che il ruolo consente di effettuare a un utente. Ad esempio, puoi specificare che il ruolo deve permettere agli utenti di gestire solo le risorse Amazon RDS e Amazon EC2, ma non gli utenti o i gruppi IAM. In questo scenario di esempio, si utilizza la policy di autorizzazione per fornire l'accesso in sola lettura per Example Corp a tutte le risorse nell'account dell'Utente A.

1. Dopo aver creato il ruolo, è necessario fornire l'Amazon Resource Name (ARN) del ruolo a Example Corp.

1. Quando Example Corp deve accedere alle tue AWS risorse, qualcuno dell'azienda chiama l'API. AWS `sts:AssumeRole` La chiamata include l'ARN del ruolo da assumere e il ExternalId parametro che corrisponde all'ID cliente.

Se la richiesta proviene da qualcuno che utilizza Example Corp e se l'ARN del ruolo e l'ID esterno sono corretti, la richiesta ha esito positivo. Account AWS Fornisce quindi credenziali di sicurezza temporanee che Example Corp può utilizzare per accedere alle AWS risorse consentite dal ruolo.

In altre parole, quando una policy di ruolo include un ID esterno, chiunque desideri assumere il ruolo deve essere un entità principale nel ruolo e deve includere l'ID esterno corretto.

## Punti chiave per l'esterno IDs
<a name="id_roles_third-party_key-points"></a>
+ In un ambiente multi-tenant in cui si supportano più clienti con AWS account diversi, si consiglia di utilizzare un ID esterno per utente. Account AWS Questo ID dovrebbe essere una stringa casuale generata dalla terza parte.
+ Per richiedere che la terza parte fornisca un ID esterno quando si assume un ruolo, aggiorna la policy di attendibilità del ruolo con l'ID esterno scelto.
+ Per fornire un ID esterno quando assumi un ruolo, utilizza l' AWS API AWS CLI o per assumere quel ruolo. Per ulteriori informazioni, consulta l'operazione dell'[AssumeRole](https://docs.aws.amazon.com/STS/latest/APIReference/API_AssumeRole.html)API STS o l'operazione CLI STS [assume-role](https://docs.aws.amazon.com/cli/latest/reference/sts/assume-role.html).
+ Il valore `ExternalId` deve avere un minimo di 2 caratteri e un massimo di 1.224 caratteri. Il valore deve essere alfanumerico senza spazi. Può anche includere i seguenti simboli: più (\$1), uguale (=), virgola (,), punto (.), chiocciola (@), due punti (:), barra (/) e trattino (-).

## Risorse aggiuntive
<a name="id_roles_third-party_additional_resources"></a>

Le risorse seguenti possono rivelarsi utili per fornire l'accesso a Account AWS di proprietà di terze parti.
+ Per informazioni su come consentire ad altri di eseguire azioni sul tuo computer, consulta. Account AWS[Creare un ruolo utilizzando policy di attendibilità personalizzate](id_roles_create_for-custom.md)
+ Per informazioni su come concedere l'autorizzazione per passare a un ruolo, consulta [Concedere le autorizzazioni agli utenti per cambiare ruoli](id_roles_use_permissions-to-switch.md)
+ Per informazioni su come creare e fornire a utenti attendibili credenziali di sicurezza temporanee, [Autorizzazioni per le credenziali di sicurezza temporanee](id_credentials_temp_control-access.md).

# Accesso a un AWS servizio
<a name="id_roles_common-scenarios_services"></a>

Molti AWS servizi richiedono l'utilizzo di ruoli per controllare a cosa può accedere il servizio. Un ruolo che un servizio assume per eseguire operazioni a tuo nome viene chiamato [ruolo del servizio](id_roles.md#iam-term-service-role). Quando un ruolo fornisce uno scopo specializzato per un servizio, questo può essere categorizzato come [ruolo collegato al servizio](id_roles.md#iam-term-service-linked-role). Consulta la [documentazione AWS](https://docs.aws.amazon.com/) di ciascun servizio per verificare se utilizza ruoli e per ulteriori informazioni su come assegnare un ruolo per il servizio da utilizzare.

Per informazioni dettagliate sulla creazione di un ruolo per delegare l'accesso a un servizio offerto da AWS, consulta[Creare un ruolo per delegare le autorizzazioni a un servizio AWS](id_roles_create_for-service.md).

# Accesso a utenti autenticati esternamente (federazione delle identità)
<a name="id_roles_common-scenarios_federated-users"></a>

I tuoi utenti potrebbero già avere identità esterne AWS, ad esempio nella tua directory aziendale. Se tali utenti devono utilizzare AWS risorse (o utilizzare applicazioni che accedono a tali risorse), devono utilizzare anche credenziali AWS di sicurezza. È possibile utilizzare un ruolo IAM per specificare le autorizzazioni per gli utenti la cui identità è federata dalla propria organizzazione o da un provider di identità di terze parti (IdP).

**Nota**  
Come best practice di sicurezza, ti consigliamo di gestire l'accesso degli utenti in [Centro identità IAM](https://docs.aws.amazon.com//singlesignon/latest/userguide/what-is.html) con la federazione delle identità anziché creare utenti IAM. Per informazioni su situazioni specifiche in cui è richiesto un utente IAM, consulta la sezione [Quando creare un utente IAM invece di un ruolo](https://docs.aws.amazon.com/IAM/latest/UserGuide/id.html#id_which-to-choose).

## Federazione di utenti di una applicazione per dispositivi mobili o basata sul Web con Amazon Cognito
<a name="id_roles_common-scenarios_federated-users-cognito"></a>

Se crei un'app mobile o basata sul Web che accede alle AWS risorse, l'app necessita di credenziali di sicurezza per poter effettuare richieste programmatiche a. AWS Per la maggior parte degli scenari relativi alle applicazioni per dispositivi mobili, consigliamo di utilizzare [Amazon Cognito](https://aws.amazon.com/cognito/). Puoi utilizzare questo servizio con [AWS Mobile SDK per iOS e Mobile SDK per](https://aws.amazon.com/sdkforios/) [Android e AWS Fire OS per creare identità uniche per gli utenti e](https://aws.amazon.com/sdkforandroid/) autenticarli per un accesso sicuro alle tue risorse. AWS Amazon Cognito supporta gli stessi provider di identità come quelli elencati nella sezione successiva e supporta anche [identità autenticate dallo sviluppatore](https://aws.amazon.com/blogs/mobile/amazon-cognito-announcing-developer-authenticated-identities) e accesso non autenticato (ospite). Amazon Cognito fornisce inoltre operazioni API per la sincronizzazione dei dati utente in modo che vengano conservati quando gli utenti passano da un dispositivo all'altro. Per ulteriori informazioni, consulta [Amazon Cognito per applicazioni per dispositivi mobili](id_federation_common_scenarios.md#id_roles_providers_oidc_cognito). 

## Federazione degli utenti con provider di servizi di identità pubblica o OpenID Connect
<a name="id_roles_common-scenarios_federated-users-openId"></a>

Quando possibile, utilizza Amazon Cognito per scenari di applicazioni per dispositivi mobili o basate sul Web. Amazon Cognito si occupa della maggior parte del behind-the-scenes lavoro con i servizi di provider di identità pubblici per te. Lavora con gli stessi servizi di terze parti e supporta anche gli accessi anonimi. Tuttavia, per ulteriori scenari avanzati, è possibile lavorare direttamente con un servizio di terze parti, ad esempio Login with Amazon, Facebook, Google o qualsiasi IdP compatibile con OpenID Connect (OIDC). Per ulteriori informazioni sull'utilizzo della federazione OIDC utilizzando uno di questi servizi, consulta [Federazione OIDC](id_roles_providers_oidc.md).

## Federazione degli utenti con SAML 2.0
<a name="id_roles_common-scenarios_federated-users-saml20"></a>

Se la tua organizzazione utilizza già un pacchetto software per provider di identità che supporta SAML 2.0 (Security Assertion Markup Language 2.0), puoi creare fiducia tra la tua organizzazione come provider di identità (IdP) e AWS come fornitore di servizi. Puoi quindi utilizzare SAML per fornire ai tuoi utenti il Single Sign-On federato (SSO) o l'accesso federato alle operazioni dell' Console di gestione AWS API di chiamata. AWS Ad esempio, se la tua azienda utilizza Microsoft Active Directory e Active Directory Federation Services, puoi effettuare la federazione utilizzando SAML 2.0. Per ulteriori informazioni sulla federazione degli utenti con SAML 2.0, consulta [Federazione SAML 2.0](id_roles_providers_saml.md).

## Federazione degli utenti creando un'applicazione personalizzata per la gestione di identità
<a name="id_roles_common-scenarios_federated-users-idbroker"></a>

Se il proprio archivio identità non è compatibile con SAML 2.0, è possibile creare un'applicazione personalizzata per la gestione di identità per eseguire una funzione simile. L'applicazione broker autentica gli utenti, richiede credenziali temporanee per gli utenti e quindi le fornisce all'utente per accedere alle AWS risorse. AWS 

Ad esempio, Example Corp. ha molti dipendenti che devono eseguire applicazioni interne che accedono alle risorse dell'azienda. AWS I dipendenti hanno già identità nel sistema di identità e autenticazione dell'azienda ed Example Corp. non desidera creare un utente IAM separato per ogni dipendente dell'azienda.

Bob è uno sviluppatore presso Example Corp. Per consentire alle applicazioni interne di Example Corp. di accedere alle AWS risorse dell'azienda, Bob sviluppa un'applicazione di identity broker personalizzata. L'applicazione verifica che i dipendenti abbiano effettuato l'accesso nel sistema di identità e autenticazione esistente, che potrebbe utilizzare LDAP, Active Directory o un altro sistema. L'applicazione del gestore identità quindi ottiene le credenziali di sicurezza provvisorie per i dipendenti. Questo scenario è simile a quello precedente (un'app mobile che utilizza un sistema di autenticazione personalizzato), tranne per il fatto che le applicazioni che richiedono l'accesso alle AWS risorse vengono eseguite tutte all'interno della rete aziendale e l'azienda dispone di un sistema di autenticazione esistente.

Per ottenere le credenziali di sicurezza provvisorie, l'applicazione del gestore identità chiama `AssumeRole` o `GetFederationToken` per ottenere le credenziali di sicurezza provvisorie, a seconda di come Bob desidera gestire le policy per gli utenti e quando scadono le credenziali provvisorie. (Per ulteriori informazioni sulle differenze tra queste operazioni API, consultare [Credenziali di sicurezza temporanee in IAM](id_credentials_temp.md) e [Autorizzazioni per le credenziali di sicurezza temporanee](id_credentials_temp_control-access.md).) La chiamata restituisce credenziali di sicurezza temporanee costituite da un ID chiave di AWS accesso, una chiave di accesso segreta e un token di sessione. L'applicazione del gestore identità rende tali credenziali di sicurezza provvisorie disponibili all'applicazione aziendale interna. L'applicazione può quindi utilizzare le credenziali provvisorie per effettuare chiamate a AWS direttamente. L'app memorizza le credenziali finché non scadono e in seguito richiede un nuovo set di credenziali temporanee. L'immagine seguente illustra questo scenario.

![\[Esempio di flusso di lavoro in cui viene utilizzata un'applicazione personalizzata del gestore identità\]](http://docs.aws.amazon.com/it_it/IAM/latest/UserGuide/images/enterprise-authentication-with-identity-broker-application.diagram.png)


Questo scenario ha i seguenti attributi:
+ L'applicazione del gestore identità ha le autorizzazioni per accedere all'API di servizio token IAM (STS) per creare le credenziali di sicurezza temporanee.
+ L'applicazione del gestore identità è in grado di verificare che i dipendenti siano autenticati nel sistema di autenticazione esistente.
+ Gli utenti possono ottenere un URL temporaneo che consente loro di accedere alla Console di AWS gestione (denominata Single Sign-on).

Per ulteriori informazioni sulla creazione di credenziali di sicurezza provvisorie, consultare [Confronta le AWS STS credenziali](id_credentials_sts-comparison.md). Per ulteriori informazioni sull'accesso alla Console di gestione da parte dei principali federati SAML, consulta AWS . [Consentire ai principali federati SAML 2.0 di accedere a Console di gestione AWS](id_roles_providers_enable-console-saml.md)

# Creazione di ruoli IAM
<a name="id_roles_create"></a>

Per creare un ruolo, puoi utilizzare l' Console di gestione AWS AWS CLI API Tools for Windows PowerShell o IAM.

Se utilizzi il Console di gestione AWS, una procedura guidata ti guida attraverso i passaggi per la creazione di un ruolo. La procedura guidata prevede passaggi leggermente diversi a seconda che tu stia creando un ruolo per un AWS servizio, per un o per un principale Account AWS federato SAML o OIDC.

**Ruoli per gli utenti IAM**  
Crea questo ruolo per delegare le autorizzazioni all'interno del tuo ruolo Account AWS o a ruoli definiti in altri ruoli di tua proprietà. Account AWS Un utente in un account può passare a un ruolo dello stesso o di un altro account. Mentre si usa il ruolo, l'utente è in grado di eseguire solo le azioni e accedere solo alle risorse consentite dal ruolo; le loro autorizzazioni utente originali sono sospese. Quando l'utente esce dal ruolo, le autorizzazioni utente originali vengono ripristinate.

Per ulteriori informazioni, consulta [Creazione di un ruolo per fornire le autorizzazioni a un utente IAM](id_roles_create_for-user.md).

Per ulteriori informazioni sulla creazione di ruoli per l'accesso multi-account, consulta [Creare un ruolo utilizzando policy di attendibilità personalizzate](id_roles_create_for-custom.md).

**Ruoli per i servizi AWS**  
Creare questo ruolo per delegare le autorizzazioni per un servizio che può eseguire operazioni per tuo conto Un [ruolo di servizio](id_roles.md#iam-term-service-role) che passi a un servizio deve avere una policy IAM con le autorizzazioni che consentano al servizio di eseguire azioni associate a quel servizio. Sono necessarie autorizzazioni diverse per ciascuno dei servizi AWS .

Per ulteriori informazioni sulla creazione dei ruoli di servizio, consulta [Creare un ruolo per delegare le autorizzazioni a un servizio AWS](id_roles_create_for-service.md).

Per ulteriori informazioni sulla creazione di ruoli collegati al servizio, consulta [Creare un ruolo collegato ai servizi](id_roles_create-service-linked-role.md).

**Ruoli per la federazione delle identità**  
Crea questo ruolo per delegare le autorizzazioni agli utenti che hanno già identità esterne a AWS. Quando utilizzi un provider di identità, non devi creare un codice di accesso personalizzato né gestire le tue identità utente. I tuoi utenti esterni accedono tramite un IdP e puoi concedere a tali identità esterne le autorizzazioni per utilizzare le AWS risorse del tuo account. I provider di identità aiutano a proteggere l' AWS account perché non è necessario distribuire o incorporare credenziali di sicurezza a lungo termine, come le chiavi di accesso, nell'applicazione.

Per ulteriori informazioni, consulta [Creazione di un ruolo per un provider di identità di terze parti](id_roles_create_for-idp.md).

# Creazione di un ruolo per fornire le autorizzazioni a un utente IAM
<a name="id_roles_create_for-user"></a>

Puoi utilizzare i ruoli IAM per fornire l'accesso alle tue AWS risorse. Con i ruoli IAM, puoi stabilire relazioni di fiducia tra il tuo account *fiduciario* e altri account AWS *affidabili*. L'account che concede fiducia possiede la risorsa alla quale accedere e l'account affidabile contiene gli utenti che devono accedere alla risorsa. Tuttavia, è possibile che un altro account sia proprietario di una risorsa nell'account in uso. L'account che concede fiducia potrebbe infatti consentire all'account attendibile di creare nuove risorse, ad esempio creando nuovi oggetti in un bucket Amazon S3. In tal caso, l'account che crea la risorsa ne è proprietario e controlla chi può accedervi.

Dopo aver creato la relazione di fiducia, un utente IAM o un'applicazione dell'account affidabile può utilizzare l'operazione [https://docs.aws.amazon.com/STS/latest/APIReference/API_AssumeRole.html](https://docs.aws.amazon.com/STS/latest/APIReference/API_AssumeRole.html)API AWS Security Token Service (AWS STS). Questa operazione fornisce credenziali di sicurezza temporanee che consentono l'accesso alle AWS risorse del tuo account.

Gli account possono essere controllati da sé stessi oppure l'account con gli utenti può essere controllato da terze parti. Se l'altro account con gli utenti è un account Account AWS che non controlli, puoi utilizzare l'`externalId`attributo. L'ID esterno può essere qualsiasi parola o numero concordato tra l'utente e l'amministratore dell'account di terze parti. Questa opzione aggiunge automaticamente una condizione alla policy di affidabilità che consente all'utente di assumere il ruolo solo se la richiesta include il corretto `sts:ExternalID`. Per ulteriori informazioni, consulta [Accesso a Account AWS siti di proprietà di terzi](id_roles_common-scenarios_third-party.md).

Per informazioni su come utilizzare i ruoli per delegare le autorizzazioni, consultare [Termini e concetti dei ruoli](id_roles.md#id_roles_terms-and-concepts). Per informazioni sull'utilizzo di un ruolo di servizio per consentire l'accesso a risorse nel proprio account, consultare [Creare un ruolo per delegare le autorizzazioni a un servizio AWS](id_roles_create_for-service.md).

## Creazione di un ruolo IAM (console)
<a name="roles-creatingrole-user-console"></a>

Puoi utilizzare il Console di gestione AWS per creare un ruolo che un utente IAM può assumere. Ad esempio, supponiamo che l'organizzazione disponga di più Account AWS elementi per isolare un ambiente di sviluppo da un ambiente di produzione. Per informazioni di alto livello sulla creazione di un ruolo che consenta agli utenti nell'account di sviluppo di accedere alle risorse nell'account di produzione, consulta la sezione [Esempio di uno scenario in cui si utilizzano account di sviluppo e produzione separati](id_roles_common-scenarios_aws-accounts.md#id_roles_common-scenarios_aws-accounts-example).

**Autorizzazioni minime**  
Per eseguire le seguenti operazioni, devi disporre come minimo delle seguenti autorizzazioni IAM:  
`access-analyzer:ValidatePolicy`
`iam:AttachRolePolicy`
`iam:CreatePolicy`
`iam:CreateRole`
`iam:GetAccountSummary`
`iam:GetPolicy`
`iam:GetPolicyVersion`
`iam:GetRole`
`iam:ListAccountAliases`
`iam:ListAttachedRolePolicies`
`iam:ListOpenIDConnectProviders`
`iam:ListPolicies`
`iam:ListRolePolicies`
`iam:ListRoles`
`iam:ListRoleTags`
`iam:ListSAMLProviders`

------
#### [ Console ]

1. Accedi a Console di gestione AWS e apri la console IAM all'indirizzo [https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/).

1. Nel riquadro di navigazione della console, selezionare **Ruoli** e **Crea ruolo**.

1. Scegli il tipo di ruolo **Account AWS**.

1. Per creare un ruolo per il tuo account, scegli **This account** (Questo account). Per creare un ruolo per un altro account, scegli **Altro Account AWS** e inserisci l'**ID account ID** al quale desideri concedere l'accesso alle risorse.

   L'amministratore dell'account specificato può concedere l'autorizzazione di assumere questo ruolo a qualsiasi utente IAM in tale account. Per eseguire questa operazione, l'amministratore collega una policy all'utente o al gruppo che garantisce l'autorizzazione per l'operazione `sts:AssumeRole`. Tale policy deve specificare il nome ARN del ruolo `Resource`. 

1. Per concedere le autorizzazioni agli utenti da un account di cui non hai il controllo e se tali utenti assumeranno il ruolo a livello di programmazione, seleziona **Require external ID** (Richiedi ID esterno). L'ID esterno può essere qualsiasi parola o numero concordato tra l'utente e l'amministratore dell'account di terze parti. Questa opzione aggiunge automaticamente una condizione alla policy di affidabilità che consente all'utente di assumere il ruolo solo se la richiesta include il corretto `sts:ExternalID`. Per ulteriori informazioni, consulta [Accesso a Account AWS siti di proprietà di terzi](id_roles_common-scenarios_third-party.md).
**Importante**  
La scelta di questa opzione limita l'accesso al ruolo solo tramite Tools for Windows PowerShell o l' AWS API. AWS CLI Questo perché non è possibile utilizzare la AWS console per passare a un ruolo che presenta una `externalId` condizione nella politica di attendibilità. Tuttavia, è possibile creare questo tipo di accesso a livello di codice scrivendo uno script o un'applicazione utilizzando il kit SDK rilevante. Per ulteriori informazioni e uno script di esempio, consulta [Come abilitare l'accesso tra account alla Console di gestione AWS](https://aws.amazon.com/blogs/security/how-to-enable-cross-account-access-to-the-aws-management-console) nel Blog sulla sicurezza di AWS .

1. Se si desidera limitare il ruolo agli utenti che accedono con la multi-factor authentication (MFA), selezionare **Require MFA (Richiedi MFA)**. Questa opzione aggiunge una condizione alla policy di affidabilità del ruolo che controlla un accesso MFA. Un utente che desidera assumere il ruolo deve accedere con una password monouso temporanea da un dispositivo MFA configurato. Gli utenti senza autenticazione MFA non possono assumere il ruolo. Per ulteriori informazioni sulla funzionalità MFA, consultare [AWS Autenticazione a più fattori in IAM](id_credentials_mfa.md).

1. Scegli **Next (Successivo)**.

1. IAM include un elenco delle politiche AWS gestite e gestite dai clienti nel tuo account. Selezionare la policy delle autorizzazioni da utilizzare o scegliere **Crea policy** per aprire una nuova scheda del browser e creare una nuova policy da zero. Per ulteriori informazioni, consulta [Creazione di policy IAM](access_policies_create-console.md#access_policies_create-start). Una volta creata la policy, chiudere la scheda e tornare alla scheda originale. Selezionare la casella di controllo accanto alle policy di autorizzazione da assegnare a chiunque assuma il ruolo. È anche possibile non selezionare le policy ora e collegarle al ruolo in un secondo momento. Per default, un ruolo non dispone di autorizzazioni.

1. (Facoltativo) Impostare un [limite delle autorizzazioni](access_policies_boundaries.md). Questa è una caratteristica avanzata. 

   Aprire la sezione **Set permissions boundary (Imposta limite delle autorizzazioni)** e selezionare **Use a permissions boundary to control the maximum role permissions (Usa un limite delle autorizzazioni per controllare il numero massimo di autorizzazioni del ruolo)**. Selezionare la policy da utilizzare per il limite delle autorizzazioni.

1. Scegli **Next (Successivo)**.

1. In **Nome ruolo**, immetti un nome per il ruolo. I nomi dei ruoli devono essere univoci all'interno del tuo Account AWS. Quando il nome di un ruolo viene utilizzato in una policy o come parte di un ARN, il nome del ruolo fa distinzione tra maiuscole e minuscole. Quando un nome di ruolo viene visualizzato ai clienti nella console, ad esempio durante la procedura di accesso, il nome del ruolo non fa distinzione tra maiuscole e minuscole. Poiché varie entità possono fare riferimento al ruolo, non puoi modificare il nome del ruolo dopo averlo creato.

1. (Facoltativo) In **Description** (Descrizione), inserisci una descrizione per il nuovo ruolo.

1. Scegli **Edit** (Modifica) nelle sezioni **Step 1: Select trusted entities** (Fase 1: seleziona le entità attendibili) o **Step 2: Add permissions** (Fase 2: aggiungi autorizzazioni) per modificare i casi d'uso e le autorizzazioni per il ruolo. Verrai reindirizzato alle pagine precedenti per apportare le modifiche.

1. (Facoltativo) Aggiungere metadati al ruolo collegando i tag come coppie chiave-valore. Per ulteriori informazioni sull'utilizzo dei tag in IAM, consultare [Tag per AWS Identity and Access Management le risorse](id_tags.md).

1. Rivedere il ruolo e scegliere **Crea ruolo**.
**Importante**  
Ricordare che questa è solo la prima metà della configurazione obbligatoria. È inoltre necessario fornire ai singoli utenti nell'account attendibile l'autorizzazione a passare al ruolo nella console o ad assumere il ruolo a livello di codice. Per ulteriori informazioni su questa fase, consultare [Concedere le autorizzazioni agli utenti per cambiare ruoli](id_roles_use_permissions-to-switch.md).

------

## Creazione di un ruolo IAM (AWS CLI)
<a name="roles-creatingrole-user-cli"></a>

La creazione di un ruolo da a AWS CLI comporta più passaggi. Quando si utilizza la console per creare un ruolo, molti passaggi vengono eseguiti automaticamente, ma con la console è AWS CLI necessario eseguire ogni passaggio in modo esplicito e autonomo. È necessario creare il ruolo e quindi assegnargli una policy di autorizzazione. Puoi anche scegliere di impostare il [limite delle autorizzazioni](access_policies_boundaries.md) per il ruolo.

**Per creare un ruolo per accesso tra account (AWS CLI)**

1. Creare un ruolo: [aws iam create-role](https://docs.aws.amazon.com/cli/latest/reference/iam/create-role.html)

1. [Allega una politica di autorizzazioni gestite al ruolo: aws iam attach-role-policy](https://docs.aws.amazon.com/cli/latest/reference/iam/attach-role-policy.html)

    or

   [Crea una politica di autorizzazioni in linea per il ruolo: aws iam put-role-policy](https://docs.aws.amazon.com/cli/latest/reference/iam/put-role-policy.html)

1. (Facoltativo) Aggiungere attributi personalizzati al ruolo collegando tag: [aws iam tag-role](https://docs.aws.amazon.com/cli/latest/reference/iam/tag-role.html)

   Per ulteriori informazioni, consulta [Gestione dei tag sui ruoli (AWS CLI o AWS API) IAM](id_tags_roles.md#id_tags_roles_procs-cli-api).

1. [(Facoltativo) Imposta il [limite delle autorizzazioni](access_policies_boundaries.md) per il ruolo: aws iam put-role-permissions-boundary](https://docs.aws.amazon.com/cli/latest/reference/iam/put-role-permissions-boundary.html)

   Il limite delle autorizzazioni controlla il numero massimo di autorizzazioni che è possibile concedere a un ruolo. I limiti delle autorizzazioni sono una funzionalità avanzata. AWS 

L'esempio seguente mostra i primi due passaggi, più comuni, per la creazione di un ruolo per più account in un ambiente semplice. Questo esempio permette agli utenti dell'account `123456789012` di assumere il ruolo e visualizzare il bucket `example_bucket` di Amazon S3. L'esempio presuppone inoltre l'uso un computer client con Windows e che l'interfaccia a riga di comando sia già configurata con le credenziali dell'account e la regione. Per ulteriori informazioni, vedere [Configurazione dell'interfaccia a AWS riga di comando](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-getting-started.html).

In questo esempio, è necessario includere la seguente policy di attendibilità nel primo comando al momento della creazione del ruolo. Questa policy di attendibilità consente agli utenti dell'account `123456789012` di assumere il ruolo tramite l'operazione `AssumeRole`, ma solo se l'utente fornisce l'autenticazione MFA utilizzando i parametri `SerialNumber` e `TokenCode`. Per ulteriori informazioni sulla funzionalità MFA, consultare [AWS Autenticazione a più fattori in IAM](id_credentials_mfa.md).

------
#### [ JSON ]

****  

```
{
  "Version":"2012-10-17",		 	 	 
  "Statement": [
      {
          "Effect": "Allow",
          "Principal": { "AWS": "arn:aws:iam::123456789012:root" },
          "Action": "sts:AssumeRole",
          "Condition": { "Bool": { "aws:MultiFactorAuthPresent": "true" } }
      }
  ]
}
```

------

**Importante**  
Se l'elemento `Principal` contiene l'ARN per un determinato utente o ruolo IAM, quando la policy viene salvata l'ARN viene trasformato in un ID principale univoco. Ciò aiuta a mitigare il rischio che qualcuno aumenti le proprie autorizzazioni rimuovendo e ricreando il ruolo o l'utente. Questo ID non è normalmente presente nella console, perché avviene anche una trasformazione inversa nell'ARN quando la policy di affidabilità viene visualizzata. Tuttavia, se si elimina il ruolo o l'utente, l'ID principale viene visualizzato nella console perché non è più AWS possibile mapparlo su un ARN. Pertanto, se si elimina e crea nuovamente un utente o un ruolo a cui viene fatto riferimento in un elemento `Principal` della policy di attendibilità, è necessario modificare il ruolo per sostituire l'ARN.

Quando si utilizza il secondo comando, è necessario collegare una policy gestita esistente al ruolo. La policy delle autorizzazioni seguente consente agli utenti che assumono il ruolo di eseguire solo l'operazione `ListBucket` sul bucket `example_bucket` di Amazon S3.

------
#### [ JSON ]

****  

```
{
  "Version":"2012-10-17",		 	 	 
  "Statement": [
      {
          "Effect": "Allow",
          "Action": "s3:ListBucket",
          "Resource": "arn:aws:s3:::example_bucket"
      }
  ]
}
```

------

Per creare questo ruolo `Test-UserAccess-Role`, è prima necessario salvare la policy di attendibilità precedente con il nome `trustpolicyforacct123456789012.json` nella cartella `policies` dell'unità `C:` locale. Quindi salva la precedente politica di autorizzazione come politica gestita dai clienti nel tuo account Account AWS con il nome. `PolicyForRole` È quindi possibile utilizzare i comandi seguenti per creare il ruolo e collegare la policy gestita.

```
# Create the role and attach the trust policy file that allows users in the specified account to assume the role.
$ aws iam create-role --role-name Test-UserAccess-Role --assume-role-policy-document file://C:\policies\trustpolicyforacct123456789012.json

# Attach the permissions policy (in this example a managed policy) to the role to specify what it is allowed to do.
$ aws iam attach-role-policy --role-name Test-UserAccess-Role --policy-arn arn:aws:iam::123456789012:policy/PolicyForRole
```

**Importante**  
Ricordare che questa è solo la prima metà della configurazione obbligatoria. È inoltre necessario fornire a singoli utenti nell'account affidabile le autorizzazioni per passare al ruolo. Per ulteriori informazioni su questa fase, consultare [Concedere le autorizzazioni agli utenti per cambiare ruoli](id_roles_use_permissions-to-switch.md).

Dopo aver creato il ruolo e avergli concesso le autorizzazioni per eseguire AWS attività o accedere alle AWS risorse, qualsiasi utente dell'`123456789012`account può assumere il ruolo. Per ulteriori informazioni, consulta [Passaggio a un ruolo IAM (AWS CLI)](id_roles_use_switch-role-cli.md).

## Creazione di un ruolo IAM (AWS API)
<a name="roles-creatingrole-user-api"></a>

La creazione di un ruolo dall' AWS API prevede diversi passaggi. Quando si usa la console per creare un ruolo, molti dei passaggi vengono eseguiti automaticamente, ma con l'API ogni passaggio deve essere eseguito esplicitamente dall'utente. È necessario creare il ruolo e quindi assegnargli una policy di autorizzazione. Puoi anche scegliere di impostare il [limite delle autorizzazioni](access_policies_boundaries.md) per il ruolo.

**Creare un ruolo nel codice (AWS API)**

1. Crea un ruolo: [CreateRole](https://docs.aws.amazon.com/IAM/latest/APIReference/API_CreateRole.html)

   Per la policy di affidabilità del ruolo, è possibile specificare una posizione del file.

1. Allega una politica di autorizzazione gestita al ruolo: [AttachRolePolicy](https://docs.aws.amazon.com/IAM/latest/APIReference/API_AttachRolePolicy.html)

   or

   Crea una politica di autorizzazione in linea per il ruolo: [PutRolePolicy](https://docs.aws.amazon.com/IAM/latest/APIReference/API_PutRolePolicy.html)
**Importante**  
Ricordare che questa è solo la prima metà della configurazione obbligatoria. È inoltre necessario fornire a singoli utenti nell'account affidabile le autorizzazioni per passare al ruolo. Per ulteriori informazioni su questa fase, consultare [Concedere le autorizzazioni agli utenti per cambiare ruoli](id_roles_use_permissions-to-switch.md).

1. (Facoltativo) Aggiungi attributi personalizzati all'utente allegando tag: [TagRole](https://docs.aws.amazon.com/IAM/latest/APIReference/API_TagRole.html)

   Per ulteriori informazioni, consulta [Gestione dei tag sugli utenti IAM (AWS CLI o AWS API)](id_tags_users.md#id_tags_users_procs-cli-api).

1. (Facoltativo) Imposta il [limite delle autorizzazioni per il ruolo](access_policies_boundaries.md): [PutRolePermissionsBoundary](https://docs.aws.amazon.com/IAM/latest/APIReference/API_PutRolePermissionsBoundary.html)

   Il limite delle autorizzazioni controlla il numero massimo di autorizzazioni che è possibile concedere a un ruolo. I limiti delle autorizzazioni sono una funzionalità avanzata. AWS 

Dopo aver creato il ruolo e avergli concesso le autorizzazioni per eseguire AWS attività o accedere alle AWS risorse, è necessario concedere le autorizzazioni agli utenti dell'account per consentire loro di assumere il ruolo. Per ulteriori informazioni sull'assunzione di un ruolo, consulta [Passa a un ruolo IAM (AWS API)](id_roles_use_switch-role-api.md).

## Creazione di un ruolo IAM (AWS CloudFormation)
<a name="roles_creatingrole-user-cloudformation"></a>

Per informazioni sulla creazione di un ruolo IAM in AWS CloudFormation, consulta il [riferimento alle risorse e alle proprietà e](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-iam-role.html) [gli esempi nella Guida](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-iam-role.html#aws-resource-iam-role--examples) per l'*AWS CloudFormation utente*.

Per ulteriori informazioni sui modelli IAM in AWS CloudFormation, consulta gli [snippet di AWS Identity and Access Management modello nella Guida](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/quickref-iam.html) per l'*AWS CloudFormation utente*.

# Creare un ruolo per delegare le autorizzazioni a un servizio AWS
<a name="id_roles_create_for-service"></a>

Molti AWS servizi richiedono l'utilizzo di ruoli per consentire al servizio di accedere alle risorse di altri servizi per conto dell'utente. Un ruolo che un servizio assume per eseguire operazioni a tuo nome viene chiamato [ruolo del servizio](id_roles.md#iam-term-service-role). Quando un ruolo fornisce uno scopo specializzato per un servizio, questo può essere categorizzato come [ruolo collegato al servizio](id_roles.md#iam-term-service-linked-role). Per visualizzare i servizi che supportano ruoli collegati ai servizi, oppure se un servizio supporta qualsiasi forma di credenziali provvisorie, consulta [AWS servizi che funzionano con IAM](reference_aws-services-that-work-with-iam.md). Per apprendere come un singolo servizio utilizza i ruoli, scegli il nome del servizio nella tabella e visualizza la documentazione relativa a tale servizio.

Quando imposti l'autorizzazione `PassRole`, devi assicurarti che un utente non invii un ruolo dove il ruolo dispone di più autorizzazioni di quelle che desideri che l'utente abbia. Ad esempio, Alice potrebbe non essere autorizzata a eseguire alcune operazioni su Amazon S3. Se Alice potesse trasferire un ruolo a un servizio che consente le azioni di Amazon S3, il servizio potrebbe eseguire azioni Amazon S3 per conto di Alice durante l'esecuzione del processo.

Per informazioni su come i ruoli aiutano a delegare le autorizzazioni, consulta [Termini e concetti dei ruoli](id_roles.md#id_roles_terms-and-concepts).

## Autorizzazioni del ruolo del servizio
<a name="id_roles_create_service-permissions"></a>

Per consentire a una entità IAM (utente o ruolo) di creare o modificare un ruolo di servizio, occorre configurare le autorizzazioni.

**Nota**  
L'ARN per un ruolo collegato ai servizi include un principale del servizio, indicata nelle policy seguenti come `SERVICE-NAME.amazonaws.com`. Non tentare di indovinare il principale del servizio, perché fa distinzione tra maiuscole e minuscole e il formato può variare tra i servizi AWS . Per visualizzare l'entità principale di un servizio, consulta la relativa documentazione del ruolo collegato al servizio.

**Come consentire a un'entità IAM di creare un ruolo di servizio specifico**

Aggiungi la policy seguente all'entità IAM che deve creare il ruolo di servizio. Questa policy ti permette di creare un ruolo del servizio per il servizio specificato e utilizzando un nome specifico. Puoi quindi collegare le policy gestite o inline a tale ruolo. 

------
#### [ JSON ]

****  

```
{
    "Version":"2012-10-17",		 	 	 
    "Statement": [
        {
            "Effect": "Allow",
            "Action": [
                "iam:AttachRolePolicy",
                "iam:CreateRole",
                "iam:PutRolePolicy"
            ],
            "Resource": "arn:aws:iam::*:role/SERVICE-ROLE-NAME"
        }
    ]
}
```

------

**Come consentire a un'entità IAM di creare un qualsiasi ruolo di servizio**

AWS consiglia di consentire solo agli utenti amministrativi di creare qualsiasi ruolo di servizio. Una persona con autorizzazioni per creare un ruolo e allegare qualsiasi policy può eseguire l'escalation delle proprie autorizzazioni. Invece, crea una policy che consenta a questa persona di creare solo i ruoli di cui hanno bisogno o lascia che un amministratore crei il ruolo di servizio per suo conto.

Per allegare una policy che consenta a un amministratore di accedere all'intero account Account AWS, utilizza la policy [AdministratorAccess](https://console.aws.amazon.com/iam/home#policies/arn:aws:iam::aws:policy/AdministratorAccess) AWS gestita.

**Come consentire a un'entità IAM di modificare un ruolo di servizio**

Aggiungi la policy seguente all'entità IAM che deve modificare il ruolo di servizio.

------
#### [ JSON ]

****  

```
{
    "Version":"2012-10-17",		 	 	 
    "Statement": [
        {
            "Sid": "EditSpecificServiceRole",
            "Effect": "Allow",
            "Action": [
                "iam:AttachRolePolicy",
                "iam:DeleteRolePolicy",
                "iam:DetachRolePolicy",
                "iam:GetRole",
                "iam:GetRolePolicy",
                "iam:ListAttachedRolePolicies",
                "iam:ListRolePolicies",
                "iam:PutRolePolicy",
                "iam:UpdateRole",
                "iam:UpdateRoleDescription"
            ],
            "Resource": "arn:aws:iam::*:role/SERVICE-ROLE-NAME"
        },
        {
            "Sid": "ViewRolesAndPolicies",
            "Effect": "Allow",
            "Action": [
                "iam:GetPolicy",
                "iam:ListRoles"
            ],
            "Resource": "*"
        }
    ]
}
```

------

**Come consentire a un'entità IAM di eliminare un ruolo di servizio specifico**

Aggiungi l'istruzione seguente alla policy delle autorizzazioni per l'entità IAM che deve eliminare il ruolo di servizio specificato.

```
{
    "Effect": "Allow",
    "Action": "iam:DeleteRole",
    "Resource": "arn:aws:iam::*:role/SERVICE-ROLE-NAME"
}
```

**Come consentire a un'entità IAM di eliminare qualunque ruolo di servizio**

AWS consiglia di consentire solo agli utenti amministrativi di eliminare qualsiasi ruolo di servizio. Invece, crea una policy che consenta loro di eliminare solo i ruoli di cui hanno bisogno o lascia che un amministratore elimini il ruolo di servizio per suo conto.

Per allegare una politica che consenta a un amministratore di accedere all'intero account Account AWS, utilizza la politica [AdministratorAccess](https://console.aws.amazon.com/iam/home#policies/arn:aws:iam::aws:policy/AdministratorAccess) AWS gestita.

## Creazione di un ruolo per un AWS servizio (console)
<a name="roles-creatingrole-service-console"></a>

È possibile utilizzare il Console di gestione AWS per creare un ruolo per un servizio. Dal momento che alcuni servizi supportano più ruoli del servizio, consulta la [documentazione AWS](https://docs.aws.amazon.com/) relativa al servizio per determinare quale caso d'uso selezionare. È possibile apprendere come assegnare le necessarie policy di affidabilità e autorizzazioni al ruolo, in modo che il servizio possa assumere quel ruolo per conto dell'utente. Le operazioni che è possibile utilizzare per controllare le autorizzazioni per il tuo ruolo possono variare, a seconda del modo in cui il servizio definisce i casi d'uso e della creazione o meno di un ruolo collegato ai servizi.

------
#### [ Console ]

**Per creare un ruolo per una Servizio AWS (console IAM)**

1. 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. Nel pannello di navigazione della console IAM, scegliere **Ruoli** e quindi **Crea ruolo**.

1. Per **Tipo di entità attendibile**, seleziona **Servizio AWS**.

1. Per **Servizio o caso d'uso**, scegli un servizio, quindi scegli il caso d'uso. I casi d'uso sono definiti dal servizio per includere la policy di fiducia richiesta dal servizio.

1. Scegli **Next (Successivo)**.

1. Per **Policy di autorizzazione**, le opzioni dipendono dal caso d'uso selezionato:
   + Se il servizio definisce le autorizzazioni per il ruolo, le policy di autorizzazioni non possono essere selezionate.
   + Seleziona una policy da un set limitato di policy di autorizzazione.
   + Seleziona una policy tra tutte le policy di autorizzazione.
   + Non selezionare policy di autorizzazioni, crea le policy dopo la creazione del ruolo e quindi collegale al ruolo.

1. (Facoltativo) Impostare un [limite delle autorizzazioni](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_boundaries.html). Questa è una funzionalità avanzata disponibile per i ruoli di servizio, ma non per i ruoli collegati ai servizi.

   1. Apri la sezione **Imposta limite delle autorizzazioni** e seleziona **Usa un limite delle autorizzazioni per controllare il numero massimo di autorizzazioni del ruolo**. 

      IAM include un elenco delle politiche AWS gestite e gestite dal cliente nel tuo account.

   1. Selezionare la policy da utilizzare per il limite delle autorizzazioni.

1. Scegli **Next (Successivo)**.

1. Per **Nome del ruolo**, le opzioni dipendono dal servizio:
   + Se il servizio definisce il nome del ruolo, non puoi modificarlo.
   + Se il servizio definisce un prefisso per il nome del ruolo, puoi inserire un suffisso facoltativo.
   + Se il servizio non definisce il nome del ruolo, puoi assegnare un nome al ruolo.
**Importante**  
Quando assegni un nome a un ruolo, tieni presente quanto segue:  
I nomi dei ruoli devono essere univoci all'interno del tuo Account AWS account e non possono essere resi unici per caso.  
Ad esempio, non creare ruoli denominati **PRODROLE** e **prodrole**. Quando il nome di un ruolo viene utilizzato in una policy o come parte di un ARN, il nome del ruolo fa distinzione tra maiuscole e minuscole, tuttavia quando un nome di ruolo viene visualizzato ai clienti nella console, ad esempio durante il processo di accesso, il nome del ruolo non fa distinzione tra maiuscole e minuscole.
Non è possibile modificare il nome del ruolo dopo averlo creato, in quanto altre entità possono fare riferimento al ruolo.

1. (Facoltativo) In **Descrizione**, inserisci una descrizione per il ruolo.

1. (Facoltativo) Per modificare i casi d'uso e le autorizzazioni per il ruolo, in **Fase 1: seleziona le entità attendibili** o **Fase 2: aggiungi autorizzazioni** seleziona **Modifica**.

1. (Facoltativo) Per facilitare l'identificazione, l'organizzazione o la ricerca del ruolo, aggiungi i tag come coppie chiave-valore. Per ulteriori informazioni sull'utilizzo dei tag in IAM, consulta [Tags for AWS Identity and Access Management resources](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_tags.html) nella *IAM User Guide*.

1. Verificare il ruolo e quindi scegliere **Create role (Crea ruolo)**.

------

## Creazione di un ruolo per un servizio (AWS CLI)
<a name="roles-creatingrole-service-cli"></a>

La creazione di un ruolo da AWS CLI richiede diversi passaggi. Quando usi la console per creare un ruolo, molti passaggi vengono eseguiti automaticamente, ma con la AWS CLI devi eseguire esplicitamente ogni passaggio da solo. È necessario creare il ruolo e quindi assegnargli una policy di autorizzazione. Se il servizio in uso è Amazon EC2, è necessario creare anche un profilo dell'istanza e aggiungervi il ruolo. Puoi anche scegliere di impostare il [limite delle autorizzazioni](access_policies_boundaries.md) per il ruolo.

**Per creare un ruolo per un AWS servizio da AWS CLI**

1. Il seguente comando `[create-role](https://docs.aws.amazon.com/cli/latest/reference/iam/create-role.html)` crea un ruolo denominato *Ruolo di test* e gli collega una policy di attendibilità:

   `aws iam create-role --role-name Test-Role --assume-role-policy-document file://Test-Role-Trust-Policy.json`

1. Allega una politica di autorizzazioni gestite al ruolo: [aws iam attach-role-policy](https://docs.aws.amazon.com/cli/latest/reference/iam/attach-role-policy.html).

   Ad esempio, il seguente comando `attach-role-policy` allega la policy gestita AWS denominata `ReadOnlyAccess` al ruolo IAM denominato `ReadOnlyRole`:

   `aws iam attach-role-policy --policy-arn arn:aws:iam::aws:policy/ReadOnlyAccess --role-name ReadOnlyRole`

    or

   [Crea una politica di autorizzazioni in linea per il ruolo: aws iam put-role-policy](https://docs.aws.amazon.com/cli/latest/reference/iam/put-role-policy.html)

   Per aggiungere una policy di autorizzazioni in linea, consulta l'esempio seguente:

    `aws iam put-role-policy --role-name Test-Role --policy-name ExamplePolicy --policy-document file://AdminPolicy.json`

1. (Facoltativo) Aggiungere attributi personalizzati al ruolo collegando tag: [aws iam tag-role](https://docs.aws.amazon.com/cli/latest/reference/iam/tag-role.html)

   Per ulteriori informazioni, consulta [Gestione dei tag sui ruoli (AWS CLI o AWS API) IAM](id_tags_roles.md#id_tags_roles_procs-cli-api).

1. [(Facoltativo) Imposta il [limite delle autorizzazioni](access_policies_boundaries.md) per il ruolo: aws iam put-role-permissions-boundary](https://docs.aws.amazon.com/cli/latest/reference/iam/put-role-permissions-boundary.html)

   Il limite delle autorizzazioni controlla il numero massimo di autorizzazioni che è possibile concedere a un ruolo. I limiti delle autorizzazioni sono una funzionalità avanzata. AWS 

Se intendi utilizzare il ruolo con Amazon EC2 o un altro AWS servizio che utilizza Amazon EC2, devi archiviare il ruolo in un profilo di istanza. Un profilo dell'istanza è un container per un ruolo che può essere associato a un'istanza Amazon EC2 quando viene avviato. Un profilo dell'istanza può contenere un solo ruolo e tale limite non può essere aumentato. Se crei il ruolo utilizzando Console di gestione AWS, il profilo dell'istanza viene creato per te con lo stesso nome del ruolo. Per ulteriori informazioni sui profili delle istanze, consulta [Usare profili dell'istanza](id_roles_use_switch-role-ec2_instance-profiles.md). Per informazioni su come avviare un'istanza EC2 con un ruolo, consulta [Controllo dell'accesso alle risorse Amazon EC2](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/UsingIAM.html#UsingIAMrolesWithAmazonEC2Instances) nella *Guida per l'utente di Amazon EC2*.

**Per creare un profilo dell'istanza e memorizzarvi il ruolo (AWS CLI)**

1. Crea un profilo di istanza: [aws iam create-instance-profile](https://docs.aws.amazon.com/cli/latest/reference/iam/create-instance-profile.html)

1. Aggiungi il ruolo al profilo dell'istanza: [aws iam add-role-to-instance -profile](https://docs.aws.amazon.com/cli/latest/reference/iam/add-role-to-instance-profile.html)

Il comando di AWS CLI esempio riportato di seguito illustra i primi due passaggi per la creazione di un ruolo e l'assegnazione delle autorizzazioni. Mostra inoltre i due passaggi necessari per creare un profilo dell'istanza e aggiungere il ruolo al profilo. Questa policy di attendibilità di esempio permette al servizio Amazon EC2 di assumere il ruolo e visualizzare il bucket `example_bucket` di Amazon S3. L'esempio presuppone inoltre l'uso un computer client con Windows e che l'interfaccia a riga di comando sia già configurata con le credenziali dell'account e la regione. Per ulteriori informazioni, vedere [Configurazione](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-getting-started.html) dell'interfaccia a riga di comando. AWS 

In questo esempio, è necessario includere la seguente policy di attendibilità nel primo comando al momento della creazione del ruolo. La policy di attendibilità consente al servizio Amazon EC2 di assumere il ruolo. 

------
#### [ JSON ]

****  

```
{
  "Version":"2012-10-17",		 	 	 
  "Statement": {
    "Effect": "Allow",
    "Principal": {"Service": "ec2.amazonaws.com"},
    "Action": "sts:AssumeRole"
  }
}
```

------

Quando si utilizza il secondo comando, è necessario collegare una policy di autorizzazione al ruolo. L'esempio di policy di autorizzazione seguente consente al ruolo di eseguire solo l'operazione `ListBucket` sul bucket `example_bucket` di Amazon S3.

------
#### [ JSON ]

****  

```
{
  "Version":"2012-10-17",		 	 	 
  "Statement": {
    "Effect": "Allow",
    "Action": "s3:ListBucket",
    "Resource": "arn:aws:s3:::example_bucket"
  }
}
```

------

Per creare questo ruolo `Test-Role-for-EC2`, è innanzitutto necessario salvare la policy di attendibilità precedente con il nome `trustpolicyforec2.json` e la policy di autorizzazione precedente con il nome `permissionspolicyforec2.json` nella directory `policies` dell'unità `C:` locale. È quindi possibile utilizzare i comandi seguenti per creare il ruolo, collegare la policy, creare il profilo dell'istanza e aggiungere il ruolo al profilo dell'istanza.

```
# Create the role and attach the trust policy that allows EC2 to assume this role.
$ aws iam create-role --role-name Test-Role-for-EC2 --assume-role-policy-document file://C:\policies\trustpolicyforec2.json

# Embed the permissions policy (in this example an inline policy) to the role to specify what it is allowed to do.
$ aws iam put-role-policy --role-name Test-Role-for-EC2 --policy-name Permissions-Policy-For-Ec2 --policy-document file://C:\policies\permissionspolicyforec2.json

# Create the instance profile required by EC2 to contain the role
$ aws iam create-instance-profile --instance-profile-name EC2-ListBucket-S3

# Finally, add the role to the instance profile
$ aws iam add-role-to-instance-profile --instance-profile-name EC2-ListBucket-S3 --role-name Test-Role-for-EC2
```

Quando avvii l'istanza EC2, specifica il nome del profilo dell'istanza nella pagina **Configura i dettagli dell'istanza** se utilizzi la AWS console. Se utilizzi il comando della CLI `aws ec2 run-instances`, specifica il parametro `--iam-instance-profile`.

## Creazione di un ruolo per un servizio (AWS API)
<a name="roles-creatingrole-service-api"></a>

La creazione di un ruolo dall' AWS API prevede diversi passaggi. Quando si usa la console per creare un ruolo, molti dei passaggi vengono eseguiti automaticamente, ma con l'API ogni passaggio deve essere eseguito esplicitamente dall'utente. È necessario creare il ruolo e quindi assegnargli una policy di autorizzazione. Se il servizio in uso è Amazon EC2, è necessario creare anche un profilo dell'istanza e aggiungervi il ruolo. Puoi anche scegliere di impostare il [limite delle autorizzazioni](access_policies_boundaries.md) per il ruolo.

**Creare un ruolo per un AWS servizio (AWS API)**

1. Crea un ruolo: [CreateRole](https://docs.aws.amazon.com/IAM/latest/APIReference/API_CreateRole.html)

   Per la policy di affidabilità del ruolo, è possibile specificare una posizione del file.

1. Allega una politica di autorizzazioni gestite al ruolo: [AttachRolePolicy](https://docs.aws.amazon.com/IAM/latest/APIReference/API_AttachRolePolicy.html)

    or

   Crea una politica di autorizzazioni in linea per il ruolo: [PutRolePolicy](https://docs.aws.amazon.com/IAM/latest/APIReference/API_PutRolePolicy.html)

1. (Facoltativo) Aggiungi attributi personalizzati all'utente allegando tag: [TagRole](https://docs.aws.amazon.com/IAM/latest/APIReference/API_TagRole.html)

   Per ulteriori informazioni, consulta [Gestione dei tag sugli utenti IAM (AWS CLI o AWS API)](id_tags_users.md#id_tags_users_procs-cli-api).

1. (Facoltativo) Imposta il [limite delle autorizzazioni per il ruolo](access_policies_boundaries.md): [PutRolePermissionsBoundary](https://docs.aws.amazon.com/IAM/latest/APIReference/API_PutRolePermissionsBoundary.html)

   Il limite delle autorizzazioni controlla il numero massimo di autorizzazioni che è possibile concedere a un ruolo. I limiti delle autorizzazioni sono una funzionalità avanzata. AWS 

Se intendi utilizzare il ruolo con Amazon EC2 o un altro AWS servizio che utilizza Amazon EC2, devi archiviare il ruolo in un profilo di istanza. Un profilo dell'istanza è un container per un ruolo. Ogni profilo dell'istanza può contenere un solo ruolo e tale limite non può essere superato. Se crei il ruolo in Console di gestione AWS, il profilo dell'istanza viene creato per te con lo stesso nome del ruolo. Per ulteriori informazioni sui profili delle istanze, consulta [Usare profili dell'istanza](id_roles_use_switch-role-ec2_instance-profiles.md). Per informazioni su come avviare un'istanza Amazon EC2 con un ruolo, consulta [Controllo dell'accesso alle risorse Amazon EC2](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/UsingIAM.html#UsingIAMrolesWithAmazonEC2Instances) nella *Guida per l'utente di Amazon EC2*. 

**Per creare un profilo di istanza e memorizzare il ruolo al suo interno (AWS API)**

1. Crea un profilo di istanza: [CreateInstanceProfile](https://docs.aws.amazon.com/IAM/latest/APIReference/API_CreateInstanceProfile.html)

1. Aggiungi il ruolo al profilo dell'istanza: [AddRoleToInstanceProfile](https://docs.aws.amazon.com/IAM/latest/APIReference/API_AddRoleToInstanceProfile.html)

# Creare un ruolo collegato ai servizi
<a name="id_roles_create-service-linked-role"></a>

Un ruolo collegato ai servizi è un tipo univoco di ruolo IAM collegato direttamente a un servizio AWS . I ruoli collegati ai servizi sono predefiniti dal servizio e includono tutte le autorizzazioni richieste dal servizio per chiamare altri AWS servizi per conto dell'utente. Il servizio collegato definisce anche le modalità di creazione, modifica ed eliminazione di un ruolo collegato al servizio. Un servizio può creare o eliminare automaticamente il ruolo. È possibile che ti permetta di creare, modificare o eliminare il ruolo come parte di una procedura guidata o un processo nel servizio. Oppure potrebbe richiedere l'utilizzo di IAM per creare o eliminare il ruolo. Indipendentemente dal metodo, i ruoli collegati ai servizi semplificano la procedura di configurazione di un servizio poiché non dovrai più aggiungere manualmente le autorizzazioni necessarie ai servizi per completare le operazioni per tuo conto.

**Nota**  
Ricorda che i ruoli di servizio sono diversi dai ruoli collegati ai servizi. Un ruolo di servizio è un [ruolo IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles.html) che un servizio assume per eseguire operazioni per tuo conto. Un amministratore IAM può creare, modificare ed eliminare un ruolo di servizio dall’interno di IAM. Per ulteriori informazioni, consulta [Create a role to delegate permissions to an Servizio AWS](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_create_for-service.html) nella *Guida per l’utente IAM*. Un ruolo collegato al servizio è un tipo di ruolo di servizio collegato a un. Servizio AWS Il servizio può assumere il ruolo per eseguire un’operazione per tuo conto. I ruoli collegati al servizio vengono visualizzati nel tuo account Account AWS e sono di proprietà del servizio. Un amministratore IAM può visualizzare le autorizzazioni per i ruoli collegati al servizio, ma non modificarle. 

Il servizio collegato definisce le autorizzazioni dei relativi ruoli collegati ai servizi e, a meno che non sia stato stabilito diversamente, solo quel servizio può assumere i ruoli. Le autorizzazioni definite includono la policy di attendibilità e la policy delle autorizzazioni. Una policy delle autorizzazioni specifica non può essere collegata a un’altra entità IAM.

Prima di poter eliminare i ruoli, devi eliminare le risorse associate. Questo ti aiuta a evitare di rimuovere involontariamente l’autorizzazione ad accedere alle risorse. 

**Suggerimento**  
Per informazioni su quali servizi supportano i ruoli collegati ai servizi, consulta la pagina [AWS servizi che funzionano con IAM](reference_aws-services-that-work-with-iam.md) e cerca i servizi per cui è indicato **Sì **nella colonna **Ruolo collegato ai servizi**. Scegliere **Sì** in corrispondenza di un link per visualizzare la documentazione relativa al ruolo collegato al servizio per tale servizio.

## Autorizzazioni del ruolo collegato ai servizi
<a name="service-linked-role-permissions"></a>

Per consentire a un utente o un ruolo di creare o modificare un ruolo collegato ai servizi, devi configurare le autorizzazioni per un'entità IAM (utente o ruolo).

**Nota**  
L'ARN per un ruolo collegato ai servizi include un'entità principale del servizio, indicata nelle policy seguenti come `SERVICE-NAME.amazonaws.com`. Non cercate di indovinare il principale del servizio, perché fa distinzione tra AWS maiuscole e minuscole e il formato può variare da un servizio all'altro. Per visualizzare l'entità principale di un servizio, consulta la relativa documentazione del ruolo collegato al servizio.

**Per consentire a un'entità IAM di creare un ruolo specifico collegato ai servizi**

Aggiungi la policy seguente a un'entità IAM che deve creare il ruolo collegato ai servizi.

------
#### [ JSON ]

****  

```
{
    "Version":"2012-10-17",		 	 	 
    "Statement": [
        {
            "Effect": "Allow",
            "Action": "iam:CreateServiceLinkedRole",
            "Resource": "arn:aws:iam::*:role/aws-service-role/SERVICE-NAME.amazonaws.com/SERVICE-LINKED-ROLE-NAME-PREFIX*",
            "Condition": {"StringLike": {"iam:AWSServiceName": "SERVICE-NAME.amazonaws.com"}}
        },
        {
            "Effect": "Allow",
            "Action": [
                "iam:AttachRolePolicy",
                "iam:PutRolePolicy"
            ],
            "Resource": "arn:aws:iam::*:role/aws-service-role/SERVICE-NAME.amazonaws.com/SERVICE-LINKED-ROLE-NAME-PREFIX*"
        }
    ]
}
```

------

**Come consentire a un'entità IAM di creare qualunque ruolo collegato ai servizi**

Aggiungi la seguente istruzione alla policy delle autorizzazioni per l'entità IAM che deve creare un ruolo collegato ai servizi o qualunque ruolo di servizio che include le policy di cui ha bisogno. Questa istruzione della policy non consente all'entità IAM di collegare una policy al ruolo.

```
{
    "Effect": "Allow",
    "Action": "iam:CreateServiceLinkedRole",
    "Resource": "arn:aws:iam::*:role/aws-service-role/*"
}
```

**Come consentire a un'entità IAM di modificare la descrizione di qualunque ruolo di servizio**

Aggiungi la seguente istruzione alla policy delle autorizzazioni per l'entità IAM che deve modificare la descrizione di un ruolo collegato ai servizi o qualunque ruolo di servizio.

```
{
    "Effect": "Allow",
    "Action": "iam:UpdateRoleDescription",
    "Resource": "arn:aws:iam::*:role/aws-service-role/*"
}
```

**Come consentire a un'entità IAM di eliminare un ruolo collegato ai servizi specifico**

Aggiungi la seguente istruzione alla policy delle autorizzazioni per l'entità IAM che deve eliminare il ruolo collegato ai servizi.

```
{
    "Effect": "Allow",
    "Action": [
        "iam:DeleteServiceLinkedRole",
        "iam:GetServiceLinkedRoleDeletionStatus"
    ],
    "Resource": "arn:aws:iam::*:role/aws-service-role/SERVICE-NAME.amazonaws.com/SERVICE-LINKED-ROLE-NAME-PREFIX*"
}
```

**Come consentire a un'entità IAM di eliminare qualunque ruolo collegato ai servizi**

Aggiungi la seguente istruzione alla policy delle autorizzazioni per l'entità IAM che deve eliminare un ruolo collegato ai servizi ma non il ruolo di servizio.

```
{
    "Effect": "Allow",
    "Action": [
        "iam:DeleteServiceLinkedRole",
        "iam:GetServiceLinkedRoleDeletionStatus"
    ],
    "Resource": "arn:aws:iam::*:role/aws-service-role/*"
}
```

**Come consentire a un'entità IAM di passare un ruolo esistente al servizio**

Alcuni AWS servizi consentono di trasferire un ruolo esistente al servizio, anziché creare un nuovo ruolo collegato al servizio. Per eseguire questa operazione, un utente deve disporre delle autorizzazioni per *passare il ruolo* al servizio. Aggiungi l'istruzione seguente alla policy delle autorizzazioni per l'entità IAM che deve passare un ruolo. Questa istruzione della policy consente anche all'entità di visualizzare un elenco di ruoli da cui è possibile scegliere il ruolo da passare. Per ulteriori informazioni, consulta [Concedere a un utente le autorizzazioni per passare un ruolo a un servizio AWS](id_roles_use_passrole.md).

```
{
  "Sid": "PolicyStatementToAllowUserToListRoles",
  "Effect": "Allow",
  "Action": ["iam:ListRoles"],
  "Resource": "*"
},
{
  "Sid": "PolicyStatementToAllowUserToPassOneSpecificRole",
  "Effect": "Allow",
  "Action": [ "iam:PassRole" ],
  "Resource": "arn:aws:iam::account-id:role/my-role-for-XYZ"
}
```

## Autorizzazioni indirette con ruoli collegati al servizio
<a name="create-service-linked-role-permissions-transfer"></a>

Le autorizzazioni concesse da un ruolo collegato ai servizi possono essere indirettamente trasferite ad altri utenti e ruoli. Quando un ruolo collegato al servizio viene utilizzato da un AWS servizio, tale ruolo può utilizzare le proprie autorizzazioni per chiamare altri servizi. AWS Ciò significa che gli utenti e i ruoli con le autorizzazioni per chiamare un servizio che utilizza un ruolo collegato al servizio possono avere accesso indiretto ai servizi a cui può accedere quel ruolo collegato al servizio.

Ad esempio, quando crei un'istanza database Amazon RDS, [un ruolo collegato ai servizi per RDS](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/UsingWithRDS.IAM.ServiceLinkedRoles.html) viene creato automaticamente se non ne esiste già uno. Questo ruolo collegato al servizio consente a RDS di chiamare Amazon EC2, Amazon SNS, Amazon CloudWatch Logs e Amazon Kinesis per tuo conto. Se consenti agli utenti e ai ruoli del tuo account di modificare o creare database RDS, potrebbero interagire indirettamente con Amazon EC2, Amazon SNS, i log di Amazon Logs e le risorse CloudWatch Amazon Kinesis chiamando RDS, poiché RDS utilizzerebbe il suo ruolo collegato ai servizi per accedere a tali risorse.

### Metodi per creare un ruolo collegato ai servizi
<a name="create-service-linked-role"></a>

Il metodo utilizzato per creare un ruolo collegato ai servizi dipende dal servizio. In alcuni casi, non devi creare manualmente un ruolo collegato ai servizi. Ad esempio, quando completi un'azione specifica (ad esempio la creazione di una risorsa) nel servizio, il servizio potrebbe creare il ruolo collegato ai servizi per te. O se stavi utilizzando un servizio prima di iniziare il supporto ai ruoli collegati ai servizi, allora il servizio potrebbe aver creato automaticamente il ruolo nel tuo account. Per ulteriori informazioni, consulta [Nel mio account è apparso un nuovo ruolo AWS](troubleshoot_roles.md#troubleshoot_roles_new-role-appeared).

In altri casi, il servizio può supportare la creazione di un ruolo collegato ai servizi manualmente utilizzando la console di servizio, le API o la CLI. Per informazioni su quali servizi supportano i ruoli collegati ai servizi, consulta la pagina [AWS servizi che funzionano con IAM](reference_aws-services-that-work-with-iam.md) e cerca i servizi per cui è indicato **Sì **nella colonna **Ruolo collegato ai servizi**. Per scoprire se il servizio supporta la creazione del ruolo collegato ai servizi, selezionare il link **Sì** per visualizzare il ruolo collegato ai servizi per quel servizio.

Se il servizio non supporta la creazione del ruolo, è possibile utilizzare IAM per creare il ruolo collegato ai servizi.

**Importante**  
I ruoli collegati ai servizi vengono conteggiati nel limite dei [Ruoli IAM in un Account AWS](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_iam-quotas.html#reference_iam-quotas-entities), ma se è stato raggiunto il limite puoi sempre creare i ruoli collegati ai servizi nel tuo account. Solo i ruoli collegati ai servizi possono superare il limite.

### Creazione di un ruolo collegato ai servizi (console)
<a name="create-service-linked-role-iam-console"></a>

Prima di creare un ruolo collegato ai servizi in IAM, scopri se il servizio collegato crea automaticamente i ruoli collegati ai servizi; inoltre, scopri se è possibile creare il ruolo dalla console del servizio, dall'API o dalla CLI.<a name="create-service-linked-role-iam-console"></a>

**Come creare un ruolo collegato ai servizi (console)**

1. 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. Nel pannello di navigazione della console IAM seleziona **Ruoli**. Quindi seleziona **Create role** (Crea ruolo).

1. Scegli il tipo di ruolo di **servizio AWS **.

1. Scegli il caso d'uso per il servizio. I casi d'uso sono definiti dal servizio in modo da includere la policy di attendibilità richiesta dal servizio. Quindi, seleziona **Successivo**.

1. Scegli una o più policy di autorizzazione da collegare al ruolo. A seconda del caso d'uso selezionato, il servizio può eseguire una di queste operazioni:
   + Definire le autorizzazioni utilizzate dal ruolo.
   + Consentire di scegliere tra un set limitato di autorizzazioni.
   + Consentire di scegliere qualsiasi autorizzazione.
   + Ti consente di non selezionare policy in questo momento, creare le policy successivamente e quindi collegarle al ruolo.

   Seleziona la casella di controllo accanto alla policy che assegna le autorizzazioni desiderate per il ruolo, quindi scegli **Successivo**. 
**Nota**  
Le autorizzazioni specificate sono disponibili per qualsiasi entità che utilizza il ruolo. Per default, un ruolo non dispone di autorizzazioni.

1. Il grado di personalizzazione per **Nome ruolo** viene definito dal servizio. Se il servizio definisce il nome del ruolo, allora questa opzione non può essere modificata. In altri casi, il servizio può definire un prefisso per il ruolo e consentirti di inserire un suffisso opzionale.

   Se possibile, inserisci il suffisso del nome del ruolo da aggiungere al nome predefinito. Il suffisso consente di identificare lo scopo del ruolo. I nomi dei ruoli devono essere univoci all'interno dell'account AWS . Non si distinguono per caso. Ad esempio, non è possibile creare ruoli denominati sia **<service-linked-role-name>\$1SAMPLE** che **<service-linked-role-name>\$1sample**. Poiché varie entità possono fare riferimento al ruolo, non è possibile modificare il nome del ruolo dopo averlo creato.

1. (Facoltativo) In **Description** (Descrizione), modifica la descrizione per il nuovo ruolo collegato ai servizi.

1. Non è possibile collegare tag ai ruoli collegati ai servizi durante la creazione. Per ulteriori informazioni sull'utilizzo dei tag in IAM, consultare [Tag per AWS Identity and Access Management le risorse](id_tags.md).

1. Rivedere il ruolo e scegliere **Crea ruolo**.

### Creazione di un ruolo collegato ai servizi (AWS CLI)
<a name="create-service-linked-role-iam-cli"></a>

Prima di creare un ruolo collegato ai servizi in IAM, scopri se il servizio collegato crea automaticamente i ruoli collegati ai servizi e se è possibile creare il ruolo dalla CLI del servizio. Se la CLI del servizio non è supportata, puoi usare i comandi IAM per creare un ruolo collegato ai servizi con la policy di attendibilità e le policy in linea che il servizio richiede per assumere il ruolo.

**Per creare un ruolo collegato ai servizi (AWS CLI)**

Esegui il comando seguente:

```
aws iam [create-service-linked-role](https://docs.aws.amazon.com/cli/latest/reference/iam/create-service-linked-role.html) --aws-service-name SERVICE-NAME.amazonaws.com
```

### Creazione di un ruolo collegato al servizio (API)AWS
<a name="create-service-linked-role-iam-api"></a>

Prima di creare un ruolo collegato ai servizi in IAM, scopri se il servizio collegato crea automaticamente i ruoli collegati ai servizi e scopri se è possibile creare il ruolo dalle API del servizio. Se l'API del servizio non è supportata, puoi utilizzarla per creare un ruolo collegato al servizio con la policy di fiducia e le politiche in linea necessarie al servizio per assumere il ruolo. AWS 

**Per creare un ruolo collegato al servizio (API)AWS **

Utilizzare la chiamata API [CreateServiceLinkedRole](https://docs.aws.amazon.com/IAM/latest/APIReference/API_CreateServiceLinkedRole.html). Nella richiesta, specificare un nome del servizio di `SERVICE_NAME_URL.amazonaws.com`. 

Ad esempio, per creare il ruolo collegato ai servizi **Lex Bots (Bot di Lex)**, utilizzare `lex.amazonaws.com`.

# Creazione di un ruolo per un provider di identità di terze parti
<a name="id_roles_create_for-idp"></a>

Puoi utilizzare provider di identità invece di creare utenti IAM nel tuo Account AWS. Con un provider di identità (IdP), puoi gestire le tue identità utente all'esterno AWS e concedere a queste identità utente esterne le autorizzazioni per accedere AWS alle risorse del tuo account. Per ulteriori informazioni sulla federazione e sui provider di identità, consultare [Provider di identità e federazione in AWS](id_roles_providers.md).

## Creazione di un ruolo per i principali federati OIDC e SAML (console)
<a name="roles-creatingrole-federated-users-console"></a>

Le procedure per la creazione di un ruolo dipendono dalla scelta dei provider di terze parti:
+ Per OpenID Connect (OIDC), consulta [Creare un ruolo per la federazione OpenID Connect (console)](id_roles_create_for-idp_oidc.md).
+ Per SAML 2.0, consulta [Creare un ruolo per una federazione SAML 2.0 (console)](id_roles_create_for-idp_saml.md).

## Creazione di un ruolo per l'accesso federato (AWS CLI)
<a name="roles-creatingrole-identityprovider-cli"></a>

Le procedure per creare un ruolo per il provider di identità supportato (OIDC o SAML) dalla AWS CLI sono identiche. La differenza consiste nel contenuto della policy di affidabilità creata in passaggi preliminari. Inizia seguendo le fasi descritte nella sezione dei **prerequisiti** per il tipo di provider in uso:
+ Per un provider OIDC, consulta [Prerequisiti per la creazione di un ruolo per OIDC](id_roles_create_for-idp_oidc.md#idp_oidc_Prerequisites).
+ Per un provider SAML, consulta [Prerequisiti per la creazione di un ruolo per SAML](id_roles_create_for-idp_saml.md#idp_saml_Prerequisites).

La creazione di un ruolo da richiede diversi passaggi. AWS CLI Quando si utilizza la console per creare un ruolo, molti passaggi vengono eseguiti automaticamente, ma con la console AWS CLI è necessario eseguire esplicitamente ogni passaggio da soli. È necessario creare il ruolo e quindi assegnargli una policy di autorizzazione. Puoi anche scegliere di impostare il [limite delle autorizzazioni](access_policies_boundaries.md) per il ruolo.

**Per creare un ruolo (AWS CLI)**

1. Creare un ruolo: [aws iam create-role](https://docs.aws.amazon.com/cli/latest/reference/iam/create-role.html)

1. [Allega una politica di autorizzazioni al ruolo: aws iam attach-role-policy](https://docs.aws.amazon.com/cli/latest/reference/iam/attach-role-policy.html)

    or

   [Crea una politica di autorizzazioni in linea per il ruolo: aws iam put-role-policy](https://docs.aws.amazon.com/cli/latest/reference/iam/put-role-policy.html)

1. (Facoltativo) Aggiungere attributi personalizzati al ruolo collegando tag: [aws iam tag-role](https://docs.aws.amazon.com/cli/latest/reference/iam/tag-role.html)

   Per ulteriori informazioni, consulta [Gestione dei tag sui ruoli (AWS CLI o AWS API) IAM](id_tags_roles.md#id_tags_roles_procs-cli-api).

1. [(Facoltativo) Imposta il [limite delle autorizzazioni](access_policies_boundaries.md) per il ruolo: aws iam put-role-permissions-boundary](https://docs.aws.amazon.com/cli/latest/reference/iam/put-role-permissions-boundary.html)

   Il limite delle autorizzazioni controlla il numero massimo di autorizzazioni che è possibile concedere a un ruolo. I limiti delle autorizzazioni sono una funzionalità avanzata. AWS 

L'esempio seguente mostra i primi due passaggi, più comuni, per la creazione di un ruolo del provider di identità in un ambiente semplice. Questo esempio permette agli utenti dell'account `123456789012` di assumere il ruolo e visualizzare il bucket `example_bucket` di Amazon S3. Questo esempio presuppone inoltre che tu stia eseguendo Windows AWS CLI su un computer che esegue Windows e che lo abbia già configurato AWS CLI con le tue credenziali. Per ulteriori informazioni, consultare la pagina relativa alla [configurazione di AWS Command Line Interface](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-getting-started.html).

La policy di attendibilità di esempio riportata di seguito è progettata per un'app per dispositivi mobili in cui l'utente accede tramite Amazon Cognito. In questo esempio, *us-east:12345678-ffff-ffff-ffff-123456* rappresenta l'ID del pool di identità assegnato da Amazon Cognito.

------
#### [ JSON ]

****  

```
{
    "Version":"2012-10-17",		 	 	 
    "Statement": {
        "Sid": "RoleForCognito",
        "Effect": "Allow",
        "Principal": {"Federated": "cognito-identity.amazonaws.com"},
        "Action": "sts:AssumeRoleWithWebIdentity",
        "Condition": {"StringEquals": {"cognito-identity.amazonaws.com:aud": "us-east:12345678-ffff-ffff-ffff-123456"}}
    }
}
```

------

La policy delle autorizzazioni seguente consente agli utenti che assumono il ruolo di eseguire solo l'operazione `ListBucket` sul bucket `example_bucket` di Amazon S3.

------
#### [ JSON ]

****  

```
{
  "Version":"2012-10-17",		 	 	 
  "Statement": {
    "Effect": "Allow",
    "Action": "s3:ListBucket",
    "Resource": "arn:aws:s3:::example_bucket"
  }
}
```

------

Per creare questo ruolo `Test-Cognito-Role`, è prima necessario salvare la policy di attendibilità precedente con il nome `trustpolicyforcognitofederation.json` e la policy di autorizzazione precedente con il nome `permspolicyforcognitofederation.json` nella cartella `policies` dell'unità `C:` locale. È quindi possibile utilizzare i comandi seguenti per creare il ruolo e collegare la policy inline.

```
# Create the role and attach the trust policy that enables users in an account to assume the role.
$ aws iam create-role --role-name Test-Cognito-Role --assume-role-policy-document file://C:\policies\trustpolicyforcognitofederation.json

# Attach the permissions policy to the role to specify what it is allowed to do.
aws iam put-role-policy --role-name Test-Cognito-Role --policy-name Perms-Policy-For-CognitoFederation --policy-document file://C:\policies\permspolicyforcognitofederation.json
```

## Creazione di un ruolo per l'accesso federato (API)AWS
<a name="roles-creatingrole-identityprovider-api"></a>

Le procedure per creare un ruolo per il provider di identità supportato (OIDC o SAML) dalla AWS CLI sono identiche. La differenza consiste nel contenuto della policy di affidabilità creata in passaggi preliminari. Inizia seguendo le fasi descritte nella sezione dei **prerequisiti** per il tipo di provider in uso:
+ Per un provider OIDC, consulta [Prerequisiti per la creazione di un ruolo per OIDC](id_roles_create_for-idp_oidc.md#idp_oidc_Prerequisites).
+ Per un provider SAML, consulta [Prerequisiti per la creazione di un ruolo per SAML](id_roles_create_for-idp_saml.md#idp_saml_Prerequisites).

**Per creare un ruolo (AWS API)**

1. Crea un ruolo: [CreateRole](https://docs.aws.amazon.com/IAM/latest/APIReference/API_CreateRole.html)

1. Allega una politica di autorizzazioni al ruolo: [AttachRolePolicy](https://docs.aws.amazon.com/IAM/latest/APIReference/API_AttachRolePolicy.html)

    or

   Crea una politica di autorizzazioni in linea per il ruolo: [PutRolePolicy](https://docs.aws.amazon.com/IAM/latest/APIReference/API_PutRolePolicy.html)

1. (Facoltativo) Aggiungi attributi personalizzati all'utente allegando tag: [TagRole](https://docs.aws.amazon.com/IAM/latest/APIReference/API_TagRole.html)

   Per ulteriori informazioni, consulta [Gestione dei tag sugli utenti IAM (AWS CLI o AWS API)](id_tags_users.md#id_tags_users_procs-cli-api).

1. (Facoltativo) Imposta il [limite delle autorizzazioni per il ruolo](access_policies_boundaries.md): [PutRolePermissionsBoundary](https://docs.aws.amazon.com/IAM/latest/APIReference/API_PutRolePermissionsBoundary.html)

   Il limite delle autorizzazioni controlla il numero massimo di autorizzazioni che è possibile concedere a un ruolo. I limiti delle autorizzazioni sono una funzionalità avanzata. AWS 

# Creare un ruolo per la federazione OpenID Connect (console)
<a name="id_roles_create_for-idp_oidc"></a>

Puoi utilizzare i provider di identità federati OpenID Connect (OIDC) invece di creare utenti nel tuo. AWS Identity and Access Management Account AWS Con un provider di identità (IdP), puoi gestire le tue identità utente all'esterno AWS e concedere a queste identità utente esterne le autorizzazioni per accedere AWS alle risorse del tuo account. Per ulteriori informazioni sulla federazione e, vedere. IdPs [Provider di identità e federazione in AWS](id_roles_providers.md)

## Prerequisiti per la creazione di un ruolo per OIDC
<a name="idp_oidc_Prerequisites"></a>

Prima di poter creare un ruolo per la federazione OIDC, devi completare i seguenti passaggi obbligatori.<a name="oidc-prereqs"></a>

**Per prepararsi alla creazione di un ruolo per la federazione OIDC**

1. Registrati con uno o più servizi che offrono l'identità OIDC federata. Se stai creando un'app che richiede l'accesso alle tue AWS risorse, configurala anche con le informazioni del provider. Al momento della registrazione, il gestore fornisce un ID applicazione o destinatario univoco per l'app. Provider diversi utilizzano una terminologia diversa per questo processo. Questa guida utilizza il termine*configurare* per il processo di identificazione dell'applicazione con il provider. È possibile configurare più app con ogni provider o più provider con una sola app. Consulta le informazioni sull'utilizzo degli IdP specificate di seguito:
   + [Centro Sviluppatori di Login with Amazon](https://login.amazon.com/)
   + [Aggiunta dell'accesso a Facebook a un'app o a un sito Web](https://developers.facebook.com/docs/facebook-login/v2.1) sul sito degli sviluppatori di Facebook.
   + [Utilizzo della OAuth versione 2.0 per il login (OpenID Connect)](https://developers.google.com/accounts/docs/OAuth2Login) sul sito degli sviluppatori di Google.

1. <a name="idpoidcstep2"></a>Dopo aver ricevuto le informazioni richieste dall'IdP, crea un IdP in IAM. Per ulteriori informazioni, consulta [Creare un provider di identità OpenID Connect (OIDC) in IAM](id_roles_providers_create_oidc.md).
**Importante**  
Se utilizzi un IdP OIDC di Google, Facebook o Amazon Cognito, non occorre creare un IdP IAM separato nella Console di gestione AWS. Questi provider di identità OIDC sono già integrati AWS e possono essere utilizzati. Ignora questa fase e vai alla fase successiva per creare nuovi ruoli utilizzando l'IdP.

1. Prepara le policy per il ruolo che verrà assunto dagli utenti autenticati dal provider di identità. Come qualsiasi altro ruolo, anche il ruolo per un'app per dispositivi mobili include due policy. Una è la policy di affidabilità, che specifica chi può assumere il ruolo. L'altra è la policy di autorizzazione, che specifica le operazioni e le risorse AWS a cui l'app per dispositivi mobili può accedere o meno.

   Per il Web IdPs, ti consigliamo di utilizzare [Amazon Cognito](https://aws.amazon.com/cognito/) per gestire le identità. In tal caso, si utilizza una policy di attendibilità simile all'esempio seguente.

------
#### [ JSON ]

****  

   ```
   {
       "Version":"2012-10-17",		 	 	 
       "Statement": {
           "Effect": "Allow",
           "Principal": {"Federated": "cognito-identity.amazonaws.com"},
           "Action": "sts:AssumeRoleWithWebIdentity",
           "Condition": {
               "StringEquals": {"cognito-identity.amazonaws.com:aud": "us-east-2:12345678-abcd-abcd-abcd-123456"},
               "ForAnyValue:StringLike": {"cognito-identity.amazonaws.com:amr": "unauthenticated"}
           }
       }
   }
   ```

------

   Sostituisci `us-east-2:12345678-abcd-abcd-abcd-123456` con l'ID del pool di identità che ti ha assegnato Amazon Cognito.

   Nella configurazione manuale di un IdP OIDC, al momento della creazione della policy di attendibilità occorre utilizzare tre valori che garantiscono che solo l'app in questione possa assumere quel ruolo:
   + Per l'elemento `Action`, si utilizza l'operazione `sts:AssumeRoleWithWebIdentity`.
   + Per l'elemento `Principal`, usa la stringa `{"Federated":providerUrl/providerArn}`.
     + Per alcuni OIDC comuni IdPs, si tratta di un URL. `providerUrl` Gli esempi seguenti includono metodi per specificare il principale per alcuni casi comuni: IdPs

       `"Principal":{"Federated":"cognito-identity.amazonaws.com"}`

       `"Principal":{"Federated":"www.amazon.com"}`

       `"Principal":{"Federated":"graph.facebook.com"}`

       `"Principal":{"Federated":"accounts.google.com"}`
     + Per gli altri gestori OIDC, utilizza il nome della risorsa Amazon (ARN) dell'IdP OIDC creato in [Step 2](#idpoidcstep2), come nell'esempio seguente:

       `"Principal":{"Federated":"arn:aws:iam::123456789012:oidc-provider/server.example.com"}`
   + Per l'elemento `Condition`, si utilizza una condizione `StringEquals` per limitare le autorizzazioni. È necessario testare l'ID del pool di identità per Amazon Cognito o l'ID app per altri provider. L'ID del pool di identità dovrebbe corrispondere all'ID app che hai ricevuto durante la configurazione dell'app con l'IdP. Questa corrispondenza tra i IDs garantisce che la richiesta provenga dalla tua app.
**Nota**  
I ruoli IAM per i pool di identità di Amazon Cognito si affidano al principale del servizio `cognito-identity.amazonaws.com` per assumere il ruolo. I ruoli di questo tipo devono contenere almeno una chiave di condizione per limitare i principali che possono assumere il ruolo.  
Considerazioni aggiuntive si applicano ai pool di identità di Amazon Cognito che assumono [ruoli IAM su più account](access_policies-cross-account-resource-access.md). Le policy di attendibilità di questi ruoli devono accettare il principale del servizio `cognito-identity.amazonaws.com` e devono contenere la chiave di condizione `aud` per limitare l'assunzione di ruoli agli utenti dei pool di identità previsti. Una policy che considera attendibili i pool di identità di Amazon Cognito senza questa condizione comporta il rischio che un utente proveniente da un pool di identità non intenzionale possa assumere il ruolo. Per ulteriori informazioni, consulta [Policy di attendibilità per i ruoli IAM nell'autenticazione di base (classica)](https://docs.aws.amazon.com/cognito/latest/developerguide/iam-roles.html#trust-policies) nella *Guida per gli sviluppatori di Amazon Cognito*.

     Crea un elemento condizione simile agli esempi seguenti, a seconda dell'IdP in uso: 

     `"Condition": {"StringEquals": {"cognito-identity.amazonaws.com:aud": "us-east:12345678-ffff-ffff-ffff-123456"}}`

     `"Condition": {"StringEquals": {"www.amazon.com:app_id": "amzn1.application-oa2-123456"}}`

     `"Condition": {"StringEquals": {"graph.facebook.com:app_id": "111222333444555"}}`

     `"Condition": {"StringEquals": {"accounts.google.com:aud": "66677788899900pro0"}}`

     Per i provider OIDC, si utilizza l'URL completo del provider di identità OIDC con la chiave di contesto `aud`, come nell'esempio seguente: 

     `"Condition": {"StringEquals": {"server.example.com:aud": "appid_from_oidc_idp"}}`
**Nota**  
I valori per il principale nella policy di attendibilità per il ruolo sono specifici dell'IdP. Un ruolo per OIDC può specificare solo un principale. Pertanto, se l'app per dispositivi mobili consente agli utenti di effettuare l'accesso da più di un IdP, devi creare un ruolo separato per ogni IdP da supportare. Crea policy di attendibilità separate per ogni IdP.

   Se un utente utilizza un'app per dispositivi mobili per accedere da Login with Amazon, si applica la policy di attendibilità di esempio riportata di seguito. Nell'esempio, *amzn1.application-oa2-123456* rappresenta l'ID dell'app che Amazon assegna quando hai configurato l'app utilizzando Login with Amazon.

------
#### [ JSON ]

****  

   ```
   {
         "Version":"2012-10-17",		 	 	 
         "Statement": [{
             "Sid": "RoleForLoginWithAmazon",
             "Effect": "Allow",
             "Principal": {"Federated": "www.amazon.com"},
             "Action": "sts:AssumeRoleWithWebIdentity",
             "Condition": {"StringEquals": {"www.amazon.com:app_id": "amzn1.application-oa2-123456"}}
         }]
     }
   ```

------

   Se un utente utilizza un'app per dispositivi mobili per accedere da Facebook, si applica la policy di attendibilità di esempio riportata di seguito. In questo esempio, *111222333444555* rappresenta l'ID dell'app assegnato da Facebook.

------
#### [ JSON ]

****  

   ```
   {
         "Version":"2012-10-17",		 	 	 
         "Statement": [{
             "Sid": "RoleForFacebook",
             "Effect": "Allow",
             "Principal": {"Federated": "graph.facebook.com"},
             "Action": "sts:AssumeRoleWithWebIdentity",
             "Condition": {"StringEquals": {"graph.facebook.com:app_id": "111222333444555"}}
         }]
     }
   ```

------

   Se un utente utilizza un'app per dispositivi mobili per accedere da Google, si applica la policy di attendibilità di esempio riportata di seguito. In questo esempio, *666777888999000* rappresenta l'ID dell'app assegnato da Google.

------
#### [ JSON ]

****  

   ```
   {
         "Version":"2012-10-17",		 	 	 
         "Statement": [{
             "Sid": "RoleForGoogle",
             "Effect": "Allow",
             "Principal": {"Federated": "accounts.google.com"},
             "Action": "sts:AssumeRoleWithWebIdentity",
             "Condition": {"StringEquals": {"accounts.google.com:aud": "666777888999000"}}
         }]
     }
   ```

------

   Se un utente utilizza un'app per dispositivi mobili per accedere da Amazon Cognito, si applica la policy di attendibilità di esempio riportata di seguito. In questo esempio, *us-east:12345678-ffff-ffff-ffff-123456* rappresenta l'ID del pool di identità assegnato da Amazon Cognito.

------
#### [ JSON ]

****  

   ```
   {
         "Version":"2012-10-17",		 	 	 
         "Statement": [{
             "Sid": "RoleForCognito",
             "Effect": "Allow",
             "Principal": {"Federated": "cognito-identity.amazonaws.com"},
             "Action": "sts:AssumeRoleWithWebIdentity",
             "Condition": {"StringEquals": {"cognito-identity.amazonaws.com:aud": "us-east:12345678-ffff-ffff-ffff-123456"}}
         }]
     }
   ```

------

## Creazione di un ruolo per OIDC
<a name="idp_oidc_Create"></a>

Una volta completati i prerequisiti, puoi creare il ruolo in IAM. *Per i provider di identità OpenID Connect (OIDC) condivisi riconosciuti, IAM richiede una valutazione esplicita di affermazioni specifiche in JSON Web Tokens (IdPs), note come controlli del provider di identità. JWTs* *Per ulteriori informazioni su quali OIDC dispongono dei controlli dei provider di identità, consulta. IdPs * [Controlli tramite provider di identità per i provider OIDC condivisi](id_roles_providers_oidc_secure-by-default.md)

Nella procedura seguente viene descritto come creare il ruolo per la federazione OIDC nella Console di gestione AWS. Per creare un ruolo dall' AWS API AWS CLI or, consulta le procedure disponibili all'indirizzo. [Creazione di un ruolo per un provider di identità di terze parti](id_roles_create_for-idp.md)

**Importante**  
Se utilizzi Amazon Cognito, utilizza la console di Amazon Cognito per configurare i ruoli. In caso contrario, usa la console IAM per creare un ruolo per la federazione OIDC.

**Per creare un ruolo IAM per la federazione OIDC**

1. 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. Nel riquadro di navigazione, scegli **Ruoli**, quindi **Crea ruolo**.

1. Scegli **Identità Web** come tipo di entità attendibile e seleziona **Avanti**.

1. Per **Identity provider** (Gestore dell'identità digitale [IdP]), scegli l'IdP per il ruolo: 
   + Se vuoi creare un ruolo per un singolo IdP Web, scegli **Login with Amazon**, **Facebook** o **Google**. 
**Nota**  
Devi creare un ruolo separato per ogni IdP che intendi supportare.
   + Se vuoi creare un ruolo per uno scenario avanzato per Amazon Cognito, scegli **Amazon Cognito**. 
**Nota**  
Devi creare manualmente un ruolo da utilizzare con Amazon Cognito solo quando operi in uno scenario avanzato. In caso contrario, i ruoli possono essere creati da Amazon Cognito. Per ulteriori informazioni su Amazon Cognito, consulta la pagina [Provider di identità esterni di pool di identità (identità federate)](https://docs.aws.amazon.com/cognito/latest/developerguide/external-identity-providers.html) nella *Guida per gli sviluppatori di Amazon Cognito*. 
   + Se desideri creare un ruolo per GitHub Actions, devi iniziare aggiungendo il provider GitHub OIDC a IAM. **Dopo aver aggiunto il provider GitHub OIDC a IAM, scegli token.actions.githubusercontent.com.** 
**Nota**  
Per informazioni su come configurare AWS il provider OIDC GitHub di Trust come identità federata, consulta [GitHub Docs - Configuring OpenID Connect in](https://docs.github.com/en/actions/deployment/security-hardening-your-deployments/configuring-openid-connect-in-amazon-web-services) Amazon Web Services. Per informazioni sulle best practice per limitare l'accesso ai ruoli associati a IAM IdP GitHub for, [Configurazione di un ruolo per il provider di GitHub identità OIDC](#idp_oidc_Create_GitHub) consulta questa pagina.
   + Se desideri creare un ruolo per HashiCorp Cloud Platform (HCP) Terraform, devi iniziare aggiungendo il provider Terraform OIDC a IAM. Dopo aver aggiunto il provider OIDC Terraform a IAM, scegli **app.terraform.io**. 
**Importante**  
Il provider IAM roles for HashiCorp Cloud Platform (HCP) Terraform OIDC deve valutare la chiave delle condizioni IAM, nella policy di fiducia dei ruoli. `app.terraform.io:sub` Questa chiave di condizione limita le organizzazioni, i progetti, gli spazi di lavoro o le fasi di esecuzione di HCP Terraform in grado di assumere il ruolo. Senza questa condizione chiave, la vostra policy di fiducia concede l'accesso al vostro ruolo e alle vostre AWS risorse da parte di identità esterne all'organizzazione, il che non è in linea con il principio del privilegio minimo.   
Se imposti o modifichi una politica di fiducia per un ruolo associato al provider HCP Terraform OIDC nel tuo AWS account, ma non valuti la chiave di condizione IAM, riceverai un errore. `app.terraform.io:sub` Inoltre, AWS STS negherà le richieste di autorizzazione se la policy di attendibilità del ruolo non valuta questa chiave di condizione.

1. Le informazioni richieste variano in base al provider OIDC scelto.
   + Inserisci l'identificatore per l'applicazione. L'etichetta relativa all'identificatore cambia in base al gestore scelto:
     + Se vuoi creare un ruolo per Login with Amazon, inserisci l'ID app nella casella **Application ID** (ID applicazione).
     + Se vuoi creare un ruolo per Facebook, inserisci l'ID app nella casella **Application ID** (ID applicazione).
     + Se vuoi creare un ruolo per Google, inserisci il nome del destinatario nella casella **Audience** (Destinatario).
     + Se vuoi creare un ruolo per Amazon Cognito, inserisci l'ID del pool di identità che hai creato per le applicazioni Amazon Cognito nella casella **Identity Pool ID** (ID pool di identità).
   + Se desideri creare un ruolo per GitHub Actions, inserisci i seguenti dettagli:
     + Per **Pubblico**, scegli `sts.amazonaws.com`.
     + Per **GitHub l'organizzazione**, inserisci il nome GitHub dell'organizzazione. Il nome GitHub dell'organizzazione è obbligatorio e deve essere alfanumerico, compresi i trattini (-). Non puoi usare caratteri jolly (\$1 e?) nel nome dell' GitHub organizzazione.
     + (Facoltativo) Per il **GitHub repository**, inserisci il nome del GitHub repository. Se non specifichi un valore, viene utilizzato un carattere jolly (`*`) per impostazione predefinita.
     + (Facoltativo) Per il **GitHub ramo**, inserisci il nome del GitHub ramo. Se non specifichi un valore, viene utilizzato un carattere jolly (`*`) per impostazione predefinita.
   + Se desideri creare un ruolo per HashiCorp Cloud Platform (HCP) Terraform, inserisci i seguenti dettagli:
     + Per **Pubblico**, scegli `aws.workload.identity`.
     + Per **Organizzazione**, inserisci il nome dell'organizzazione. È possibile specificare un carattere jolly (`*`) per tutte le organizzazioni.
     + Per **Progetto**, inserisci il nome del progetto. È possibile specificare un carattere jolly (`*`) per tutti i progetti.
     + In **Spazio di lavoro**, immetti un nome per lo spazio di lavoro. È possibile specificare un carattere jolly (`*`) per tutti gli spazi di lavoro.
     + Per **Fase di esecuzione**, inserisci il nome della fase di esecuzione. È possibile specificare un carattere jolly (`*`) per tutte le fasi di esecuzione.

1. (Facoltativo) In **Condizione (facoltativo)** scegli **Aggiungi condizione**per creare condizioni aggiuntive che devono essere soddisfatte prima che gli utenti dell'applicazione possano utilizzare le autorizzazioni concesse dal ruolo. Ad esempio, puoi aggiungere una condizione che conceda l'accesso alle AWS risorse solo per uno specifico ID utente IAM. Puoi anche aggiungere condizioni alla policy di attendibilità dopo la creazione del ruolo. Per ulteriori informazioni, consulta [Aggiornamento di una policy di attendibilità del ruolo](id_roles_update-role-trust-policy.md).

1. Verifica le informazioni su OIDC, quindi seleziona **Successivo**.

1. IAM include un elenco delle politiche AWS gestite e gestite dai clienti nel tuo account. Seleziona la policy delle autorizzazioni da utilizzare o scegli **Create policy** (Crea policy) per aprire una nuova scheda del browser e creare una nuova policy da zero. Per ulteriori informazioni, consulta [Creazione di policy IAM](access_policies_create-console.md#access_policies_create-start). Una volta creata la policy, chiudere la scheda e tornare alla scheda originale. Seleziona la casella di controllo accanto alle policy di autorizzazione che si desidera abbiano gli utenti OIDC. È anche possibile non selezionare le policy ora e collegarle al ruolo in un secondo momento. Per default, un ruolo non dispone di autorizzazioni.

1. (Facoltativo) Impostare un [limite delle autorizzazioni](access_policies_boundaries.md). Questa è una caratteristica avanzata.

   Apri la sezione **Permissions boundary** (Limite delle autorizzazioni) e scegli **Use a permissions boundary to control the maximum role permissions** (Usa un limite delle autorizzazioni per controllare il numero massimo di autorizzazioni del ruolo). Selezionare la policy da utilizzare per il limite delle autorizzazioni.

1. Scegli **Next (Successivo)**.

1. In **Role name**, (Nome ruolo), inserisci un nome. I nomi dei ruoli devono essere univoci all'interno del tuo Account AWS. Non fanno distinzione tra maiuscole e minuscole. Ad esempio, non è possibile creare ruoli denominati sia **PRODROLE** sia **prodrole**. Poiché altre AWS risorse potrebbero fare riferimento al ruolo, non puoi modificare il nome del ruolo dopo averlo creato.

1. (Facoltativo) In **Description** (Descrizione), inserisci una descrizione per il nuovo ruolo.

1. Per modificare i casi d'uso e le autorizzazioni per il ruolo, scegli **Edit** (Modifica) nelle sezioni **Step 1: Select trusted entities** (Fase 1: seleziona le entità attendibili) o **Step 2: Add permissions** (Fase 2: aggiungi autorizzazioni). 

1. (Facoltativo) Per aggiungere metadati al ruolo, collegare i tag come coppie chiave-valore. Per ulteriori informazioni sull'utilizzo dei tag in IAM, consultare [Tag per AWS Identity and Access Management le risorse](id_tags.md).

1. Rivedere il ruolo e scegliere **Crea ruolo**.

## Configurazione di un ruolo per il provider di GitHub identità OIDC
<a name="idp_oidc_Create_GitHub"></a>

Se si utilizza GitHub come provider di identità (IdP) OpenID Connect (OIDC), la best practice consiste nel limitare le entità che possono assumere il ruolo associato all'IDP IAM. Quando includi una dichiarazione di condizione nella policy di fiducia, puoi limitare il ruolo a un' GitHuborganizzazione, un repository o una filiale specifici. Puoi usare la chiave di condizione `token.actions.githubusercontent.com:sub` con operatori di condizione delle stringhe per limitare l'accesso. Ti consigliamo di limitare la condizione a un insieme specifico di repository o filiali all'interno dell'organizzazione GitHub . Per informazioni su come configurare AWS l'OIDC GitHub di To Trust come identità federata, consulta [GitHub Docs - Configuring OpenID Connect in](https://docs.github.com/en/actions/deployment/security-hardening-your-deployments/configuring-openid-connect-in-amazon-web-services) Amazon Web Services. 

Se utilizzi GitHub ambienti in flussi di lavoro operativi o in policy OIDC, ti consigliamo vivamente di aggiungere regole di protezione all'ambiente per una maggiore sicurezza. Utilizza i rami e i tag di implementazione per limitare i rami e i tag che possono essere implementati nell'ambiente. Per ulteriori informazioni sulla configurazione degli ambienti con regole di protezione, consulta [i rami e i tag di distribuzione](https://docs.github.com/en/actions/deployment/targeting-different-environments/using-environments-for-deployment#deployment-branches-and-tags) nell'articolo *Utilizzo degli ambienti GitHub* per la distribuzione.

Quando GitHub OIDC IdP è il Principal affidabile per il tuo ruolo, IAM verifica la condizione della policy di fiducia del ruolo per verificare che la chiave della condizione `token.actions.githubusercontent.com:sub` sia presente e che il suo valore non sia solo un carattere jolly (\$1 e?) o null. IAM esegue questo controllo quando la policy di attendibilità viene creata o aggiornata. Se la chiave di condizione `token.actions.githubusercontent.com:sub` non è presente o il valore della chiave non soddisfa i criteri di valore indicati, la richiesta avrà esito negativo e restituirà un errore.

**Importante**  
Se non limiti la chiave di condizione a un'organizzazione o `token.actions.githubusercontent.com:sub` a un repository specifici, GitHub le azioni di organizzazioni o repository al di fuori del tuo controllo possono assumere ruoli associati all' GitHub IdP IAM nel tuo account. AWS 

L'esempio seguente di policy di fiducia limita l'accesso all' GitHub organizzazione, al repository e alla filiale definiti. Il `token.actions.githubusercontent.com:sub` valore della chiave di condizione nell'esempio seguente è il formato predefinito del valore dell'oggetto documentato da. GitHub

------
#### [ JSON ]

****  

```
{
  "Version":"2012-10-17",		 	 	 
  "Statement": [
    {
      "Effect": "Allow",
      "Principal": {
        "Federated": "arn:aws:iam::012345678910:oidc-provider/token.actions.githubusercontent.com"
      },
      "Action": "sts:AssumeRoleWithWebIdentity",
      "Condition": {
        "StringEquals": {
          "token.actions.githubusercontent.com:aud": "sts.amazonaws.com",
          "token.actions.githubusercontent.com:sub": "repo:GitHubOrg/GitHubRepo:ref:refs/heads/GitHubBranch"
        }
      }
    }
  ]
}
```

------

La condizione di esempio seguente limita l'accesso all' GitHub organizzazione e all'archivio definiti, ma concede l'accesso a qualsiasi ramo all'interno del repository.

```
"Condition": {
  "StringEquals": {
          "token.actions.githubusercontent.com:aud": "sts.amazonaws.com"
  },
  "StringLike": {    
    "token.actions.githubusercontent.com:sub": "repo:GitHubOrg/GitHubRepo:*"
  }
}
```

La condizione di esempio seguente limita l'accesso a qualsiasi repository o ramo all'interno dell'organizzazione definita. GitHub Si consiglia di limitare la chiave di condizione `token.actions.githubusercontent.com:sub` a un valore specifico che limiti l'accesso ad GitHub Actions dall'interno GitHub dell'organizzazione.

```
"Condition": {
  "StringEquals": {
          "token.actions.githubusercontent.com:aud": "sts.amazonaws.com"
  },
  "StringLike": {    
    "token.actions.githubusercontent.com:sub": "repo:GitHubOrg/*"
  }
}
```

Per ulteriori informazioni sulle chiavi di federazione OIDC disponibili per i controlli delle condizioni nelle policy, consulta [Chiavi disponibili per la federazione AWS OIDC](reference_policies_iam-condition-keys.md#condition-keys-wif).

# Creare un ruolo per una federazione SAML 2.0 (console)
<a name="id_roles_create_for-idp_saml"></a>

 Puoi utilizzare la federazione SAML 2.0 invece di creare utenti IAM nel tuo Account AWS. Con un provider di identità (IdP), puoi gestire le tue identità utente all'esterno AWS e concedere a queste identità utente esterne le autorizzazioni per accedere AWS alle risorse del tuo account. Per ulteriori informazioni sulla federazione e sui provider di identità, consultare [Provider di identità e federazione in AWS](id_roles_providers.md).

**Nota**  
Per migliorare la resilienza della federazione, ti consigliamo di configurare l'IdP e la federazione AWS per supportare più endpoint di accesso SAML. Per i dettagli, consulta l'articolo del AWS Security Blog [Come utilizzare gli endpoint SAML regionali per](https://aws.amazon.com/blogs//security/how-to-use-regional-saml-endpoints-for-failover) il failover.

## Prerequisiti per la creazione di un ruolo per SAML
<a name="idp_saml_Prerequisites"></a>

Prima di creare un ruolo per la federazione SAML 2.0, devi completare i seguenti passaggi obbligatori.<a name="saml-prereqs"></a>

**Preparazione per la creazione di un ruolo per la federazione SAML 2.0**

1. <a name="idpsamlstep1"></a>Prima di creare un ruolo per la federazione basata su SAML, devi creare un provider SAML in IAM. Per ulteriori informazioni, consulta [Creare un provider di identità SAML in IAM](id_roles_providers_create_saml.md).

1. Prepara le policy per il ruolo che verrà assunto dagli utenti autenticati con SAML 2.0. Come qualsiasi altro ruolo, anche i ruoli per la federazione SAML includono due policy. Una è la policy di attendibilità del ruolo, che specifica chi può assumere il ruolo. L'altra è la politica di autorizzazione IAM che specifica le AWS azioni e le risorse a cui è consentito o negato l'accesso al principale federato SAML.

   Al momento della creazione della policy di attendibilità per il ruolo, devi utilizzare tre valori che garantiscono che solo la tua applicazione possa assumere il ruolo:
   + Per l'elemento `Action`, si utilizza l'operazione `sts:AssumeRoleWithSAML`.
   + Per l'elemento `Principal`, usa la stringa `{"Federated":ARNofIdentityProvider}`. Sostituire `ARNofIdentityProvider` con l'ARN del [provider di identità SAML](id_roles_providers_saml.md) creato in [Step 1](#idpsamlstep1).
   + Per l’elemento `Condition`, utilizza una condizione `StringEquals` per verificare che l’attributo `saml:aud` della risposta SAML corrisponda all’URL visualizzato dal browser quando si accede alla console. L’URL dell’endpoint di accesso corrisponde all’attributo destinatario SAML del provider di identità. Puoi includere l'accesso URLs all'interno di aree geografiche particolari. AWS consiglia di utilizzare gli endpoint regionali anziché l'endpoint globale per migliorare la resilienza della federazione. [Per un elenco dei *region-code* valori possibili, consulta la colonna **Regione** negli AWS endpoint di accesso.](https://docs.aws.amazon.com/general/latest/gr/signin-service.html)

     Se è richiesta la crittografia SAML, l’URL di accesso deve includere l’identificatore univoco che AWS assegna al provider SAML. Puoi visualizzare l’identificatore univoco selezionando il provider di identità nella console IAM per visualizzare la pagina dei dettagli.

     `https://region-code.signin.aws.amazon.com/saml/acs/IdP-ID`

   L'esempio seguente mostra una policy di affidabilità concepita per un utente federato SAML:

------
#### [ JSON ]

****  

   ```
   {
       "Version":"2012-10-17",		 	 	 
       "Statement": {
           "Effect": "Allow",
           "Action": "sts:AssumeRoleWithSAML",
           "Principal": {
               "Federated": "arn:aws:iam::111122223333:saml-provider/PROVIDER-NAME"
           },
           "Condition": {
               "StringEquals": {
                   "SAML:aud": "https://region-code.signin.aws.amazon.com/saml"
               }
           }
       }
   }
   ```

------

   Sostituisci l'ARN principale con l'ARN effettivo del provider SAML, creato in IAM. L'ARN include l'ID account e il nome del provider. 

## Creazione di un ruolo per SAML
<a name="idp_saml_Create"></a>

Dopo aver completato i passaggi dei prerequisiti, è possibile creare il ruolo per la federazione basata su SAML. 

**Per creare un ruolo per una federazione basata su SAML**

1. 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. Nel pannello di navigazione della console IAM, scegli **Ruoli** e quindi **Crea ruolo**.

1. Selezionare il tipo di ruolo **SAML 2.0 federation (Federazione SAML 2.0)**.

1. In **Select a SAML provider** (Seleziona un gestore dell'identità digitale SAML), scegli il gestore per il ruolo. 

1. Selezionare il metodo di livello di accesso SAML 2.0. 
   + Scegli **Consenti solo l'accesso programmatico** per creare un ruolo che può essere assunto a livello di codice dall' AWS API oppure. AWS CLI
   + Scegli **Consenti Console di gestione AWS accesso e programmazione** per creare un ruolo che può essere assunto a livello di codice e da. Console di gestione AWS

   I due comandi sono simili, ma il ruolo che può essere assunto anche tramite console include una policy di affidabilità con una condizione particolare. Tale condizione verifica in modo esplicito che il destinatario SAML (attributo `SAML:aud`) sia impostato sull’endpoint di accesso di AWS per il tuo provider SAML.

1. La procedura per definire gli attributi varia a seconda del tipo di accesso.
   + Se si sta creando un ruolo per l'accesso programmatico, scegliere un attributo dall'elenco **Attributo**. Dopodiché, nella casella **Value** (Valore), inserisci un valore da includere nel ruolo. In questo modo, l'accesso al ruolo viene limitato agli utenti dal provider di identità la cui risposta di autenticazione SAML (asserzione) includa gli attributi specificati. Per fare in modo che il ruolo sia limitato a un sottoinsieme di utenti all'interno dell'organizzazione, specificare almeno un attributo. 
   + Se stai creando un ruolo per scopi programmatici e di Console di gestione AWS accesso, la sezione **Endpoint di accesso** definisce l'URL visualizzato dal browser quando accedi alla console. Questo endpoint è l’attributo destinatario SAML del tuo provider di identità, che corrisponde alla chiave di contesto [`saml:aud`](reference_policies_iam-condition-keys.md#condition-keys-saml). Per ulteriori informazioni, consulta [Configurare le asserzioni SAML per la risposta di autenticazione](id_roles_providers_create_saml_assertions.md).

     1. Scegli **Endpoint regionali** o **Endpoint non regionali**. Ti consigliamo di utilizzare più endpoint di accesso SAML regionali per migliorare la resilienza della federazione.

     1. Per **le regioni**, scegli le aree che il tuo provider SAML supporta per l'accesso. AWS 

     1.  **Affinché l'accesso URLs includa identificatori univoci**, seleziona se gli endpoint di accesso includono gli AWS identificatori univoci assegnati al tuo provider di identità SAML. Questa opzione è necessaria per le asserzioni SAML crittografate. Per ulteriori informazioni, consulta [Federazione SAML 2.0](id_roles_providers_saml.md).

1. Per aggiungere ulteriori condizioni relative agli attributi alla policy di attendibilità, scegli **Condition (optional)** (Condizione [facoltativo]), seleziona la condizione aggiuntiva e specifica un valore. 
**Nota**  
L'elenco include gli attributi SAML più comunemente utilizzati. IAM supporta attributi aggiuntivi che puoi usare per creare condizioni. Per un elenco degli attributi supportati, consulta [Chiavi disponibili per la federazione SAML](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_iam-condition-keys.html#condition-keys-saml). Se si necessita di una condizione per un attributo SAML supportato che non è nell'elenco, è possibile aggiungere tale condizione manualmente. A tale scopo, modificare la policy di attendibilità dopo aver creato il ruolo.

1.  Verifica le informazioni di attendibilità di SAML 2.0, quindi scegli **Next** (Successivo). 

1. IAM include un elenco delle politiche AWS gestite e gestite dai clienti nel tuo account. Seleziona la policy delle autorizzazioni da utilizzare o scegli **Create policy** (Crea policy) per aprire una nuova scheda del browser e creare una nuova policy da zero. Per ulteriori informazioni, consulta [Creazione di policy IAM](access_policies_create-console.md#access_policies_create-start). Una volta creata la policy, chiudere la scheda e tornare alla scheda originale. Seleziona la casella di controllo accanto alle policy di autorizzazione che desideri concedere agli utenti federati SAML. È anche possibile non selezionare le policy ora e collegarle al ruolo in un secondo momento. Per default, un ruolo non dispone di autorizzazioni.

1. (Facoltativo) Impostare un [limite delle autorizzazioni](access_policies_boundaries.md). Questa è una caratteristica avanzata.

   Apri la sezione **Permissions boundary** (Limite delle autorizzazioni) e scegli **Use a permissions boundary to control the maximum role permissions** (Usa un limite delle autorizzazioni per controllare il numero massimo di autorizzazioni del ruolo). Selezionare la policy da utilizzare per il limite delle autorizzazioni.

1. Scegli **Next (Successivo)**.

1. Scegli **Prossimo: Rivedi**.

1. In **Role name**, (Nome ruolo), inserisci un nome. I nomi dei ruoli devono essere univoci all'interno del tuo Account AWS. Non si distinguono per caso. Ad esempio, non è possibile creare ruoli denominati sia **PRODROLE** che **prodrole**. Poiché altre AWS risorse potrebbero fare riferimento al ruolo, non è possibile modificare il nome del ruolo dopo che è stato creato. 

1. (Facoltativo) In **Description** (Descrizione), inserisci una descrizione per il nuovo ruolo.

1. Scegli **Edit** (Modifica) nelle sezioni **Step 1: Select trusted entities** (Fase 1: seleziona le entità attendibili) o **Step 2: Add permissions** (Fase 2: aggiungi autorizzazioni) per modificare i casi d'uso e le autorizzazioni per il ruolo. 

1. (Facoltativo) Aggiungere metadati al ruolo collegando i tag come coppie chiave-valore. Per ulteriori informazioni sull'utilizzo dei tag in IAM, consultare [Tag per AWS Identity and Access Management le risorse](id_tags.md).

1. Rivedere il ruolo e scegliere **Crea ruolo**.

Una volta creato il ruolo, è possibile completare la relazione di trust SAML configurando il software provider di identità con informazioni su AWS. Queste informazioni includono i ruoli che devono utilizzare gli utenti federati SAML. Tale operazione viene definita configurazione della relazione di trust fra IdP e AWS. Per ulteriori informazioni, consulta [Configurare il provider di identità SAML 2.0 con una relazione di attendibilità della parte affidabile e aggiunta di attestazioni](id_roles_providers_create_saml_relying-party.md). 

# Creare un ruolo utilizzando policy di attendibilità personalizzate
<a name="id_roles_create_for-custom"></a>

Puoi creare una politica di fiducia personalizzata per delegare l'accesso e consentire ad altri di eseguire azioni nel tuo Account AWS. Per ulteriori informazioni, consulta [Creazione di policy IAM](access_policies_create-console.md#access_policies_create-start).

Per informazioni su come utilizzare i ruoli per delegare le autorizzazioni, consultare [Termini e concetti dei ruoli](id_roles.md#id_roles_terms-and-concepts).

## Creazione di un ruolo IAM utilizzando una policy di attendibilità personalizzata (console)
<a name="roles-creatingrole-custom-trust-policy-console"></a>

Puoi utilizzare il Console di gestione AWS per creare un ruolo che un utente IAM può assumere. Ad esempio, supponiamo che l'organizzazione disponga di più Account AWS elementi per isolare un ambiente di sviluppo da un ambiente di produzione. Per informazioni di alto livello sulla creazione di un ruolo che consenta agli utenti nell'account di sviluppo di accedere alle risorse nell'account di produzione, consulta la sezione [Esempio di uno scenario in cui si utilizzano account di sviluppo e produzione separati](id_roles_common-scenarios_aws-accounts.md#id_roles_common-scenarios_aws-accounts-example).

**Creare un ruolo utilizzando una policy di attendibilità personalizzata (console)**

1. 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. Nel riquadro di navigazione della console, selezionare **Ruoli** e **Crea ruolo**.

1. Scegli il tipo di ruolo **Custom trust policy** (Policy di attendibilità personalizzata).

1. Nella sezione **Custom trust policy** (Policy di attendibilità personalizzata), inserisci o incolla la policy di attendibilità personalizzata per il ruolo. Per ulteriori informazioni, consulta [Creazione di policy IAM](access_policies_create-console.md#access_policies_create-start).

1. Risolvi eventuali avvisi di sicurezza, errori o avvisi generali generati durante la [convalida delle policy](access_policies_policy-validator.md), quindi scegli **Next** (Successivo).

1. (Facoltativo) Impostare un [limite delle autorizzazioni](access_policies_boundaries.md). Questa è una funzionalità avanzata disponibile per i ruoli di servizio, ma non per i ruoli collegati ai servizi.

   Apri la sezione **Permissions boundary** (Limite delle autorizzazioni) e scegli **Use a permissions boundary to control the maximum role permissions** (Usa un limite delle autorizzazioni per controllare il numero massimo di autorizzazioni del ruolo). IAM include un elenco delle politiche AWS gestite e gestite dai clienti nel tuo account. Selezionare la policy da utilizzare per il limite delle autorizzazioni.

1. Scegli **Next (Successivo)**.

1. Il grado di personalizzazione per **Nome ruolo** viene definito dal servizio. Se il servizio definisce il nome del ruolo, questa opzione non può essere modificata. In altri casi, il servizio può definire un prefisso per il ruolo e consentire all'utente di aggiungere un suffisso opzionale. Alcuni servizi consentono di specificare l'intero nome del ruolo.

   Se possibile, inserisci un nome del ruolo o un suffisso del nome del ruolo. I nomi dei ruoli devono essere univoci all'interno del tuo Account AWS. Non si distinguono per caso. Ad esempio, non è possibile creare ruoli denominati sia **PRODROLE** che **prodrole**. Poiché altre AWS risorse potrebbero fare riferimento al ruolo, non è possibile modificare il nome del ruolo dopo che è stato creato.

1. (Facoltativo) In **Descrizione**, inserisci una descrizione per il nuovo ruolo.

1. (Facoltativo) Scegli **Modifica** nelle sezioni **Fase 1: seleziona le entità attendibili** o **Fase 2: aggiungi autorizzazioni** per modificare la policy personalizzata e le autorizzazioni per il ruolo. 

1. (Facoltativo) Aggiungere metadati al ruolo collegando i tag come coppie chiave-valore. Per ulteriori informazioni sull'utilizzo dei tag in IAM, consultare [Tag per AWS Identity and Access Management le risorse](id_tags.md).

1. Rivedere il ruolo e scegliere **Crea ruolo**.

# Esempi di policy per la delega dell'accesso
<a name="id_roles_create_policy-examples"></a>

Gli esempi seguenti mostrano come consentire o concedere Account AWS l'accesso alle risorse di un altro Account AWS. Per ulteriori informazioni su come creare una policy IAM utilizzando questi documenti di policy JSON, consulta [Creazione di policy utilizzando l'editor JSON](access_policies_create-console.md#access_policies_create-json-editor).

**Topics**
+ [Utilizzo dei ruoli per delegare l'accesso alle risorse di altre Account AWS risorse](#example-delegate-xaccount-rolesapi)
+ [Utilizzo di una policy per delegare l'accesso ai servizi](#id_roles_create_policy-examples-access-to-services)
+ [Utilizzo di una policy basata sulle risorse per delegare l'accesso a un bucket Amazon S3 in un altro account](#example-delegate-xaccount-S3)
+ [Utilizzo di una policy basata sulle risorse per delegare l'accesso a una coda Amazon SQS in un altro account](#example-delegate-xaccount-SQS)
+ [Impossibile delegare l'accesso quando l'accesso all'account è rifiutato](#example-delegate-xaccount-SQS-denied)

## Utilizzo dei ruoli per delegare l'accesso alle risorse di altre Account AWS risorse
<a name="example-delegate-xaccount-rolesapi"></a>

 Per un tutorial che mostra come utilizzare i ruoli IAM per concedere agli utenti di un account l'accesso alle AWS risorse presenti in un altro account, consulta[Tutorial IAM: delega l'accesso tra AWS account utilizzando i ruoli IAM](tutorial_cross-account-with-roles.md). 

**Importante**  
È possibile includere l'ARN per un ruolo o utente specifico nell'elemento `Principal` di una policy di affidabilità del ruolo. Quando si salva la policy, AWS trasforma l'ARN in un ID principale univoco. Ciò aiuta a mitigare il rischio che qualcuno aumenti i propri privilegi rimuovendo e ricreando il ruolo o l'utente. Questa ID nella console non è normalmente presente, in quanto c'è anche una trasformazione inversa verso il nome ARN quando la policy di affidabilità viene visualizzata. Tuttavia, se si elimina il ruolo o l'utente, la relazione viene interrotta. La policy non è più applicabile, anche se si ricrea l'utente o il ruolo perché non corrisponde all'ID principale archiviato nella policy di attendibilità. Quando ciò accade, l'ID principale viene visualizzato nella console perché non è più AWS possibile mapparlo su un ARN. Il risultato è che se si elimina e si ricrea un utente o un ruolo referenziato in un elemento `Principal` della policy di attendibilità, è necessario modificare il ruolo per sostituire il nome ARN. L'utente o il ruolo viene trasformato nel nuovo ID principale quando si salva la policy.

## Utilizzo di una policy per delegare l'accesso ai servizi
<a name="id_roles_create_policy-examples-access-to-services"></a>

L'esempio seguente mostra una policy che può essere collegata a un ruolo. La policy consente a due servizi, Amazon EMR e AWS Data Pipeline, di assumere il ruolo. I servizi possono eseguire qualsiasi attività concesse da una policy di autorizzazioni assegnata al ruolo (non visualizzato). Per specificare più principali del servizio, non si specificano due elementi `Service`, è possibile averne solo uno. Utilizzare invece una serie di principali del servizio come il valore di un elemento singolo `Service`.

------
#### [ JSON ]

****  

```
{
  "Version":"2012-10-17",		 	 	 
  "Statement": [
    {
      "Effect": "Allow",
      "Principal": {
        "Service": [
          "elasticmapreduce.amazonaws.com",
          "datapipeline.amazonaws.com"
        ]
      },
      "Action": "sts:AssumeRole"
    }
  ]
}
```

------

## Utilizzo di una policy basata sulle risorse per delegare l'accesso a un bucket Amazon S3 in un altro account
<a name="example-delegate-xaccount-S3"></a>

In questo esempio, l'account A utilizza una policy basata sulle risorse (una [policy del bucket](https://docs.aws.amazon.com/AmazonS3/latest/userguide/UsingBucketPolicies.html) Amazon S3) per concedere all'account B l'accesso completo al bucket S3 dell'account A. A questo punto, l'account B crea una policy utente IAM per delegare tale accesso al bucket dell'account A a uno degli utenti nell'account B. 

La policy del bucket S3 nell'account A potrebbe essere simile alla policy seguente. In questo esempio, il bucket S3 dell'account A è denominato *amzn-s3-demo-bucket* e il numero dell'account B è 111122223333. Non specifica alcun utente o gruppo nell'account B, ma solo l'account stesso.

------
#### [ JSON ]

****  

```
{
  "Version":"2012-10-17",		 	 	 
  "Statement": {
    "Sid": "AccountBAccess1",
    "Effect": "Allow",
    "Principal": {"AWS": "111122223333"},
    "Action": "s3:*",
    "Resource": [
      "arn:aws:s3:::amzn-s3-demo-bucket",
      "arn:aws:s3:::amzn-s3-demo-bucket/*"
    ]
  }
}
```

------

In alternativa, l'account A può utilizzare Amazon S3 [Access Control Lists (ACLs)](https://docs.aws.amazon.com/AmazonS3/latest/userguide/S3_ACLs_UsingACLs.html) per concedere all'account B l'accesso a un bucket S3 o a un singolo oggetto all'interno di un bucket. In questo caso, l'unica cosa che cambia è il modo in cui l'account A concede l'accesso all'account B. L'account B utilizza ancora una policy per delegare l'accesso a un gruppo IAM nell'account B, come descritto nella parte successiva di questo esempio. Per maggiori informazioni sul controllo dell'accesso a bucket e oggetti S3, passa a [Controllo accessi](https://docs.aws.amazon.com/AmazonS3/latest/userguide/UsingAuthAccess.html) nella *Guida per l'utente di Amazon Simple Storage Service*. 

L'amministratore dell'account B potrebbe creare le seguenti policy di esempio. La policy permette l'accesso in lettura a un gruppo o un utente nell'account B. La policy precedente concede l'accesso all'account B. Tuttavia, i singoli gruppi e gli utenti dell'account B non possono accedere alla risorsa finché una policy utente o di gruppo non concede esplicitamente le autorizzazioni alla risorsa. Le autorizzazioni in questa policy possono essere solo un subset di quelli nella precedente policy multiaccount. L'account B non può concedere più autorizzazioni ai propri gruppi e utenti rispetto a quanti concessi dall'account A all'account B nella prima policy. In questa policy, l'elemento `Action` è esplicitamente definito per permettere solo operazioni `List` e l'elemento `Resource` di questa policy corrisponde all'elemento `Resource` per la policy del bucket implementata dall'account A.

Per implementare questa policy, l'account B utilizza IAM per collegarla all'utente (o al gruppo) appropriato nell'account B. 

------
#### [ JSON ]

****  

```
{
  "Version":"2012-10-17",		 	 	 
  "Statement": {
    "Effect": "Allow",
    "Action": "s3:List*",
    "Resource": [
      "arn:aws:s3:::amzn-s3-demo-bucket",
      "arn:aws:s3:::amzn-s3-demo-bucket/*"
    ]
  }
}
```

------

## Utilizzo di una policy basata sulle risorse per delegare l'accesso a una coda Amazon SQS in un altro account
<a name="example-delegate-xaccount-SQS"></a>

Nell'esempio seguente, l'account A ha una coda Amazon SQS che utilizza una policy basata sulla risorsa collegata alla coda per concedere l'accesso in coda all'account B. Quindi, l'account B utilizza una policy di gruppo IAM per delegare l'accesso a un gruppo nell'account B. 

La seguente policy di coda di esempio fornisce all'account B l'autorizzazione per eseguire le operazioni `SendMessage` e `ReceiveMessage` sulla coda dell'account A denominata *queue1*, ma solo tra mezzogiorno e le 15:00 del 30 novembre 2014. Il numero dell'account B è 1111-2222-3333. L'account A usa Amazon SQS per implementare questa policy. 

------
#### [ JSON ]

****  

```
{
  "Version":"2012-10-17",		 	 	 
  "Statement": {
    "Effect": "Allow",
    "Principal": {"AWS": "111122223333"},
    "Action": [
      "sqs:SendMessage",
      "sqs:ReceiveMessage"
    ],
    "Resource": ["arn:aws:sqs:*:123456789012:queue1"],
    "Condition": {
      "DateGreaterThan": {"aws:CurrentTime": "2014-11-30T12:00Z"},
      "DateLessThan": {"aws:CurrentTime": "2014-11-30T15:00Z"}
    }
  }
}
```

------

La policy dell'account B per la delega dell'accesso a un gruppo nell'account B potrebbe essere simile all'esempio seguente. L'account B usa IAM per collegare questa policy a un gruppo (o utente). 

------
#### [ JSON ]

****  

```
{
  "Version":"2012-10-17",		 	 	 
  "Statement": {
    "Effect": "Allow",
    "Action": "sqs:*",
    "Resource": "arn:aws:sqs:*:123456789012:queue1"
  }
}
```

------

Nell'esempio della policy utente IAM precedente, l'account B utilizza un carattere jolly per concedere all'utente l'accesso a tutte le operazioni Amazon SQS per la coda dell'account A. Tuttavia, l'account B può delegare l'accesso solo nella misura in cui all'account B è stato concesso l'accesso. Il gruppo dell'account B con la seconda policy può accedere alla coda solo tra mezzogiorno e le 15:00 del 30 novembre 2014. L'utente può eseguire solo le operazioni `SendMessage` e `ReceiveMessage`, come definito nella policy della coda Amazon SQS dell'account A. 

## Impossibile delegare l'accesso quando l'accesso all'account è rifiutato
<a name="example-delegate-xaccount-SQS-denied"></a>

Un Account AWS non può delegare l'accesso alle risorse di un altro account se l'altro account ha negato esplicitamente l'accesso all'account principale dell'utente. Il rifiuto si propaga agli utenti di tale account indipendentemente dal fatto che gli utenti dispongano di policy esistenti che garantiscono loro l'accesso.

Ad esempio, l'account A scrive una policy bucket per il bucket S3 dell'account A che rifiuta esplicitamente l'accesso all'account B per il bucket dell'account A. Tuttavia, l'account B scrive una policy utente IAM che concede a un utente dell'account B l'accesso al bucket dell'account A. Il rifiuto esplicito applicato al bucket S3 dell'account A si propaga agli utenti dell'account B e sostituisce la policy dell'utente IAM che concede l'accesso all'utente dell'account B. Per informazioni dettagliate su come vengono valutate le autorizzazioni, consulta [Logica di valutazione delle policy](reference_policies_evaluation-logic.md). 

La policy del bucket dell'account A potrebbe essere simile alla policy seguente. In questo esempio, il bucket S3 dell'account A è denominato *amzn-s3-demo-bucket* e il numero dell'account B è 1111-2222-3333. L'account A usa Amazon S3 per implementare questa policy. 

------
#### [ JSON ]

****  

```
{
  "Version":"2012-10-17",		 	 	 
  "Statement": {
    "Sid": "AccountBDeny",
    "Effect": "Deny",
    "Principal": {"AWS": "111122223333"},
    "Action": "s3:*",
    "Resource": "arn:aws:s3:::amzn-s3-demo-bucket/*"
  }
}
```

------

Questo rifiuto esplicito sostituisce qualsiasi policy dell'account B che fornisce l'autorizzazione per accedere al bucket S3 nell'account A. 

# Gestione del ruolo IAM
<a name="id_roles_manage"></a>

Prima che un utente, applicazione o servizio possa utilizzare un ruolo che è stato creato, è necessario concedere le autorizzazioni per passare al ruolo. È possibile utilizzare qualsiasi policy collegata a gruppi o utenti per concedere le autorizzazioni necessarie. In questa sezione viene descritto come concedere agli utenti l'autorizzazione per l'utilizzo di un ruolo. Spiega inoltre come l'utente può passare a un ruolo dagli Console di gestione AWS strumenti per Windows PowerShell, da AWS Command Line Interface (AWS CLI) e dall'[https://docs.aws.amazon.com/STS/latest/APIReference/API_AssumeRole.html](https://docs.aws.amazon.com/STS/latest/APIReference/API_AssumeRole.html)API.

**Importante**  
Se crei un ruolo a livello programmatico anziché nella console IAM, hai l'opzione per aggiungere un `Path` con un massimo di 512 caratteri in aggiunta a `RoleName`, che può contenere fino a 64 caratteri. Tuttavia, se intendi utilizzare un ruolo con la funzione **Cambia ruolo** in Console di gestione AWS, la combinazione `Path` `RoleName` non può superare i 64 caratteri.

**Topics**
+ [Visualizzazione dell'accesso per il ruolo](#roles-modify_prerequisites)
+ [Generazione di una policy basata sulle informazioni di accesso](#roles-modify_gen-policy)
+ [Concedere le autorizzazioni agli utenti per cambiare ruoli](id_roles_use_permissions-to-switch.md)
+ [Concedere a un utente le autorizzazioni per passare un ruolo a un servizio AWS](id_roles_use_passrole.md)
+ [Revocare le credenziali di sicurezza temporanee per i ruoli IAM](id_roles_use_revoke-sessions.md)
+ [Aggiornamento di un ruolo collegato ai servizi](id_roles_update-service-linked-role.md)
+ [Aggiornamento di una policy di attendibilità del ruolo](id_roles_update-role-trust-policy.md)
+ [Aggiornamento delle autorizzazioni per un ruolo](id_roles_update-role-permissions.md)
+ [Aggiornamento delle impostazioni per un ruolo](id_roles_update-role-settings.md)
+ [Eliminare i ruoli o i profili delle istanze](id_roles_manage_delete.md)

## Visualizzazione dell'accesso per il ruolo
<a name="roles-modify_prerequisites"></a>

Prima di modificare le autorizzazioni per un ruolo, è opportuno esaminare la sua attività recente a livello di servizio. È un'opzione importante per non rimuovere l'accesso da parte di un principale (persona o applicazione) che la sta utilizzando. Per ulteriori informazioni sulla visualizzazione delle ultime informazioni di accesso, vedere [Perfeziona le autorizzazioni AWS utilizzando le informazioni dell'ultimo accesso](access_policies_last-accessed.md).

## Generazione di una policy basata sulle informazioni di accesso
<a name="roles-modify_gen-policy"></a>

Talvolta, è possibile concedere autorizzazioni a un'entità IAM (utente o ruolo) oltre a quelle richieste. Per ottimizzare le autorizzazioni concesse, puoi generare una policy IAM basata sull'attività di accesso per un'entità. IAM Access Analyzer esamina AWS CloudTrail i log e genera un modello di policy che contiene le autorizzazioni utilizzate dall'entità nell'intervallo di date specificato. È possibile utilizzare il modello per creare una policy gestita con autorizzazioni granulari e quindi collegarla al ruolo IAM. In questo modo, concedi solo le autorizzazioni necessarie all'utente o al ruolo per interagire con le AWS risorse per il tuo caso d'uso specifico. Per ulteriori informazioni, consulta [Generazione di policy per Sistema di analisi degli accessi IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/access-analyzer-policy-generation.html).

# Concedere le autorizzazioni agli utenti per cambiare ruoli
<a name="id_roles_use_permissions-to-switch"></a>

Quando un amministratore [crea un ruolo per l'accesso multi-account](id_roles_create_for-user.md), stabilisce l'attendibilità tra l'account proprietario del ruolo e le risorse (account che determina l'attendibilità) e l'account che contiene gli utenti (account attendibile). A tale scopo, l'amministratore dell'account attendibile specifica il numero dell'account attendibile come `Principal` nella policy di attendibilità del ruolo. Ciò consente *potenzialmente* a qualsiasi utente nell'account attendibile di assumere il ruolo. Per completare la configurazione, l'amministratore dell'account attendibile deve fornire a determinati gruppi o utenti dell'account l'autorizzazione per il passaggio al ruolo.

**Concessione dell'autorizzazione per passare a un ruolo**

1. In qualità di amministratore dell'account attendibile, crea una nuova policy per l'utente oppure modifica una policy esistente per aggiungere gli elementi richiesti. Per informazioni dettagliate, vedi [Creazione o modifica della policy](#roles-usingrole-createpolicy).

1. Quindi decidi come desideri eseguire la condivisione delle informazioni sul ruolo: 
   + **Role link** (Link del ruolo): invia agli utenti un collegamento che indirizza alla pagina **Switch Role** (Cambia ruolo) con tutti i dettagli già compilati. 
   + **ID account o alias:** fornisci a ciascun utente il nome del ruolo insieme al numero dell'ID account o all'alias dell'account. L'utente accede quindi alla pagina **Switch Role (Cambia ruolo)** e aggiunge i dettagli manualmente. 

   Per informazioni dettagliate, vedi [Fornire informazioni all'utente](#roles-usingrole-giveuser).

Tieni presente che puoi cambiare ruolo solo quando effettui l'accesso come utente IAM, come ruolo federato SAML o come ruolo con federazione delle identità Web. Non è possibile cambiare i ruoli se si effettua l'accesso come Utente root dell'account AWS.

**Importante**  
Non è possibile passare da un ruolo Console di gestione AWS a un ruolo che richiede un [ExternalId](id_roles_common-scenarios_third-party.md#id_roles_third-party_external-id)valore. È possibile passare a tale ruolo solo chiamando l'API [https://docs.aws.amazon.com/STS/latest/APIReference/API_AssumeRole.html](https://docs.aws.amazon.com/STS/latest/APIReference/API_AssumeRole.html) che supporta il parametro `ExternalId`.

**Note**  
In questo argomento sono descritte le policy per un *utente* poiché sostanzialmente concedi autorizzazioni a un utente per l'esecuzione di un'operazione. Tuttavia, consigliamo di non concedere le autorizzazioni direttamente a un singolo utente. Quando un utente assume un ruolo, gli vengono assegnate le autorizzazioni associate a quel ruolo.
Quando si cambia ruolo in Console di gestione AWS, la console utilizza sempre le credenziali originali per autorizzare il passaggio. Questo vale sia per l'accesso come utente IAM che come ruolo federato SAML o come ruolo federato di identità Web. Ad esempio, se passi al RuoloA, IAM; utilizza le tue credenziali utente originali o le credenziali del ruolo federato per determinare se è possibile assumere il RuoloA. Se provi quindi a passare al RuoloB *mentre stai utilizzando il RuoloA*, per autorizzare il tentativo vengono utilizzate le credenziali utente **originali** o le credenziali del ruolo federato. Le credenziali per RuoloA non vengono utilizzate per questa operazione.

**Topics**
+ [Creazione o modifica della policy](#roles-usingrole-createpolicy)
+ [Fornire informazioni all'utente](#roles-usingrole-giveuser)

## Creazione o modifica della policy
<a name="roles-usingrole-createpolicy"></a>

Una policy che concede a un utente l'autorizzazione di assumere un ruolo deve includere una dichiarazione con effetto `Allow` per quanto segue: 
+ L'operazione `sts:AssumeRole`
+ L'Amazon Resource Name (ARN) del ruolo in un elemento `Resource`

Agli utenti che ottengono la policy (mediante l'appartenenza a un gruppo o collegata direttamente) è consentito cambiare ruoli sulla risorsa specificata.

**Nota**  
Se `Resource` è impostato su `*`, l'utente può assumere qualsiasi ruolo in qualsiasi account che considera l'account utente attendibile. (In altre parole, la policy di attendibilità del ruolo specifica l'account dell'utente come `Principal`). Come best practice, si consiglia di seguire il [principio di privilegio minimo](http://en.wikipedia.org/wiki/Principle_of_least_privilege) e specificare l'ARN completo solo per i ruoli necessari per l'utente.

L'esempio seguente mostra una policy che consente all'utente di assumere ruoli in un unico account. Inoltre, la policy utilizza un carattere jolly (\$1) per specificare che l'utente può passare a un ruolo solo se il nome del ruolo inizia con le lettere `Test`.

------
#### [ JSON ]

****  

```
{
    "Version":"2012-10-17",		 	 	 
    "Statement": {
        "Effect": "Allow",
        "Action": "sts:AssumeRole",
        "Resource": "arn:aws:iam::111122223333:role/Test*"
    }
}
```

------

**Nota**  
Le autorizzazioni che il ruolo concede all'utente non vengono aggiunte alle autorizzazioni già concesse per l'utente. Quando un utente passa a un ruolo, l'utente rinuncia temporaneamente alle proprie autorizzazioni originali in cambio di quelle concesse dal ruolo. Quando l'utente esce dal ruolo, le autorizzazioni originali dell'utente vengono ripristinate automaticamente. Ad esempio, assumiamo che le autorizzazioni dell'utente permettano di utilizzare le istanze Amazon EC2, ma le policy di autorizzazione del ruolo non concedano tali autorizzazioni. In tal caso, durante l'utilizzo del ruolo, l'utente non potrà utilizzare le istanze Amazon EC2 nella console. Inoltre, le credenziali temporanee ottenute tramite `AssumeRole` non funzioneranno con le istanze Amazon EC2 in modo programmatico.

## Fornire informazioni all'utente
<a name="roles-usingrole-giveuser"></a>

Dopo aver creato un ruolo e concesso all'utente le autorizzazioni per passare a tale ruolo, è necessario fornire all'utente quanto segue:
+ Il nome del ruolo
+ L'ID o l'alias dell'account che contiene il ruolo

Puoi semplificare le operazioni per gli utenti inviando loro un collegamento preconfigurato con l'ID account e il nome del ruolo. Puoi visualizzare il collegamento al ruolo dopo aver completato la procedura guidata **Crea ruolo** selezionando il banner **Visualizza ruolo** o nella pagina **Riepilogo del ruolo** per qualsiasi ruolo abilitato per più account.

È inoltre possibile utilizzare il formato seguente per creare manualmente il collegamento. Sostituisci l'ID account o alias e il nome del ruolo per i due parametri nel seguente esempio:

`https://signin.aws.amazon.com/switchrole?account=your_account_ID_or_alias&roleName=optional_path/role_name`

Consigliamo di suggerire agli utenti di consultare l'argomento [Passare da un utente a un ruolo IAM (console)](id_roles_use_switch-role-console.md) per guidarli nel processo. Per risolvere i problemi più comuni che si possono verificare quando si assume un ruolo, consulta la pagina [Non è possibile assumere un ruolo](troubleshoot_roles.md#troubleshoot_roles_cant-assume-role).

**Considerazioni**
+ Se crei il ruolo in maniera programmatica, puoi crearlo con un percorso e un nome. In tal caso, è necessario fornire il percorso completo e il nome del ruolo agli utenti in modo che possano specificare queste informazioni sulla pagina **Cambia ruolo** della Console di gestione AWS. Ad esempio: `division_abc/subdivision_efg/role_XYZ`.
+ Se crei il ruolo in maniera programmatica, potrai aggiungere un `Path` con un massimo di 512 caratteri e un `RoleName`. Il nome del ruolo può contenere un massimo di 64 caratteri. Tuttavia, per utilizzare un ruolo con la funzione **Switch Role** in Console di gestione AWS, la combinazione `Path` e `RoleName` non può superare i 64 caratteri.
+ Per motivi di sicurezza, puoi [esaminare AWS CloudTrail i log](cloudtrail-integration.md#cloudtrail-integration_signin-tempcreds) per scoprire chi ha eseguito un'azione in AWS. È possibile utilizzare la chiave di condizione `sts:SourceIdentity` nella policy di attendibilità del ruolo per richiedere agli utenti di specificare un'identità quando assumono un ruolo. Ad esempio, è possibile richiedere che gli utenti IAM specifichino il proprio nome utente come identità di origine. In questo modo è possibile determinare quale utente ha eseguito un'operazione specifica in AWS. Per ulteriori informazioni, consulta [`sts:SourceIdentity`](reference_policies_iam-condition-keys.md#ck_sourceidentity). Puoi utilizzare [`sts:RoleSessionName`](reference_policies_iam-condition-keys.md#ck_rolesessionname) anche per richiedere agli utenti di specificare un nome di sessione quando assumono un ruolo. Ciò consente di distinguere tra le sessioni di ruolo quando un ruolo viene utilizzato da principali diversi.

# Concedere a un utente le autorizzazioni per passare un ruolo a un servizio AWS
<a name="id_roles_use_passrole"></a>

Per configurare molti AWS servizi, è necessario *passare* un ruolo IAM al servizio. Ciò consente al servizio di assumere successivamente il ruolo ed eseguire operazioni per tuo conto. Per la maggior parte dei servizi, è sufficiente passare il ruolo al servizio una sola volta durante la configurazione e non ogni volta che il servizio assume il ruolo. Ad esempio, si supponga di disporre di un'applicazione in esecuzione in un'istanza Amazon EC2. Tale applicazione richiede credenziali temporanee per l'autenticazione e autorizzazioni per autorizzare l'applicazione a eseguire operazioni in AWS. Quando configuri l'applicazione, devi passare un ruolo ad Amazon EC2 per l'utilizzo con l'istanza che fornisce tali credenziali. È possibile definire le autorizzazioni per le applicazioni in esecuzione nell'istanza collegando una policy IAM al ruolo. L'applicazione assume il ruolo ogni volta che è necessario per eseguire le operazioni consentite dal ruolo.

Per passare un ruolo (e le relative autorizzazioni) a un AWS servizio, un utente deve disporre delle autorizzazioni per *passare il ruolo* al servizio. Ciò consente agli amministratori di garantire che solo gli utenti autorizzati possano configurare un servizio con un ruolo che concede le autorizzazioni. Per consentire a un utente di passare un ruolo a un AWS servizio, devi concedere l'`PassRole`autorizzazione all'utente, al ruolo o al gruppo IAM dell'utente.

**avvertimento**  
Puoi utilizzare l'`PassRole`autorizzazione solo per passare un ruolo IAM a un servizio che condivide lo stesso AWS account. Per passare un ruolo nell'Account A a un servizio nell'Account B, devi prima creare un ruolo IAM nell'Account B che possa assumere il ruolo dall'Account A, quindi il ruolo nell'Account B può essere passato al servizio. Per informazioni dettagliate, vedi [Accesso alle risorse multi-account in IAM](access_policies-cross-account-resource-access.md).
Non cercare di controllare chi può passare un ruolo assegnando tag al ruolo e utilizzando la chiave di condizione `ResourceTag` in una policy con l'operazione `iam:PassRole`. Questo approccio non produce risultati affidabili.

Quando imposti l'autorizzazione `PassRole`, devi assicurarti che un utente non invii un ruolo dove il ruolo dispone di più autorizzazioni di quelle che desideri che l'utente abbia. Ad esempio, Alice potrebbe non essere autorizzata a eseguire alcune operazioni su Amazon S3. Se Alice potesse trasferire un ruolo a un servizio che consente le azioni di Amazon S3, il servizio potrebbe eseguire azioni Amazon S3 per conto di Alice durante l'esecuzione del processo.

Quando si specifica un ruolo collegato ai servizi, è necessario disporre anche delle autorizzazioni per inoltrare tale ruolo al servizio. Alcuni servizi creano automaticamente un ruolo collegato ai servizi nell'account quando si esegue un'azione in quel servizio. Ad esempio, Amazon EC2 Auto Scaling crea il ruolo collegato ai servizi `AWSServiceRoleForAutoScaling` la prima volta che crei un gruppo Auto Scaling. Se provi a specificare il ruolo collegato ai servizi quando crei un gruppo con scalabilità automatica senza l'autorizzazione `iam:PassRole`, viene visualizzato un messaggio di errore. Se non specifichi esplicitamente il ruolo, l'autorizzazione `iam:PassRole` non è richiesta e l'impostazione predefinita prevede l'utilizzo del ruolo `AWSServiceRoleForAutoScaling` per tutte le operazioni eseguite su quel gruppo. Per scoprire i servizi che supportano i ruoli collegati ai servizi, consulta [AWS servizi che funzionano con IAM](reference_aws-services-that-work-with-iam.md). Per scoprire quali servizi creano automaticamente un ruolo collegato ai servizi quando si esegue un'operazione in quel servizio, selezionare il collegamento **Yes (Sì)** e visualizzare il ruolo collegato ai servizi per il servizio.

Un utente può passare un ruolo ARN come parametro in qualsiasi operazione API che utilizza il ruolo per assegnare le autorizzazioni al servizio. Il servizio quindi verifica se l'utente dispone dell'autorizzazione `iam:PassRole`. Per limitare l'utente a passare solo i ruoli approvati, puoi filtrare l'autorizzazione `iam:PassRole` con l'elemento `Resources` dell'istruzione della policy IAM. 

Puoi utilizzare l'`Condition`elemento in una policy JSON per testare il valore delle chiavi incluse nel contesto di richiesta di tutte le AWS richieste. Per ulteriori informazioni sull'utilizzo delle chiavi di condizione in una policy, consulta [Elementi delle policy JSON IAM: Condition](reference_policies_elements_condition.md). La chiave di condizione `iam:PassedToService` può essere utilizzata per specificare il principale del servizio del servizio a cui è possibile passare un ruolo. Per ulteriori informazioni sull'utilizzo della chiave `iam:PassedToService` condition in una politica, consulta [iam: PassedToService](reference_policies_iam-condition-keys.md#ck_PassedToService).

**Esempio 1**  
Si immagini di voler concedere a un utente la possibilità di trasferire uno qualsiasi dei set di ruoli approvati al servizio Amazon EC2 all'avvio di un'istanza. È necessario disporre di tre elementi:
+ Una *policy di autorizzazioni* IAM collegata al ruolo che determina quali operazioni può compiere il ruolo. Definire l'ambito delle autorizzazioni in modo da includere solo le operazioni che il ruolo deve effettuare e sole le risorse necessarie per tali operazioni. Puoi utilizzare una politica di autorizzazioni IAM AWS gestita o creata dal cliente.

------
#### [ JSON ]

****  

  ```
  {
      "Version":"2012-10-17",		 	 	 
      "Statement": {
          "Effect": "Allow",
          "Action": [ "A list of the permissions the role is allowed to use" ],
          "Resource": [ "A list of the resources the role is allowed to access" ]
      }
  }
  ```

------
+ Una* policy di attendibilità* per il ruolo che consente al servizio di assumere tale ruolo. Ad esempio, è possibile collegare la seguente policy di affidabilità al ruolo con l'operazione `UpdateAssumeRolePolicy`. Questa policy di attendibilità consente ad Amazon EC2 di utilizzare il ruolo e le autorizzazioni associate al ruolo.

------
#### [ JSON ]

****  

  ```
  {
      "Version":"2012-10-17",		 	 	 
      "Statement": {
          "Sid": "TrustPolicyStatementThatAllowsEC2ServiceToAssumeTheAttachedRole",
          "Effect": "Allow",
          "Principal": { "Service": "ec2.amazonaws.com" },
         "Action": "sts:AssumeRole"
      }
  }
  ```

------
+ Una *policy di autorizzazioni* IAM collegata all'utente IAM che consente all'utente di trasferire solo i ruoli approvati. In genere si aggiunge `iam:GetRole` a `iam:PassRole` in modo che l'utente possa ottenere i dettagli del ruolo da passare. In questo esempio, l'utente può passare solo i ruoli esistenti nell'account specificato con nomi che iniziano con `EC2-roles-for-XYZ-`:

------
#### [ JSON ]

****  

  ```
  {
      "Version":"2012-10-17",		 	 	 
      "Statement": [
          {
              "Effect": "Allow",
              "Action": [
                  "iam:GetRole",
                  "iam:PassRole"
              ],
              "Resource": "arn:aws:iam::111122223333:role/EC2-roles-for-XYZ-*"
          }
      ]
  }
  ```

------

Ora l'utente può avviare un'istanza Amazon EC2 con un ruolo assegnato. Le applicazioni in esecuzione nell'istanza possono accedere alle credenziali temporanee per il ruolo tramite i metadati del profilo dell'istanza. Le policy delle autorizzazioni collegate al ruolo determinano cosa può fare l'istanza. 

**Esempio 2**  
Amazon Relational Database Service (Amazon RDS) supporta una funzione chiamata **Monitoraggio avanzato**. Questa funzione consente ad Amazon RDS di monitorare un'istanza di database tramite un agente. Consente inoltre ad Amazon RDS di registrare i parametri su Amazon CloudWatch Logs. Per abilitare questa funzione, è necessario creare un ruolo di servizio per fornire le autorizzazioni Amazon RDS per monitorare e scrivere i parametri per i log. 

**Come creare un ruolo IAM per il monitoraggio avanzato di Amazon RDS**

1. 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. Selezionare **Roles (Ruoli)**, quindi selezionare **Create role (Crea ruolo)**.

1. Scegli il tipo di ruolo di **AWS servizio**, quindi, per **Casi d'uso per altri Servizi AWS**, scegli il servizio **RDS**. Scegli **RDS - Enhanced Monitoring** (RDS - Monitoraggio avanzato), quindi seleziona **Next** (Successivo).

1. Scegli la politica di RDSEnhanced MonitoringRole autorizzazione di **Amazon**.

1. Scegli **Next (Successivo)**.

1. In **Role name** (Nome ruolo), inserisci un nome del ruolo che consenta di identificarne lo scopo. I nomi dei ruoli devono essere univoci all'interno del tuo Account AWS. Quando il nome di un ruolo viene utilizzato in una policy o come parte di un ARN, il nome del ruolo fa distinzione tra maiuscole e minuscole. Quando un nome di ruolo viene visualizzato ai clienti nella console, ad esempio durante la procedura di accesso, il nome del ruolo non fa distinzione tra maiuscole e minuscole. Poiché varie entità possono fare riferimento al ruolo, non puoi modificare il nome del ruolo dopo averlo creato.

1. (Facoltativo) In **Description** (Descrizione), inserisci una descrizione per il nuovo ruolo.

1. (Facoltativo) Aggiungi metadati all'utente collegando i tag come coppie chiave-valore. Per ulteriori informazioni sull'utilizzo dei tag in IAM, consultare [Tag per AWS Identity and Access Management le risorse](id_tags.md).

1. Rivedere il ruolo e scegliere **Crea ruolo**.

Il ruolo ottiene automaticamente una policy di affidabilità che concede le autorizzazioni del servizio `monitoring.rds.amazonaws.com` per assumere il ruolo. Dopo l'avvio, Amazon RDS potrà eseguire tutte le operazioni consentite dalla policy `AmazonRDSEnhancedMonitoringRole`.

L'utente che desideri possa accedere al monitoraggio avanzato necessita di una policy che includa un'istruzione che consenta all'utente di elencare i ruoli RDS e l'istruzione che consente di passare il ruolo, come nell'esempio seguente. Utilizza il tuo numero di account e sostituisci il nome del ruolo con il nome fornito nel passaggio 6.

```
    {
      "Sid": "PolicyStatementToAllowUserToListRoles",
      "Effect": "Allow",
      "Action": ["iam:ListRoles"],
      "Resource": "*"
    },
    {
        "Sid": "PolicyStatementToAllowUserToPassOneSpecificRole",
        "Effect": "Allow",
        "Action": [ "iam:PassRole" ],
        "Resource": "arn:aws:iam::account-id:role/RDS-Monitoring-Role"
    }
```

È possibile combinare questa istruzione con dichiarazioni in un'altra policy o collocarla nella policy personalizzata. Invece, per specificare che l'utente può passare qualsiasi ruolo che inizia con `RDS-`, puoi sostituire il nome del ruolo nella risorsa ARN con un carattere jolly, come nell'esempio seguente.

```
        "Resource": "arn:aws:iam::account-id:role/RDS-*"
```

## `iam:PassRole`azioni nei AWS CloudTrail log
<a name="id_roles_use_passrole_logs"></a>

 `PassRole`non è una chiamata API. `PassRole`è un'autorizzazione, il che significa che non vengono generati CloudTrail log per IAM`PassRole`. Per verificare quali ruoli vengono passati a quali Servizi AWS in CloudTrail, è necessario esaminare il CloudTrail registro che ha creato o modificato la AWS risorsa che riceve il ruolo. Ad esempio, un ruolo viene passato a una AWS Lambda funzione al momento della creazione. Il log per l'operazione `CreateFunction` mostra un record del ruolo passato alla funzione. 

# Revocare le credenziali di sicurezza temporanee per i ruoli IAM
<a name="id_roles_use_revoke-sessions"></a>

**avvertimento**  
Se segui i passaggi in questa pagina, a tutti gli utenti con sessioni correnti create assumendo il ruolo viene negato l'accesso a tutte le AWS azioni e le risorse. Questo può causare la perdita di dati non salvati da parte degli utenti.

Quando consenti agli utenti di accedere a sessioni Console di gestione AWS con una durata di sessione lunga (ad esempio 12 ore), le loro credenziali temporanee non scadono così rapidamente. Se gli utenti espongono inavvertitamente le proprie credenziali a una terza parte non autorizzata, tale parte ha accesso per la durata della sessione. Tuttavia, è possibile revocare immediatamente tutte le autorizzazioni per le credenziali del ruolo rilasciate prima di un certo periodo di tempo, se necessario. Tutte le credenziali temporanee per quel ruolo emesse prima del momento specificata diventano non valide. Questo costringe tutti gli utenti a ripetere l'autenticazione e a richiedere nuove credenziali.

 

**Nota**  
Non è possibile revocare la sessione per un *[ruolo collegato ai servizi](id_roles.md#iam-term-service-linked-role)*.

Quando si revocano le autorizzazioni per un ruolo utilizzando la procedura AWS riportata in questo argomento, al ruolo viene associata una nuova politica in linea che nega tutte le autorizzazioni a tutte le azioni. Include una condizione che applica le restrizioni solo se l'utente ha assunto il ruolo *prima* del momento in cui sono state revocate le autorizzazioni. Se l'utente assume il ruolo *dopo* la revoca delle autorizzazioni, la policy di rifiuto non si applica a quell'utente.

Per ulteriori informazioni sulla negazione dell'accesso, consulta [Disabilitazione delle autorizzazioni per le credenziali di sicurezza temporanee](id_credentials_temp_control-access_disable-perms.md).

**Importante**  
La policy di rifiuto si applica a tutti gli utenti con il ruolo specificato, non solo a quelli con sessioni della console di durata più lunga.

## Autorizzazioni minime per revocare le autorizzazioni di sessione da un ruolo
<a name="revoke-session-permissions"></a>

Per revocare le autorizzazioni di sessione da un ruolo, è necessario disporre dell'autorizzazione `PutRolePolicy` per il ruolo. In questo modo è possibile collegare la policy inline `AWSRevokeOlderSessions` al ruolo.

## Revoca delle autorizzazioni di sessione
<a name="revoke-session"></a>

Puoi revocare le autorizzazioni della sessione da un ruolo per negare tutte le autorizzazioni a tutti gli utenti che hanno assunto il ruolo.

**Nota**  
Non è possibile modificare i ruoli in IAM creati dai set di autorizzazioni del Centro identità IAM. È necessario revocare la sessione attiva del set di autorizzazioni per un utente nel Centro identità IAM. Per ulteriori informazioni, consulta [Revocare le sessioni attive di un ruolo IAM create dai set di autorizzazioni](https://docs.aws.amazon.com/singlesignon/latest/userguide/useraccess.html#revoke-user-permissions) nella *Guida per l'utente del Centro identità IAM*.

**Per rifiutare immediatamente tutte le autorizzazioni a qualsiasi utente corrente con credenziali del ruolo**

1. 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. Nel pannello di navigazione scegli **Ruoli**, quindi seleziona il nome (non la casella di controllo) del ruolo per cui desideri revocare le autorizzazioni.

1. Nella pagina **Summary (Riepilogo)** per il ruolo selezionato, selezionare la scheda **Revoke sessions (Revoca sessioni)**.

1. Nelle scheda **Revoke sessions (Revoca sessioni)** selezionare **Revoke active sessions (Revoca sessioni attive)**.

1. AWS ti chiede di confermare l'azione. Seleziona la casella di controllo **Riconosco che sto revocando tutte le sessioni attive per questo ruolo.** e scegli **Revoca le sessioni attive** nella finestra di dialogo.

   IAM quindi collega al ruolo una policy denominata `AWSRevokeOlderSessions`. Dopo aver scelto **Revoca sessioni attive**, la policy rifiuta l'accesso a tutti gli utenti che hanno assunto il ruolo in passato e per circa 30 secondi nel futuro. Questa scelta temporale futura tiene conto del ritardo di propagazione della policy per gestire una nuova sessione acquisita o rinnovata prima che la policy aggiornata entrasse in vigore in una determinata regione. Gli utenti che assumono il ruolo più di 30 secondi dopo aver selezionato Revoca sessioni attive non saranno interessati. Per scoprire perché le modifiche non sono sempre immediatamente visibili, consulta [Le modifiche che apporto non sono sempre immediatamente visibili](troubleshoot.md#troubleshoot_general_eventual-consistency). 

**Nota**  
Se scegli nuovamente **Revoca sessioni** in un secondo momento, l'indicatore di data e timestamp della policy viene aggiornato e nega nuovamente tutte le autorizzazioni a qualsiasi utente che ha assunto il ruolo prima della nuova ora specificata.

Gli utenti validi le cui sessioni sono revocate in questo modo devono acquisire credenziali provvisorie per una nuova sessione per continuare a lavorare. Le credenziali vengono memorizzate nella AWS CLI cache fino alla loro scadenza. Per forzare la CLI a eliminare e aggiornare le credenziali memorizzate nella cache che non sono più valide, eseguire uno dei seguenti comandi:

**Linux, macOS o Unix**

```
$ rm -r ~/.aws/cli/cache
```

**Windows**

```
C:\> del /s /q %UserProfile%\.aws\cli\cache
```

## Revoca delle autorizzazioni di sessione prima di un orario specificato
<a name="revoke-session-policy"></a>

 Puoi anche revocare le autorizzazioni di sessione in qualsiasi momento a tua scelta utilizzando AWS CLI o l'SDK per specificare un valore per la `aws:TokenIssueTime` chiave nell'elemento Condition di una politica. 

Questa policy nega tutte le autorizzazioni, quando il valore di `aws:TokenIssueTime` è precedente alla data e ora specificate. Il valore di `aws:TokenIssueTime` corrisponde al momento in cui sono state create le credenziali di sicurezza provvisorie. Il `aws:TokenIssueTime` valore è presente solo nel contesto delle AWS richieste firmate con credenziali di sicurezza temporanee, pertanto l'istruzione Deny nella policy non influisce sulle richieste firmate con le credenziali a lungo termine dell'utente IAM.

Questa policy può essere collegata a un ruolo. In questo caso, la policy influisce solo sulle credenziali di sicurezza provvisorie create da tale ruolo prima della data e ora specificate.

------
#### [ JSON ]

****  

```
{
  "Version":"2012-10-17",		 	 	 
  "Statement": {
    "Effect": "Deny",
    "Action": "*",
    "Resource": "*",
    "Condition": {
      "DateLessThan": {"aws:TokenIssueTime": "2014-05-07T23:47:00Z"}
    }
  }
}
```

------

Gli utenti validi le cui sessioni sono revocate in questo modo devono acquisire credenziali provvisorie per una nuova sessione per continuare a lavorare. Le credenziali vengono memorizzate AWS CLI nella cache fino alla loro scadenza. Per forzare la CLI a eliminare e aggiornare le credenziali memorizzate nella cache che non sono più valide, eseguire uno dei seguenti comandi:

**Linux, macOS o Unix**

```
$ rm -r ~/.aws/cli/cache
```

**Windows**

```
C:\> del /s /q %UserProfile%\.aws\cli\cache
```

# Aggiornamento di un ruolo collegato ai servizi
<a name="id_roles_update-service-linked-role"></a>

Il metodo utilizzato per modificare un ruolo collegato ai servizi dipende dal servizio. Alcuni servizi consentono di modificare le autorizzazioni per un ruolo collegato ai servizi dalla console di servizio, dalle API o dalla CLI. Tuttavia, dopo aver creato un ruolo collegato ai servizi, non è possibile modificare il nome del ruolo poiché varie entità possono farvi riferimento. Puoi modificare la descrizione di qualsiasi ruolo dalla console IAM, dall'API o dalla CLI.

Per informazioni su quali servizi supportano i ruoli collegati ai servizi, consulta la pagina [AWS servizi che funzionano con IAM](reference_aws-services-that-work-with-iam.md) e cerca i servizi per cui è indicato **Sì **nella colonna **Ruolo collegato ai servizi**. Per scoprire se il servizio supporta la modifica del ruolo collegato ai servizi, selezionare il link **Sì** per visualizzare il ruolo collegato ai servizi per quel servizio.

## Modifica della descrizione di un ruolo collegato ai servizi (console)
<a name="edit-service-linked-role-iam-console"></a>

Puoi utilizzare la console IAM per modificare la descrizione di un ruolo collegato ai servizi.

**Per modificare la descrizione di un ruolo collegato ai servizi (console)**

1. Nel pannello di navigazione della console IAM seleziona **Roles (Ruoli)**.

1. Scegliere il nome del ruolo da modificare.

1. Nella parte destra di **Role description** (Descrizione ruolo), scegliere **Edit** (Modifica). 

1. Digita una nuova descrizione nella casella e scegli **Save (Salva)**.

## Modifica della descrizione di un ruolo collegato ai servizi (AWS CLI)
<a name="edit-service-linked-role-iam-cli"></a>

Puoi utilizzare i comandi IAM di AWS CLI per modificare la descrizione di un ruolo collegato al servizio.

**Per modificare la descrizione di un ruolo collegato ai servizi (AWS CLI)**

1. (Facoltativo) Per visualizzare la descrizione attuale di un ruolo, utilizza i seguenti comandi:

   ```
   aws iam [get-role](https://docs.aws.amazon.com/cli/latest/reference/iam/get-role.html) --role-name ROLE-NAME
   ```

   Per fare riferimento ai ruoli con i comandi della CLI utilizza il nome del ruolo, non l'ARN. Ad esempio, per fare riferimento a un ruolo il cui ARN è `arn:aws:iam::123456789012:role/myrole`, puoi usare **myrole**.

1. Per aggiornare la descrizione di un ruolo collegato ai servizi, utilizza il seguente comando:

   ```
   aws iam [update-role](https://docs.aws.amazon.com/cli/latest/reference/iam/update-role.html) --role-name ROLE-NAME --description OPTIONAL-DESCRIPTION
   ```

## Modifica di una descrizione di ruolo (API) collegata al servizio AWS
<a name="edit-service-linked-role-iam-api"></a>

È possibile utilizzare l' AWS API per modificare la descrizione di un ruolo collegato al servizio.

**Per modificare la descrizione di un ruolo collegato al servizio (API)AWS**

1. (Facoltativo) Per visualizzare l'attuale descrizione per un ruolo, effettua una chiamata all'operazione seguente e specifica il nome del ruolo:

   AWS API: [GetRole](https://docs.aws.amazon.com/IAM/latest/APIReference/API_GetRole.html) 

1. Per aggiornare la descrizione di un ruolo, effettua una chiamata all'operazione seguente e specifica il nome (e facoltativamente la descrizione) del ruolo: 

   AWS API: [UpdateRole](https://docs.aws.amazon.com/IAM/latest/APIReference/API_UpdateRole.html) 

# Aggiornamento di una policy di attendibilità del ruolo
<a name="id_roles_update-role-trust-policy"></a>

Per cambiare l'utente che può assumere un ruolo, modifica la policy di affidabilità del ruolo. Non puoi modificare la policy di attendibilità per un *[ruolo collegato al servizio](id_roles.md#iam-term-service-linked-role)*.

**Note**  
Se un utente viene elencato come principale in una policy di attendibilità del ruolo ma non può assumere il ruolo, controlla il [limite delle autorizzazioni](access_policies_boundaries.md) dell'utente. Se è impostato un limite delle autorizzazioni per l'utente, questo deve consentire l'operazione `sts:AssumeRole`.
Per consentire agli utenti di assumere nuovamente il ruolo corrente all'interno di una sessione di ruolo, specificare il ruolo ARN o Account AWS ARN come principale nella politica di attendibilità dei ruoli. Servizi AWS che forniscono risorse di elaborazione come Amazon EC2, Amazon ECS, Amazon EKS e Lambda forniscono credenziali temporanee e aggiornano automaticamente tali credenziali. Ciò garantisce di disporre sempre di un set di credenziali valido. Per questi servizi, non è necessario riassumere il ruolo attuale per ottenere credenziali temporanee. Tuttavia, se intendi passare [tag di sessione](id_session-tags.md) o una [Policy di sessione](access_policies.md#policies_session), devi riassumere il ruolo attuale.


## Aggiornamento di una policy di attendibilità del ruolo (console)
<a name="id_roles_update-trust-policy-console"></a>

**Per modificare una politica di fiducia nei ruoli in Console di gestione AWS**

1. 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. Nel pannello di navigazione della console IAM seleziona **Ruoli**.

1. Nell'elenco di ruoli dell'account selezionare il nome del ruolo da modificare.

1. Scegli la scheda **Relazioni di attendibilità** e quindi **Modifica policy di attendibilità**.

1. Modificare la policy di affidabilità in base alle esigenze. Per aggiungere ulteriori entità principali che possono assumere il ruolo, specificarle nell'elemento `Principal`. Ad esempio, il seguente frammento di policy mostra come fare riferimento a due Account AWS nell'`Principal`elemento:

   ```
   "Principal": {
     "AWS": [
       "arn:aws:iam::111122223333:root",
       "arn:aws:iam::444455556666:root"
     ]
   },
   ```

   Se specifichi un'entità principale in un altro account, l'aggiunta di un account alla policy di attendibilità di un ruolo è solo una parte della creazione della relazione di trust tra più account. Per impostazione predefinita, gli utenti negli account attendibili non possono assumere il ruolo. L'amministratore del nuovo account attendibile deve concedere agli utenti l'autorizzazione ad assumere il ruolo. A tale scopo, l'amministratore deve creare o modificare una policy collegata all'utente per consentire all'utente di accedere all'operazione `sts:AssumeRole`. Per ulteriori informazioni, consultare la procedura seguente o [Concedere le autorizzazioni agli utenti per cambiare ruoli](id_roles_use_permissions-to-switch.md).

   Il seguente frammento di policy mostra come fare riferimento a due AWS servizi nell'elemento: `Principal`

   ```
   "Principal": {
     "Service": [
       "opsworks.amazonaws.com",
       "ec2.amazonaws.com"
     ]
   },
   ```

1. Una volta completata la modifica della policy di attendibilità, scegli **Update policy** (Aggiorna policy) per salvare le modifiche.

   Per ulteriori informazioni sulla sintassi e sulla struttura della policy, consultare [Politiche e autorizzazioni in AWS Identity and Access Management](access_policies.md) e [Documentazione di riferimento degli elementi delle policy JSON IAM](reference_policies_elements.md).

**Per permettere agli utenti in un account esterno attendibile di usare il ruolo (console)**

Per ulteriori informazioni e dettagli su questa procedura, consultare [Concedere le autorizzazioni agli utenti per cambiare ruoli](id_roles_use_permissions-to-switch.md).

1. Accedi a un sito esterno affidabile. Account AWS

1. Stabilire se collegare le autorizzazioni a un utente o a un gruppo. Nel riquadro di navigazione della console IAM, scegli **Users** (Utenti) o **User groups** (Gruppi di utenti) in base alle esigenze.

1. Scegliere il nome dell'utente o del gruppo a cui si desidera concedere l'accesso e selezionare la scheda **Permissions (Autorizzazioni)**.

1. Esegui una delle seguenti operazioni:
   + Per modificare una policy gestita dal cliente, selezionare il nome della policy, **Edit policy (Modifica policy)** e la scheda **JSON**. Non è possibile modificare una politica AWS gestita. AWS le politiche gestite vengono visualizzate con l' AWS icona (![\[Orange cube icon indicating a policy is managed by AWS.\]](http://docs.aws.amazon.com/it_it/IAM/latest/UserGuide/images/policy_icon.png)). Per ulteriori informazioni sulle differenze tra le policy gestite da AWS e quelle gestite dal cliente, consultare [Policy gestite e policy inline](access_policies_managed-vs-inline.md).
   + Per modificare una policy inline, selezionare la freccia accanto al nome della policy e scegliere **Edit policy (Modifica policy)**.

1. Nell'editor di policy aggiungere un nuovo elemento `Statement` che specifica quanto segue:

   ```
   {
     "Effect": "Allow",
     "Action": "sts:AssumeRole",
     "Resource": "arn:aws:iam::ACCOUNT-ID:role/ROLE-NAME"
   }
   ```

   Sostituire l'ARN nell'istruzione con l'ARN del ruolo che l'utente può assumere.

1. Seguire le indicazioni sullo schermo per completare la modifica della policy. 

## Aggiornamento di una policy di attendibilità del ruolo (AWS CLI)
<a name="id_roles-update-trust-policy-cli"></a>

È possibile utilizzare il AWS CLI per modificare chi può assumere un ruolo.

**Per modificare una policy di attendibilità del ruolo (AWS CLI)**

1. (Facoltativo) Se non si conosce il nome del ruolo da modificare, eseguire il comando seguente per elencare i ruoli nell'account:
   + [aws iam list-roles](https://docs.aws.amazon.com/cli/latest/reference/iam/list-roles.html)

1. (Facoltativo) Per visualizzare la policy di affidabilità corrente per un ruolo, eseguire il comando seguente:
   + [aws iam get-role](https://docs.aws.amazon.com/cli/latest/reference/iam/get-role.html)

1. Per modificare le entità principali attendibili che possono accedere al ruolo, creare un file di testo con la policy di affidabilità aggiornata. È possibile usare qualsiasi editor di testo per creare la policy.

   Ad esempio, la policy di attendibilità seguente illustra come fare riferimento a due Account AWS nell'elemento `Principal`. Ciò consente agli utenti di due persone separate Account AWS di assumere questo ruolo.

------
#### [ JSON ]

****  

   ```
   {
       "Version":"2012-10-17",		 	 	 
       "Statement": {
           "Effect": "Allow",
           "Principal": {"AWS": [
               "arn:aws:iam::111122223333:root",
               "arn:aws:iam::444455556666:root"
           ]},
           "Action": "sts:AssumeRole"
       }
   }
   ```

------

   Se specifichi un'entità principale in un altro account, l'aggiunta di un account alla policy di attendibilità di un ruolo è solo una parte della creazione della relazione di trust tra più account. Per impostazione predefinita, gli utenti negli account attendibili non possono assumere il ruolo. L'amministratore del nuovo account attendibile deve concedere agli utenti l'autorizzazione ad assumere il ruolo. A tale scopo, l'amministratore deve creare o modificare una policy collegata all'utente per consentire all'utente di accedere all'operazione `sts:AssumeRole`. Per ulteriori informazioni, consultare la procedura seguente o [Concedere le autorizzazioni agli utenti per cambiare ruoli](id_roles_use_permissions-to-switch.md).

1. Per utilizzare il file creato per aggiornare la policy di attendibilità, eseguire il comando seguente:
   + [era io update-assume-role-policy](https://docs.aws.amazon.com/cli/latest/reference/iam/update-assume-role-policy.html)

**Per permettere agli utenti in un account esterno attendibile di usare il ruolo (AWS CLI)**

Per ulteriori informazioni e dettagli su questa procedura, consultare [Concedere le autorizzazioni agli utenti per cambiare ruoli](id_roles_use_permissions-to-switch.md).

1. Creare un file JSON contenente una policy di autorizzazione che concede le autorizzazioni ad assumere il ruolo. La policy seguente contiene ad esempio le autorizzazioni minime necessarie:

------
#### [ JSON ]

****  

   ```
   {
       "Version":"2012-10-17",		 	 	 
       "Statement": {
           "Effect": "Allow",
           "Action": "sts:AssumeRole",
           "Resource": "arn:aws:iam::111122223333:role/ROLE-NAME"
       }
   }
   ```

------

   Sostituire l'ARN nell'istruzione con l'ARN del ruolo che l'utente può assumere.

1. Esegui il comando seguente per caricare il file JSON contenente la policy di attendibilità in IAM:
   + [aws iam create-policy](https://docs.aws.amazon.com/cli/latest/reference/iam/create-policy.html)

   L'output di questo comando include l'ARN della policy. Prendere nota di questo ARN, perché sarà necessario in una fase successiva. 

1. Stabilire a quale utente o gruppo collegare la policy. Se non si conosce il nome dell'utente o del gruppo desiderato, usare uno dei comandi seguenti per elencare gli utenti o i gruppi nell'account:
   + [aws iam list-users](https://docs.aws.amazon.com/cli/latest/reference/iam/list-users.html)
   + [aws iam list-groups](https://docs.aws.amazon.com/cli/latest/reference/iam/list-groups.html)

1. Usare uno dei comandi seguenti per collegare la policy creata nel passaggio precedente all'utente o al gruppo:
   + [era io attach-user-policy](https://docs.aws.amazon.com/cli/latest/reference/iam/attach-user-policy.html)
   + [era io attach-group-policy](https://docs.aws.amazon.com/cli/latest/reference/iam/attach-group-policy.html)

## Aggiornamento di una policy di fiducia dei ruoli (AWS API)
<a name="id_roles-update-trust-policy-api"></a>

Puoi utilizzare l' AWS API per modificare chi può assumere un ruolo.

**Per modificare una politica di fiducia (AWS API) del ruolo**

1. (Facoltativo) Se non si conosce il nome del ruolo che si desidera modificare, chiamare l'operazione seguente per elencare i ruoli nell'account:
   + [ListRoles](https://docs.aws.amazon.com/IAM/latest/APIReference/API_ListRoles.html)

1. (Facoltativo) Per visualizzare la policy di affidabilità corrente per un ruolo, chiamare l'operazione seguente:
   + [GetRole](https://docs.aws.amazon.com/IAM/latest/APIReference/API_GetRole.html)

1. Per modificare le entità principali attendibili che possono accedere al ruolo, creare un file di testo con la policy di affidabilità aggiornata. È possibile usare qualsiasi editor di testo per creare la policy.

   Ad esempio, la policy di attendibilità seguente illustra come fare riferimento a due Account AWS nell'elemento `Principal`. Ciò consente agli utenti di due persone separate Account AWS di assumere questo ruolo.

------
#### [ JSON ]

****  

   ```
   {
       "Version":"2012-10-17",		 	 	 
       "Statement": {
           "Effect": "Allow",
           "Principal": {"AWS": [
               "arn:aws:iam::111122223333:root",
               "arn:aws:iam::444455556666:root"
           ]},
           "Action": "sts:AssumeRole"
       }
   }
   ```

------

   Se specifichi un'entità principale in un altro account, l'aggiunta di un account alla policy di attendibilità di un ruolo è solo una parte della creazione della relazione di trust tra più account. Per impostazione predefinita, gli utenti negli account attendibili non possono assumere il ruolo. L'amministratore del nuovo account attendibile deve concedere agli utenti l'autorizzazione ad assumere il ruolo. A tale scopo, l'amministratore deve creare o modificare una policy collegata all'utente per consentire all'utente di accedere all'operazione `sts:AssumeRole`. Per ulteriori informazioni, consultare la procedura seguente o [Concedere le autorizzazioni agli utenti per cambiare ruoli](id_roles_use_permissions-to-switch.md).

1. Per utilizzare il file creato per aggiornare la policy di attendibilità, chiamare l'operazione seguente:
   + [UpdateAssumeRolePolicy](https://docs.aws.amazon.com/IAM/latest/APIReference/API_UpdateAssumeRolePolicy.html)

**Per consentire agli utenti di un account esterno affidabile di utilizzare il ruolo (AWS API)**

Per ulteriori informazioni e dettagli su questa procedura, consultare [Concedere le autorizzazioni agli utenti per cambiare ruoli](id_roles_use_permissions-to-switch.md).

1. Creare un file JSON contenente una policy di autorizzazione che concede le autorizzazioni ad assumere il ruolo. La policy seguente contiene ad esempio le autorizzazioni minime necessarie:

------
#### [ JSON ]

****  

   ```
   {
       "Version":"2012-10-17",		 	 	 
       "Statement": {
           "Effect": "Allow",
           "Action": "sts:AssumeRole",
           "Resource": "arn:aws:iam::111122223333:role/ROLE-NAME"
       }
   }
   ```

------

   Sostituire l'ARN nell'istruzione con l'ARN del ruolo che l'utente può assumere.

1. Chiama l'operazione seguente per caricare il file JSON contenente la policy di attendibilità in IAM:
   + [CreatePolicy](https://docs.aws.amazon.com/IAM/latest/APIReference/API_CreatePolicy.html)

   L'output di questa operazione include l'ARN della policy. Prendere nota di questo ARN, perché sarà necessario in una fase successiva. 

1. Stabilire a quale utente o gruppo collegare la policy. Se non si conosce il nome dell'utente o del gruppo desiderato, chiamare una delle operazioni seguenti per elencare gli utenti o i gruppi nell'account:
   + [ListUsers](https://docs.aws.amazon.com/IAM/latest/APIReference/API_ListUsers.html)
   + [ListGroups](https://docs.aws.amazon.com/IAM/latest/APIReference/API_ListGroups.html)

1. Chiamare una delle operazioni seguenti per collegare la policy creata nel passaggio precedente all'utente o al gruppo:
   +  API: [AttachUserPolicy](https://docs.aws.amazon.com/IAM/latest/APIReference/API_AttachUserPolicy.html)
   + [AttachGroupPolicy](https://docs.aws.amazon.com/IAM/latest/APIReference/API_AttachGroupPolicy.html)

# Aggiornamento delle autorizzazioni per un ruolo
<a name="id_roles_update-role-permissions"></a>

Utilizza le seguenti procedure per aggiornare le policy e i limiti delle autorizzazioni di un ruolo.

## Prerequisito: Visualizzazione dell'accesso per il ruolo
<a name="roles-modify_prerequisites"></a>

Prima di modificare le autorizzazioni per un ruolo, è opportuno esaminare la sua attività recente a livello di servizio. È un'opzione importante per non rimuovere l'accesso da parte di un principale (persona o applicazione) che la sta utilizzando. Per ulteriori informazioni sulla visualizzazione delle ultime informazioni di accesso, vedere [Perfeziona le autorizzazioni AWS utilizzando le informazioni dell'ultimo accesso](access_policies_last-accessed.md).

## Aggiornamento di una policy delle autorizzazioni per un ruolo
<a name="id_roles_update-role-permissions-policy"></a>

Per modificare le autorizzazioni permesse dal ruolo, modifica la policy (o le policy) di autorizzazioni del ruolo. Non è possibile modificare la policy di autorizzazione per un *[ruolo collegato ai servizi](id_roles.md#iam-term-service-linked-role)* in IAM. Potresti essere in grado di modificare la policy di autorizzazione all'interno del servizio che dipende dal ruolo. Per controllare se un servizio supporta questa funzionalità, consulta [AWS servizi che funzionano con IAM](reference_aws-services-that-work-with-iam.md) e individua i servizi che hanno **Sì **nella colonna **Ruoli collegati ai servizi**. Scegliere **Sì** in corrispondenza di un link per visualizzare la documentazione relativa al ruolo collegato al servizio per tale servizio.

### Aggiornamento di una policy delle autorizzazioni del ruolo (console)
<a name="id_roles_update-role-permissions-policy-console"></a>

**Per modificare le autorizzazioni permesse da un ruolo (console)**

1. Aprire la console IAM all'indirizzo [https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/).

1. Nel pannello di navigazione della console IAM seleziona **Ruoli**.

1. Selezionare il nome del ruolo da modificare e la scheda **Permissions (Autorizzazioni)**.

1. Esegui una delle seguenti operazioni:
   + Per modificare una policy gestita dal cliente esistente, selezionare il nome della policy e scegliere **Edit policy (Modifica policy)**.
**Nota**  
Non è possibile modificare una politica AWS gestita. AWS le politiche gestite vengono visualizzate con l' AWS icona (![\[Orange cube icon indicating a policy is managed by AWS.\]](http://docs.aws.amazon.com/it_it/IAM/latest/UserGuide/images/policy_icon.png)). Per ulteriori informazioni sulla differenza tra politiche AWS gestite e politiche gestite dal cliente, vedere[Policy gestite e policy inline](access_policies_managed-vs-inline.md). 
   + Per collegare una policy gestita esistente al ruolo, scegli **Add permissions** (Aggiungi autorizzazioni) e quindi **Attach policies** (Collega policy).
   + Per modificare una policy inline esistente, espandi la policy e scegli **Edit** (Modifica).
   + Per integrare una nuova policy inline, scegli **Add permissions** (Aggiungi autorizzazioni), quindi **Create inline policy** (Crea policy inline). 
   + Per rimuovere una policy esistente dal ruolo, seleziona la casella di controllo accanto al nome della policy, quindi scegli **Rimuovi**.

### Aggiornamento di una policy di autorizzazione del ruolo (AWS CLI)
<a name="id_roles_update_permissions-policy-cli"></a>

Per modificare le autorizzazioni permesse dal ruolo, modifica la policy (o le policy) di autorizzazioni del ruolo. Non è possibile modificare la policy di autorizzazione per un *[ruolo collegato ai servizi](id_roles.md#iam-term-service-linked-role)* in IAM. Potresti essere in grado di modificare la policy di autorizzazione all'interno del servizio che dipende dal ruolo. Per controllare se un servizio supporta questa funzionalità, consulta [AWS servizi che funzionano con IAM](reference_aws-services-that-work-with-iam.md) e individua i servizi che hanno **Sì **nella colonna **Ruoli collegati ai servizi**. Scegliere **Sì** in corrispondenza di un link per visualizzare la documentazione relativa al ruolo collegato al servizio per tale servizio.

**Per modificare le autorizzazioni permesse da un ruolo (AWS CLI)**

1. (Facoltativo) Per visualizzare le autorizzazioni correnti associate a un ruolo, eseguire i comandi seguenti:

   1. [Lo scopo è quello list-role-policies](https://docs.aws.amazon.com/cli/latest/reference/iam/list-role-policies.html) di elencare le politiche in linea

   1. [aws mira list-attached-role-policies](https://docs.aws.amazon.com/cli/latest/reference/iam/list-attached-role-policies.html) a elencare le politiche gestite

1. Il comando per aggiornare le autorizzazioni per il ruolo varia a seconda del fatto che si aggiorni una policy gestita o una policy inline.

   Per aggiornare una policy gestita, eseguire il comando seguente per creare una nuova versione della policy gestita:
   + [era io create-policy-version](https://docs.aws.amazon.com/cli/latest/reference/iam/create-policy-version.html)

   Per aggiornare una policy inline, eseguire il comando seguente:
   + [era io put-role-policy](https://docs.aws.amazon.com/cli/latest/reference/iam/put-role-policy.html)

### Aggiornamento di una politica di autorizzazione dei ruoli (AWS API)
<a name="id_roles_update_permissions-policy-api"></a>

Per modificare le autorizzazioni permesse dal ruolo, modifica la policy (o le policy) di autorizzazioni del ruolo. Non è possibile modificare la policy di autorizzazione per un *[ruolo collegato ai servizi](id_roles.md#iam-term-service-linked-role)* in IAM. Potresti essere in grado di modificare la policy di autorizzazione all'interno del servizio che dipende dal ruolo. Per controllare se un servizio supporta questa funzionalità, consulta [AWS servizi che funzionano con IAM](reference_aws-services-that-work-with-iam.md) e individua i servizi che hanno **Sì **nella colonna **Ruoli collegati ai servizi**. Scegliere **Sì** in corrispondenza di un link per visualizzare la documentazione relativa al ruolo collegato al servizio per tale servizio.

**Per modificare le autorizzazioni consentite da un ruolo (API)AWS**

1. (Facoltativo) Per visualizzare le autorizzazioni correnti associate a un ruolo, chiamare le operazioni seguenti:

   1. [ListRolePolicies](https://docs.aws.amazon.com/IAM/latest/APIReference/API_ListRolePolicies.html)per elencare le politiche in linea

   1. [ListAttachedRolePolicies](https://docs.aws.amazon.com/IAM/latest/APIReference/API_ListAttachedRolePolicies.html)per elencare le politiche gestite

1. L'operazione per aggiornare le autorizzazioni per il ruolo varia a seconda del fatto che si aggiorni una policy gestita o una policy inline.

   Per aggiornare una policy gestita, chiamare l'operazione seguente per creare una nuova versione della policy gestita:
   + [CreatePolicyVersion](https://docs.aws.amazon.com/IAM/latest/APIReference/API_CreatePolicyVersion.html)

   Per aggiornare una policy inline, chiamare l'operazione seguente:
   + [PutRolePolicy](https://docs.aws.amazon.com/IAM/latest/APIReference/API_PutRolePolicy.html)

## Aggiornamento del limite delle autorizzazioni per un ruolo
<a name="id_roles_update-role-permissions-boundary"></a>

Per modificare il numero massimo di autorizzazioni consentite per un ruolo, modifica il [limite delle autorizzazioni](access_policies_boundaries.md) del ruolo.

### Aggiornamento di un limite delle autorizzazioni del ruolo (console)
<a name="id_roles_update-permissions-boundary-console"></a>

**Per modificare la policy utilizzata per impostare il limite delle autorizzazioni per un ruolo**

1. 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. Nel riquadro di navigazione, seleziona **Ruoli**.

1. Scegli il nome del ruolo con il [limite delle autorizzazioni](access_policies_boundaries.md) che desideri modificare. 

1. Scegli la scheda **Autorizzazioni**. Se necessario, aprire la sezione **Permissions boundary (Limite delle autorizzazioni)** e selezionare **Change boundary (Modifica limite)**.

1. Selezionare la policy da utilizzare per il limite delle autorizzazioni.

1. Selezionare **Change boundary (Modifica limite)**.

   Le modifiche non verranno applicate fino alla volta successiva in cui qualcuno assume questo ruolo.

### Aggiornamento di un limite delle autorizzazioni del ruolo (AWS CLI)
<a name="id_roles_update_permissions-boundary-cli"></a>

**Per modificare la policy gestita utilizzata per impostare il limite delle autorizzazioni per un ruolo (AWS CLI)**

1. (Facoltativo) Per visualizzare il [limite delle autorizzazioni](access_policies_boundaries.md) corrente per un ruolo, eseguire il comando seguente: 
   + [aws iam get-role](https://docs.aws.amazon.com/cli/latest/reference/iam/get-role.html)

1. Per usare un'altra policy gestita per aggiornare il limite delle autorizzazioni per un ruolo, eseguire il comando seguente: 
   + [era iam put-role-permissions-boundary](https://docs.aws.amazon.com/cli/latest/reference/iam/put-role-permissions-boundary.html)

   Un ruolo può avere solo una policy gestita impostata come limite delle autorizzazioni. Modificando il limite delle autorizzazioni è possibile modificare il numero massimo di autorizzazioni consentite per un ruolo.

### Aggiornamento di un limite di autorizzazioni di ruolo (API)AWS
<a name="id_roles_update-permissions-boundary-api"></a>

**Per modificare la politica gestita utilizzata per impostare il limite delle autorizzazioni per un ruolo (API)AWS**

1. (Facoltativo) Per visualizzare il [limite delle autorizzazioni](access_policies_boundaries.md) corrente per un ruolo, richiamare l'operazione seguente: 
   + [GetRole](https://docs.aws.amazon.com/IAM/latest/APIReference/API_GetRole.html)

1. Per usare un'altra policy gestita per aggiornare il limite delle autorizzazioni per un ruolo, chiamare l'operazione seguente: 
   + [PutRolePermissionsBoundary](https://docs.aws.amazon.com/IAM/latest/APIReference/API_PutRolePermissionsBoundary.html)

   Un ruolo può avere solo una policy gestita impostata come limite delle autorizzazioni. Modificando il limite delle autorizzazioni è possibile modificare il numero massimo di autorizzazioni consentite per un ruolo.

# Aggiornamento delle impostazioni per un ruolo
<a name="id_roles_update-role-settings"></a>

Utilizza le seguenti procedure per aggiornare la descrizione di un ruolo o modificare la durata massima della sessione per un ruolo.

## Aggiornamento della descrizione di un ruolo
<a name="id_roles_update-description"></a>

Per cambiare la descrizione del ruolo, modifica il testo di descrizione.

### Aggiornamento della descrizione di un ruolo (console)
<a name="id_roles_update-description-console"></a>

**Per modificare la descrizione di un ruolo (console)**

1. 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. Nel pannello di navigazione della console IAM seleziona **Roles (Ruoli)**.

1. Scegliere il nome del ruolo da modificare.

1. Nella sezione **Summary** (Riepilogo), scegli **Edit** (Modifica).

1. Digita una nuova descrizione nella casella e scegli **Save changes (Salva modifiche)**.

### Aggiornamento della descrizione di un ruolo (AWS CLI)
<a name="id_roles_update-description-cli"></a>

**Per modificare la descrizione di un ruolo (AWS CLI)**

1. (Facoltativo) Per visualizzare la descrizione corrente di un ruolo, eseguire il comando seguente:
   + [aws iam get-role](https://docs.aws.amazon.com/cli/latest/reference/iam/get-role.html)

1. Per aggiornare la descrizione di un ruolo, eseguire il comando seguente con il parametro relativo alla descrizione:
   + [aws iam update-role](https://docs.aws.amazon.com/cli/latest/reference/iam/update-role.html)

### Aggiornamento di una descrizione del ruolo (AWS API)
<a name="id_roles_update-description-api"></a>

**Per modificare la descrizione di un ruolo (AWS API)**

1. (Facoltativo) Per visualizzare la descrizione corrente per un ruolo, chiamare l'operazione seguente:
   + [GetRole](https://docs.aws.amazon.com/IAM/latest/APIReference/API_GetRole.html) 

1. Per aggiornare la descrizione di un ruolo, chiamare l'operazione seguente con il parametro relativo alla descrizione:
   + [UpdateRole](https://docs.aws.amazon.com/IAM/latest/APIReference/API_UpdateRole.html)

## Aggiornamento della durata massima della sessione per un ruolo
<a name="id_roles_update-session-duration"></a>

Per specificare l'impostazione della durata massima della sessione per i ruoli che vengono assunti utilizzando la console AWS CLI, l'o l' AWS API, modifica il valore di impostazione della durata massima della sessione. Questa impostazione può avere un valore compreso tra 1 ora e 12 ore. Se non specifichi un valore, viene applicata l'impostazione predefinita massima di 1 ora. Questa impostazione non limita le sessioni assunte dai AWS servizi.

### Aggiornamento della durata massima della sessione del ruolo (console)
<a name="id_roles_update-session-duration-console"></a><a name="id_roles_modify_max-session"></a>

**Per modificare l'impostazione della durata massima della sessione per i ruoli assunti utilizzando la console o l' AWS API (console) AWS CLI**

1. 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. Nel pannello di navigazione della console IAM seleziona **Roles (Ruoli)**.

1. Scegliere il nome del ruolo da modificare.

1. Nella sezione **Summary** (Riepilogo), scegli **Edit** (Modifica).

1. In **Maximum session duration** (Durata massima della sessione), scegli un valore. In alternativa, scegli **Custom duration** (Durata personalizzata) e inserisci un valore (in secondi).

1. Scegli **Save changes** (Salva modifiche).

   Le modifiche non verranno applicate fino alla volta successiva in cui qualcuno assume questo ruolo. Per informazioni su come revocare le sessioni esistenti per il ruolo, consultare [Revocare le credenziali di sicurezza temporanee per i ruoli IAM](id_roles_use_revoke-sessions.md).

In Console di gestione AWS, per impostazione predefinita, le sessioni utente IAM durano 12 ore. Agli utenti IAM viene che cambiano ruoli nella console viene concessa la durata massima della sessione del ruolo o il tempo rimanente nella sessione dell'utente IAM, a seconda di quale sia minore.

Chiunque assuma il ruolo dell' AWS API AWS CLI or può richiedere una sessione più lunga, fino a questo massimo. L'impostazione `MaxSessionDuration` determina la durata massima della sessione del ruolo che può essere richiesta.
+ Per specificare la durata di una sessione AWS CLI utilizzando il `duration-seconds` parametro. Per ulteriori informazioni, consulta [Passaggio a un ruolo IAM (AWS CLI)](id_roles_use_switch-role-cli.md).
+ Per specificare la durata di una sessione utilizzando l' AWS API, utilizza il `DurationSeconds` parametro. Per ulteriori informazioni, consulta [Passa a un ruolo IAM (AWS API)](id_roles_use_switch-role-api.md). 

### Aggiornamento della durata massima della sessione di ruolo (AWS CLI)
<a name="id_roles_update-session-duration-cli"></a>

**Nota**  
Chiunque assuma il ruolo dell'API AWS CLI o può utilizzare il parametro `duration-seconds` CLI o `DurationSeconds` il parametro API per richiedere una sessione più lunga. L'impostazione `MaxSessionDuration` determina la durata massima della sessione del ruolo che può essere richiesta usando il parametro `DurationSeconds`. Se gli utenti non specificano un valore per il parametro `DurationSeconds` le loro credenziali di sicurezza rimangono valide per un'ora.

**Per modificare l'impostazione della durata massima della sessione per i ruoli assunti utilizzando il AWS CLI ()AWS CLI**

1. (Facoltativo) Per visualizzare l'impostazione della durata massima della sessione corrente per un ruolo, eseguire il comando seguente:
   + [aws iam get-role](https://docs.aws.amazon.com/cli/latest/reference/iam/get-role.html)

1. Per aggiornare l'impostazione della durata massima della sessione di un ruolo, eseguire il comando seguente con il parametro `max-session-duration` della CLI oppure il parametro API `MaxSessionDuration`:
   + [aws iam update-role](https://docs.aws.amazon.com/cli/latest/reference/iam/update-role.html)

   Le modifiche non verranno applicate fino alla volta successiva in cui qualcuno assume questo ruolo. Per informazioni su come revocare le sessioni esistenti per il ruolo, consultare [Revocare le credenziali di sicurezza temporanee per i ruoli IAM](id_roles_use_revoke-sessions.md).

### Aggiornamento della durata massima della sessione di ruolo (AWS API)
<a name="id_roles_update-session-duration-api"></a>

**Nota**  
Chiunque assuma il ruolo dell'API AWS CLI o può utilizzare il parametro `duration-seconds` CLI o `DurationSeconds` il parametro API per richiedere una sessione più lunga. L'impostazione `MaxSessionDuration` determina la durata massima della sessione del ruolo che può essere richiesta usando il parametro `DurationSeconds`. Se gli utenti non specificano un valore per il parametro `DurationSeconds` le loro credenziali di sicurezza rimangono valide per un'ora.

**Per modificare l'impostazione della durata massima della sessione per i ruoli assunti utilizzando l'API (API)AWS**

1. (Facoltativo) Per visualizzare l'impostazione della durata massima della sessione corrente per un ruolo, chiamare l'operazione seguente:
   + [GetRole](https://docs.aws.amazon.com/IAM/latest/APIReference/API_GetRole.html) 

1. Per aggiornare l'impostazione della durata massima della sessione di un ruolo, chiamare l'operazione seguente con il parametro `max-sessionduration` della CLI oppure il parametro API `MaxSessionDuration`:
   + [UpdateRole](https://docs.aws.amazon.com/IAM/latest/APIReference/API_UpdateRole.html)

   Le modifiche non verranno applicate fino alla volta successiva in cui qualcuno assume questo ruolo. Per informazioni su come revocare le sessioni esistenti per il ruolo, consultare [Revocare le credenziali di sicurezza temporanee per i ruoli IAM](id_roles_use_revoke-sessions.md).

# Eliminare i ruoli o i profili delle istanze
<a name="id_roles_manage_delete"></a>

Se un ruolo non è più necessario, si consiglia di eliminare il ruolo e le autorizzazioni associate. In questo modo non sarà più presente un’entità non utilizzata che non viene monitorata e gestita attivamente. 

Se il ruolo è stato associato a un'istanza EC2, è anche possibile rimuovere il ruolo dal profilo dell'istanza e quindi eliminare il profilo dell'istanza.

**avvertimento**  
Assicurati di non avere istanze Amazon EC2 in esecuzione con il ruolo o il profilo di istanza che stai per eliminare. L'eliminazione di un ruolo o di un profilo di istanza associato a un'istanza in esecuzione interrompe tutte le applicazioni in esecuzione sull'istanza.

Se si preferisce non eliminare definitivamente un ruolo, è possibile disabilitarlo. A tale scopo, modifica le policy del ruolo e quindi revoca tutte le sessioni correnti. Ad esempio, potresti aggiungere una policy al ruolo che nega l'accesso a tutti. AWSÈ inoltre possibile modificare i criteri di attendibilità per negare l'accesso a tutti coloro che tentano di assumere il ruolo. Per ulteriori informazioni sull'avvio delle sessioni, consulta [Revocare le credenziali di sicurezza temporanee per i ruoli IAM](id_roles_use_revoke-sessions.md).

**Topics**
+ [Visualizzazione dell'accesso del ruolo](#roles-delete_prerequisites)
+ [Eliminazione del ruolo collegato ai servizi](#id_roles_manage_delete_slr)
+ [Eliminazione di un ruolo IAM (console)](#roles-managingrole-deleting-console)
+ [Eliminazione di un ruolo IAM (AWS CLI)](#roles-managingrole-deleting-cli)
+ [Eliminazione di un ruolo IAM (API)AWS](#roles-managingrole-deleting-api)
+ [Informazioni correlate](#roles-managingrole-deleting-related-info)

## Visualizzazione dell'accesso del ruolo
<a name="roles-delete_prerequisites"></a>

Prima di eliminare un ruolo, è opportuno esaminare quando è stato utilizzato per l'ultima volta. È possibile eseguire questa operazione utilizzando l' Console di gestione AWS AWS CLI, l'o l' AWS API. È consigliabile visualizzare queste informazioni per non privare dell'accesso qualcuno che utilizza il ruolo. 

La data dell'ultima attività del ruolo potrebbe non corrispondere all'ultima data riportata nella scheda **Ultimo accesso**. La scheda [**Ultimo accesso**](access_policies_last-accessed-view-data.md) riporta l'attività solo per i servizi consentiti dalle policy di autorizzazione del ruolo. La data dell'ultima attività del ruolo include l'ultimo tentativo di accesso a qualsiasi servizio in AWS.

**Nota**  
Il periodo di monitoraggio dei dati per l'ultima attività di un ruolo e i dati di Ultimo accesso sono per gli ultimi 400 giorni. Questo periodo può essere abbreviato se la regione ha iniziato a supportare queste funzionalità nell'ultimo anno. Il ruolo potrebbe essere stato utilizzato più di 400 giorni fa. Per ulteriori informazioni sul periodo di monitoraggio, consulta [Dove AWS tiene traccia delle ultime informazioni a cui si accede](access_policies_last-accessed.md#last-accessed_tracking-period).

**Per visualizzare la data di ultimo utilizzo di un ruolo (console)**

1. 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. Nel riquadro di navigazione, seleziona **Ruoli**.

1. Individua la riga del ruolo con l'attività che si desidera visualizzare. È possibile utilizzare il campo di ricerca per restringere i risultati. Visualizzare la colonna **Last activity (Ultima attività)** per visualizzare il numero di giorni trascorsi dalla data di ultimo utilizzo del ruolo. Se il ruolo non è stato utilizzato entro il periodo di monitoraggio, nella tabella viene visualizzato **None (Nessuno)**. 

1. Scegliere il nome del ruolo per visualizzare ulteriori informazioni. La pagina **Riepilogo** del ruolo include anche **Ultima attività**, che visualizza la data dell'ultimo utilizzo del ruolo. Se il ruolo non è stato utilizzato negli ultimi 400 giorni, **Last activity (Ultima attività)** visualizza **Not accessed in the tracking period (Nessun accesso nel periodo di monitoraggio)**.

**Per visualizzare la data di ultimo utilizzo di un ruolo (AWS CLI)**  
`[aws iam get-role](https://docs.aws.amazon.com/cli/latest/reference/iam/get-role.html)` - Eseguire questo comando per restituire le informazioni su un ruolo, incluso l'oggetto `RoleLastUsed`. Questo oggetto contiene `LastUsedDate` e la `Region` in cui il ruolo è stato utilizzato per l'ultima volta. Se `RoleLastUsed` è presente ma non contiene un valore, il ruolo non è stato utilizzato entro il periodo di monitoraggio.

**Per visualizzare quando un ruolo è stato utilizzato l'ultima volta (AWS API)**  
`[GetRole](https://docs.aws.amazon.com/IAM/latest/APIReference/GetRole.html)` - Chiamare questa operazione per restituire le informazioni su un ruolo, incluso l'oggetto `RoleLastUsed`. Questo oggetto contiene `LastUsedDate` e la `Region` in cui il ruolo è stato utilizzato per l'ultima volta. Se `RoleLastUsed` è presente ma non contiene un valore, il ruolo non è stato utilizzato entro il periodo di monitoraggio.

## Eliminazione del ruolo collegato ai servizi
<a name="id_roles_manage_delete_slr"></a>

Il metodo utilizzato per eliminare un ruolo collegato ai servizi dipende dal servizio. In alcuni casi, non devi eliminare manualmente un ruolo collegato ai servizi. Ad esempio, quando completi un'operazione specifica (come eliminare una risorsa) nel servizio, il servizio potrebbe eliminare il ruolo collegato ai servizi per te. In altri casi, il servizio può supportare l'eliminazione di un ruolo collegato ai servizi manualmente dalla console del servizio, dall'API o dalla AWS CLI. 

Consulta la documentazione relativa al *[ruolo collegato al servizio](id_roles.md#iam-term-service-linked-role)* del servizio collegato per ulteriori informazioni su come eliminare il ruolo. Puoi visualizzare i ruoli collegati ai servizi nell'account visitando la pagina **Ruoli** IAM nella console. I ruoli collegati al servizio vengono visualizzati con l'indicazione **(Service-linked role) (Ruolo collegato al servizio)** nella colonna **Trusted entities (Entità attendibili)** della tabella. Un banner nella pagina **Riepilogo** del ruolo indica anche che il ruolo è un ruolo collegato ai servizi.

Se il servizio non include la documentazione per l'eliminazione del ruolo collegato al servizio, puoi utilizzare la console IAM o l'API per eliminare il ruolo. AWS CLI

## Eliminazione di un ruolo IAM (console)
<a name="roles-managingrole-deleting-console"></a>

Quando utilizzi il Console di gestione AWS per eliminare un ruolo, IAM scollega automaticamente le policy gestite associate al ruolo. Inoltre elimina automaticamente anche le policy in linea associate al ruolo e qualsiasi profilo dell'istanza Amazon EC2 che contiene il ruolo. 

**Importante**  
In alcuni casi, un ruolo potrebbe essere associato a un profilo dell'istanza Amazon EC2 e il ruolo e il profilo dell'istanza potrebbero avere lo stesso nome. In tal caso puoi utilizzare il Console di gestione AWS per eliminare il ruolo e il profilo dell'istanza. Questo collegamento avviene automaticamente per i ruoli e i profili delle istanze creati nella console. Se hai creato il ruolo da AWS CLI, Tools for Windows PowerShell o dall' AWS API, il ruolo e il profilo dell'istanza potrebbero avere nomi diversi. In questo caso non è possibile utilizzare la console per eliminarli. È invece necessario utilizzare Tools for Windows PowerShell o AWS API per rimuovere prima il ruolo dal profilo dell'istanza. AWS CLIÈ quindi necessario eseguire un passaggio distinto per eliminare il ruolo.

**Per eliminare un ruolo (console)**

1. 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. Nel riquadro di navigazione, scegliere **Roles (Ruoli)**, quindi selezionare la casella di controllo accanto al nome del ruolo che si desidera eliminare. 

1. Nella parte superiore della pagina, scegli **Elimina**.

1. Nella finestra di dialogo di conferma, esamina le informazioni relative all'ultimo accesso, che mostrano l'ultima volta che ciascuno dei ruoli selezionati ha effettuato l'ultimo accesso a un AWS servizio. In questo modo potrai verificare se il ruolo è attualmente attivo. Se desideri procedere, inserisci il nome del ruolo nel campo di immissione testo e seleziona **Elimina**. Se sei sicuro, puoi procedere con l'eliminazione anche se l'ultimo accesso ai dati del servizio è ancora in fase di caricamento.

**Nota**  
Non è possibile utilizzare la console per eliminare un profilo dell'istanza, a meno che non abbia lo stesso nome del ruolo. Il profilo dell'istanza viene eliminato come parte del processo di eliminazione di un ruolo descritto nella procedura precedente. Per eliminare un profilo di istanza senza eliminare anche il ruolo, è necessario utilizzare l' AWS API AWS CLI o. Per ulteriori informazioni, consultare le sezioni indicate di seguito.

## Eliminazione di un ruolo IAM (AWS CLI)
<a name="roles-managingrole-deleting-cli"></a>

Quando si utilizza il AWS CLI per eliminare un ruolo, è necessario innanzitutto eliminare le politiche in linea associate al ruolo. È inoltre necessario scollegare le policy gestite associate al ruolo. Se desideri eliminare il profilo dell'istanza associato che contiene il ruolo, devi eliminarlo separatamente.

**Per eliminare un ruolo (AWS CLI)**

1. Se non conosci il nome del ruolo da eliminare, immetti il comando seguente per elencare i ruoli nell'account:

   ```
   aws iam list-roles
   ```

   L'elenco include l'Amazon Resource Name (ARN) di ogni ruolo. Per fare riferimento ai ruoli con i comandi della CLI utilizza il nome del ruolo, non l'ARN. Ad esempio, per fare riferimento a un ruolo il cui ARN è `arn:aws:iam::123456789012:role/myrole`, puoi usare **myrole**.

1. Rimuovi il ruolo da tutti i profili delle istanze a cui è associato.

   1. Per elencare tutti i profili delle istanze cui è associato il ruolo, immetti il seguente comando:

      ```
      aws iam list-instance-profiles-for-role --role-name role-name
      ```

   1. Per rimuovere il ruolo da un profilo dell'istanza, immetti il seguente comando per ogni profilo dell'istanza:

      ```
      aws iam remove-role-from-instance-profile --instance-profile-name instance-profile-name --role-name role-name
      ```

1. Elimina tutte le policy associate al ruolo.

   1. Per elencare tutte le policy inline presenti nel ruolo, immetti il seguente comando:

      ```
      aws iam list-role-policies --role-name role-name
      ```

   1. Per eliminare ogni policy inline dal ruolo, immetti il seguente comando per ogni policy: 

      ```
      aws iam delete-role-policy --role-name role-name --policy-name policy-name
      ```

   1. Per elencare tutte le policy gestite collegate al ruolo, immetti il seguente comando:

      ```
      aws iam list-attached-role-policies --role-name role-name
      ```

   1. Per scollegare ogni policy gestita dal ruolo, immetti il seguente comando per ogni policy: 

      ```
      aws iam detach-role-policy --role-name role-name --policy-arn policy-arn
      ```

1. Immetti il seguente comando per eliminare il ruolo:

   ```
   aws iam delete-role --role-name role-name
   ```

1. Se non prevedi di riutilizzare i profili delle istanze associati al ruolo, puoi immettere il seguente comando per eliminarli:

   ```
   aws iam delete-instance-profile --instance-profile-name instance-profile-name
   ```

## Eliminazione di un ruolo IAM (API)AWS
<a name="roles-managingrole-deleting-api"></a>

Se utilizzi l'API IAM per eliminare un ruolo, devi prima eliminare le policy inline associate al ruolo. È inoltre necessario scollegare le policy gestite associate al ruolo. Se desideri eliminare il profilo dell'istanza associato che contiene il ruolo, devi eliminarlo separatamente.

**Per eliminare un ruolo (AWS API)**

1. Per elencare tutti i profili di istanza a cui è associato un ruolo, chiama [ListInstanceProfilesForRole](https://docs.aws.amazon.com/IAM/latest/APIReference/API_ListInstanceProfilesForRole.html).

   Per rimuovere il ruolo da un profilo di istanza, chiama [RemoveRoleFromInstanceProfile](https://docs.aws.amazon.com/IAM/latest/APIReference/API_RemoveRoleFromInstanceProfile.html). È necessario passare il nome del ruolo e il nome del profilo di istanza. 

   Se non intendi riutilizzare un profilo di istanza associato al ruolo, chiama [DeleteInstanceProfile](https://docs.aws.amazon.com/IAM/latest/APIReference/API_DeleteInstanceProfile.html)per eliminarlo.

1. Per elencare tutte le politiche in linea per un ruolo, chiama. [ListRolePolicies](https://docs.aws.amazon.com/IAM/latest/APIReference/API_ListRolePolicies.html)

   Per eliminare le politiche in linea associate al ruolo, chiama. [DeleteRolePolicy](https://docs.aws.amazon.com/IAM/latest/APIReference/API_DeleteRolePolicy.html) Devi passare il nome del ruolo e il nome della policy inline. 

1. Per elencare tutte le politiche gestite associate a un ruolo, chiama [ListAttachedRolePolicies](https://docs.aws.amazon.com/IAM/latest/APIReference/API_ListAttachedRolePolicies.html). 

   Per scollegare le politiche gestite allegate al ruolo, chiama [DetachRolePolicy](https://docs.aws.amazon.com/IAM/latest/APIReference/API_DetachRolePolicy.html). Devi passare il nome del ruolo e l'ARN della policy gestita. 

1. Chiama [DeleteRole](https://docs.aws.amazon.com/IAM/latest/APIReference/API_DeleteRole.html)per eliminare il ruolo.

## Informazioni correlate
<a name="roles-managingrole-deleting-related-info"></a>

Per informazioni generali sui profili delle istanze, consulta [Usare profili dell'istanza](id_roles_use_switch-role-ec2_instance-profiles.md).

Per informazioni generali sui ruoli collegati al servizio, consultare [Creare un ruolo collegato ai servizi](id_roles_create-service-linked-role.md).

# Metodi per assumere un ruolo
<a name="id_roles_manage-assume"></a>

Prima che un utente, applicazione o servizio possa utilizzare un ruolo che è stato creato, è necessario [concedere le autorizzazioni per passare](id_roles_use_permissions-to-switch.md) al ruolo. È possibile utilizzare qualsiasi policy collegata a gruppi o utenti per concedere le autorizzazioni necessarie. Dopo aver concesso le autorizzazioni, l'utente può assumere un ruolo dagli Console di gestione AWS strumenti per Windows PowerShell, da AWS Command Line Interface (AWS CLI) e dall'[https://docs.aws.amazon.com/STS/latest/APIReference/API_AssumeRole.html](https://docs.aws.amazon.com/STS/latest/APIReference/API_AssumeRole.html)API.

**Importante**  
Se crei un ruolo a livello programmatico anziché nella console IAM, hai l'opzione per aggiungere un `Path` con un massimo di 512 caratteri in aggiunta a `RoleName`, che può contenere fino a 64 caratteri. Tuttavia, se intendete utilizzare un ruolo con la funzione **Cambia ruolo** in Console di gestione AWS, la combinazione `Path` `RoleName` non può superare i 64 caratteri.

Il metodo utilizzato per assumere il ruolo determina chi può assumere il ruolo e per quanto tempo la sessione del ruolo della sessione può durare. Quando utilizzi `AssumeRole*` Operazioni API, il ruolo IAM assunto è la risorsa. L'utente o il ruolo che chiama le operazioni API `AssumeRole*` è il principale.

Nella tabella seguente vengono confrontati i metodi per assumere i ruoli.


|  Metodo per assumere il ruolo |  **Chi può assumere il ruolo**  | **Metodo per specificare il ciclo di vita delle credenziali** |  **Ciclo di vita delle credenziali (minimo \$1 massimo \$1 predefinito)**  | 
| --- | --- | --- | --- | 
| Console di gestione AWS | Utente o ruoli¹ ([cambiando ruoli](id_roles_use_switch-role-console.md)) | Durata massima sessione nella pagina di riepilogo Ruolo | 15 min \$1 Impostazione durata massima sessione² \$1 1 ora | 
| [https://docs.aws.amazon.com/cli/latest/reference/sts/assume-role.html](https://docs.aws.amazon.com/cli/latest/reference/sts/assume-role.html) CLI oppure operazione API [https://docs.aws.amazon.com/STS/latest/APIReference/API_AssumeRole.html](https://docs.aws.amazon.com/STS/latest/APIReference/API_AssumeRole.html) |  Utente o ruolo¹ | CLI duration-seconds oppure parametro API DurationSeconds | 15 min \$1 Impostazione durata massima sessione² \$1 1 ora  | 
| [https://docs.aws.amazon.com/cli/latest/reference/sts/assume-role-with-saml.html](https://docs.aws.amazon.com/cli/latest/reference/sts/assume-role-with-saml.html) CLI oppure operazione API [https://docs.aws.amazon.com/STS/latest/APIReference/API_AssumeRoleWithSAML.html](https://docs.aws.amazon.com/STS/latest/APIReference/API_AssumeRoleWithSAML.html) | Tutti gli utenti autenticati utilizzando SAML | CLI duration-seconds oppure parametro API DurationSeconds | 15 min \$1 Impostazione durata massima sessione² \$1 1 ora  | 
| [https://docs.aws.amazon.com/cli/latest/reference/sts/assume-role-with-web-identity.html](https://docs.aws.amazon.com/cli/latest/reference/sts/assume-role-with-web-identity.html) CLI oppure operazione API [https://docs.aws.amazon.com/STS/latest/APIReference/API_AssumeRoleWithWebIdentity.html](https://docs.aws.amazon.com/STS/latest/APIReference/API_AssumeRoleWithWebIdentity.html) | Tutti gli utenti autenticati che utilizzano un provider OIDC | CLI duration-seconds oppure parametro API DurationSeconds | 15 min \$1 Impostazione durata massima sessione² \$1 1 ora  | 
| [Console URL](id_roles_providers_enable-console-custom-url.md) creata con AssumeRole  | Utente o ruolo | Parametro HTML SessionDuration nell'URL | 15 min \$1 12 ore \$1 1 ora  | 
| [Console URL](id_roles_providers_enable-console-custom-url.md) creata con AssumeRoleWithSAML  | Tutti gli utenti autenticati utilizzando SAML | Parametro HTML SessionDuration nell'URL | 15 min \$1 12 ore \$1 1 ora | 
| [Console URL](id_roles_providers_enable-console-custom-url.md) creata con AssumeRoleWithWebIdentity  | Tutti gli utenti autenticati che utilizzano un provider OIDC | Parametro HTML SessionDuration nell'URL | 15 min \$1 12 ore \$1 1 ora  | 

¹ L’utilizzo delle credenziali di un ruolo per assumere un ruolo diverso si chiama [concatenazione dei ruoli](id_roles.md#iam-term-role-chaining). Quando si utilizza la concatenazione dei ruoli, la durata della sessione del ruolo è limitata a un’ora. Questo vale per Console di gestione AWS il cambio di ruolo e le operazioni API. AWS CLI Questa limitazione non si applica all'assunzione iniziale di un ruolo in base alle credenziali utente o alle applicazioni in esecuzione su EC2 istanze Amazon che utilizzano profili di istanza.

² Questa impostazione può avere un valore compreso tra 1 ora e 12 ore. Per informazioni sulla modifica dell'impostazione della durata massima della sessione, consulta [Gestione del ruolo IAM](id_roles_manage.md). Questa impostazione determina la durata massima della sessione che è possibile richiedere quando si ottengono le credenziali del ruolo. Ad esempio, quando utilizzi le operazioni dell'[AssumeRoleAPI\$1](https://docs.aws.amazon.com/STS/latest/APIReference/API_AssumeRole.html) per assumere un ruolo, puoi specificare la durata della sessione utilizzando il parametro. `DurationSeconds` Utilizzare questo parametro per specificare la durata della sessione del ruolo da 900 secondi (15 minuti) fino all'impostazione di durata massima della sessione per il ruolo. Agli utenti IAM che cambiano ruoli nella console viene concessa la durata massima della sessione o il tempo rimanente nella sessione dell'utente, a seconda di quale sia minore. Si supponga di impostare una durata massima di 5 ore su un ruolo. Un utente IAM che è stato collegato alla console per 10 ore (rispetto al valore massimo predefinito di 12) può cambiare ruolo. La durata della sessione di ruolo disponibile è di 2 ore. Per informazioni su come visualizzare il valore massimo per il ruolo, consulta [Aggiornamento della durata massima della sessione per un ruolo](id_roles_update-role-settings.md#id_roles_update-session-duration) più avanti su questa pagina.

**Note**  
L'impostazione di durata massima delle sessioni non limita le sessioni assunte dai servizi AWS .
Le credenziali del ruolo Amazon EC2 IAM non sono soggette alla durata massima della sessione configurata nel ruolo.
Per consentire agli utenti di assumere nuovamente il ruolo corrente all'interno di una sessione di ruolo, specificare il ruolo ARN o Account AWS ARN come principale nella politica di attendibilità dei ruoli. Servizi AWS che forniscono risorse di elaborazione come Amazon EC2, Amazon ECS, Amazon EKS e Lambda forniscono credenziali temporanee e le aggiornano automaticamente. Ciò garantisce di disporre sempre di un set di credenziali valido. Per questi servizi, non è necessario riassumere il ruolo attuale per ottenere credenziali temporanee. Tuttavia, se intendi passare [tag di sessione](id_session-tags.md) o una [Policy di sessione](access_policies.md#policies_session), devi riassumere il ruolo attuale. Per informazioni su come modificare una politica di attendibilità dei ruoli per aggiungere il ruolo principale ARN o Account AWS ARN, vedere. [Aggiornamento di una policy di attendibilità del ruolo](id_roles_update-role-trust-policy.md)

**Topics**
+ [Passare da un utente a un ruolo IAM (console)](id_roles_use_switch-role-console.md)
+ [Passaggio a un ruolo IAM (AWS CLI)](id_roles_use_switch-role-cli.md)
+ [Passare a un ruolo IAM (Tools for Windows PowerShell)](id_roles_use_switch-role-twp.md)
+ [Passa a un ruolo IAM (AWS API)](id_roles_use_switch-role-api.md)
+ [Utilizzare un ruolo IAM per concedere autorizzazioni alle applicazioni in esecuzione su istanze Amazon EC2](id_roles_use_switch-role-ec2.md)
+ [Usare profili dell'istanza](id_roles_use_switch-role-ec2_instance-profiles.md)

# Passare da un utente a un ruolo IAM (console)
<a name="id_roles_use_switch-role-console"></a>

Puoi cambiare ruolo quando effettui l'accesso come utente IAM, utente del Centro identità IAM, come ruolo federato SAML o come ruolo con federazione delle identità Web. Un *ruolo* specifica un set di autorizzazioni che è possibile utilizzare per accedere alle AWS risorse necessarie. Tuttavia, non si effettua l'accesso a un ruolo, ma una volta effettuato l'accesso come utente IAM è possibile passare a un ruolo IAM. Ciò consente di accantonare temporaneamente le autorizzazioni utente originali e usufruire invece delle autorizzazioni assegnate al ruolo. Il ruolo può trovarsi nel tuo account o in qualsiasi altro Account AWS. Per ulteriori informazioni sui ruoli e i relativi vantaggi e su come crearli e configurarli, consulta [Ruoli IAM](id_roles.md) e [Creazione di ruoli IAM](id_roles_create.md).

Le autorizzazioni dell'utente e di qualsiasi ruolo a cui si passa non sono cumulative. Un solo set di autorizzazioni è attivo alla volta. Quando passi a un ruolo, lasci temporaneamente le autorizzazioni utente e utilizzi le autorizzazioni assegnate al ruolo. Quando lasci il ruolo, le autorizzazioni utente vengono automaticamente ripristinate.

Quando si cambia ruolo in Console di gestione AWS, la console utilizza sempre le credenziali originali per autorizzare lo switch. Ad esempio, se passi al RuoloA, IAM utilizza le tue credenziali originali per determinare se è possibile assumere il RuoloA. **Se poi si passa a *RoleB mentre si utilizza RoLEA, utilizza comunque le* credenziali originali per autorizzare lo switch AWS , non le credenziali per RolEA.**

**Nota**  
Quando accedi come utente al Centro identità IAM, come ruolo federato SAML o come ruolo con federazione delle identità Web, all'avvio della sessione assumi un ruolo IAM. Ad esempio, quando un utente di IAM Identity Center accede al portale di AWS accesso, deve scegliere un set di autorizzazioni correlato a un ruolo prima di poter accedere alle risorse. AWS 

## Sessioni come ruolo
<a name="id_roles_iam_user-switch-role-sessions"></a>

Quando cambi ruolo, la Console di gestione AWS sessione dura per impostazione predefinita 1 ora. Le sessioni dell'utente IAM sono 12 ore per impostazione predefinita, mentre per altri utenti è possibile che la durata della sessione sia diversa. Quando cambi ruolo nella console, viene concessa la durata massima della sessione o il tempo rimanente nella sessione dell’utente, a seconda di quale sia minore. Non puoi prolungare la durata della sessione assumendo un ruolo.

Si supponga, ad esempio, che per un ruolo sia impostata una durata massima di sessione di 10 ore. Hai effettuato l'accesso alla console per 8 ore quando decidi di cambiare ruolo. Ci sono 4 ore rimanenti nella sessione utente, quindi la durata della sessione ruolo consentita è di 4 ore e non la durata massima della sessione di 10 ore. Nella tabella seguente viene illustrato come determinare la durata della sessione per un utente IAM quando si cambia ruolo nella console.


| Il tempo rimanente della sessione utente IAM è... | La durata della sessione del ruolo è… | 
| --- | --- | 
| Meno della durata massima della sessione del ruolo | Tempo rimanente nella sessione utente | 
| Più della durata massima della sessione del ruolo | Valore della durata massima della sessione | 
| Uguale alla durata massima della sessione del ruolo | Valore della durata massima della sessione (approssimativo) | 

L’utilizzo delle credenziali perché un ruolo assuma un ruolo diverso viene chiamato [concatenamento dei ruoli](id_roles.md#iam-term-role-chaining). Quando si utilizza il concatenamento dei ruoli, la durata della sessione è limitata a un’ora, indipendentemente dall’impostazione della durata massima della sessione configurata per i singoli ruoli. Questo vale per Console di gestione AWS il cambio di ruolo e le operazioni API. AWS CLI

**Nota**  
Alcune console AWS di servizio possono rinnovare automaticamente la sessione di ruolo alla scadenza senza che l'utente intraprenda alcuna azione. Alcune potrebbero richiedere di ricaricare la pagina del browser per autenticare nuovamente la sessione.

## Considerazioni
<a name="id_roles_iam_user-switch-role-considerations"></a>
+ Non puoi cambiare ruolo se accedi come. Utente root dell'account AWS
+ Agli utenti deve essere concessa l'autorizzazione a cambiare ruolo in base alla policy. Per istruzioni, consulta [Concedere le autorizzazioni agli utenti per cambiare ruoli](id_roles_use_permissions-to-switch.md).
+ Non puoi passare da un ruolo Console di gestione AWS a un ruolo che richiede un [ExternalId](id_roles_common-scenarios_third-party.md#id_roles_third-party_external-id)valore. È possibile passare a tale ruolo solo chiamando l'API [https://docs.aws.amazon.com/STS/latest/APIReference/API_AssumeRole.html](https://docs.aws.amazon.com/STS/latest/APIReference/API_AssumeRole.html) che supporta il parametro `ExternalId`.

## Per passare a un ruolo
<a name="id_roles_iam_user-switch-role-console-procedure"></a>

1. Segui la procedura di accesso appropriata al tuo tipo di utente, come descritto nell’argomento [Accesso alla Console di gestione AWS](https://docs.aws.amazon.com/signin/latest/userguide/how-to-sign-in.html) nella *Guida per l’utente di Accedi ad AWS *.

1. In Console di gestione AWS, scegli il tuo nome utente nella barra di navigazione in alto a destra. Di solito ha il seguente aspetto: ***username*@ *account\$1ID\$1number\$1or\$1alias***.

1. Per cambiare ruolo scegli uno dei seguenti metodi:
   + Scegli **Cambia ruolo**.
   + Se hai scelto il supporto multisessione, scegli **Aggiungi sessione** e seleziona **Cambia ruolo**.
**Nota**  
Puoi accedere contemporaneamente fino a un massimo di cinque identità diverse in un unico browser web nella Console di gestione AWS. Per maggiori dettagli, consulta [Accesso a più account](https://docs.aws.amazon.com/awsconsolehelpdocs/latest/gsg/multisession.html) nella *Guida introduttiva alla Console di gestione AWS *.

1. Nella pagina **Switch Role (Cambia ruolo)** inserisci il numero ID dell'account o l'alias dell'account e il nome del ruolo che è stato fornito dall'amministratore.
**Nota**  
Se l'amministratore ha creato il ruolo con un percorso, ad esempio `division_abc/subdivision_efg/roleToDoX`, allora è necessario digitare tale percorso completo e il nome nella casella **Role (Ruolo)**. Se digiti solo il nome del ruolo, oppure se il `Path` e il `RoleName` insieme superano 64 caratteri, il passaggio di ruolo fallisce. Si tratta di un limite dei cookie del browser che memorizzano il nome del ruolo. In questo caso, contatta l'amministratore e chiedi di ridurre le dimensioni del percorso e il nome del ruolo.

1. (Facoltativo) È possibile inserire un nome di visualizzazione e selezionare un colore di visualizzazione che evidenzierà il ruolo nella barra di navigazione della console.
   + Per **Nome di visualizzazione** inserisci il testo che desideri visualizzare nella barra di navigazione al posto del tuo nome utente quando questo ruolo è attivo. Viene suggerito un nome, in base all'account e alle informazioni del ruolo, ma è possibile modificarlo in base alle proprie esigenze. 
   + Per **Colore di visualizzazione**, seleziona un colore per evidenziare il nome di visualizzazione.

   Il nome e il colore possono aiutarti a ricordare quando questo ruolo è attivo, ciò cambia le tue autorizzazioni. Ad esempio, per un ruolo che ti consente di accedere all'ambiente di test, puoi specificare un **Nome di visualizzazione** uguale a **Test** e selezionare il verde in **Colore**. Per il ruolo che ti consente di accedere all'ambiente di produzione, puoi specificare un **Nome di visualizzazione** uguale a **Production** e selezionare il rosso in **Colore**.

1. Seleziona **Switch Role** (Cambia ruolo). Il nome di visualizzazione e il colore sostituiscono il nome utente nella barra di navigazione ed è possibile iniziare a utilizzare le autorizzazioni concesse dal ruolo.

1. Dopo aver completato le attività che richiedono il ruolo IAM, potrai tornare alla sessione originale. In questo modo verranno rimosse le autorizzazioni aggiuntive fornite dal ruolo e verranno ripristinate le autorizzazioni standard.

   1. Nella console IAM, scegli il **Nome di visualizzazione** del tuo ruolo sulla barra di navigazione in alto a destra.

   1. Seleziona **Torna indietro**.

      Ad esempio, supponiamo di aver eseguito l'accesso all'account numero `123456789012` utilizzando il nome utente `Richard`. Dopo aver utilizzato il ruolo `admin-role`, si desidera interrompere l'utilizzo del ruolo e tornare alle autorizzazioni originali. Per smettere di usare il ruolo, scegli **admin-role @ 123456789012**, quindi scegli **Torna indietro**.  
![\[Grafico che mostra la funzione Torna indietro per smettere di usare un ruolo IAM e tornare all'utente originale.\]](http://docs.aws.amazon.com/it_it/IAM/latest/UserGuide/images/role-stop-using.png)

**Suggerimento**  
Gli ultimi ruoli utilizzati appariranno nel menu. La prossima volta che devi passare a uno di questi ruoli, è sufficiente selezionare il ruolo desiderato. Se il ruolo non è visualizzato nel menu, è sufficiente digitare l'account e le informazioni del ruolo manualmente.

## Risorse aggiuntive
<a name="id_roles_use_switch-role-console_additional_resources"></a>
+ [Concedere le autorizzazioni agli utenti per cambiare ruoli](id_roles_use_permissions-to-switch.md)
+ [Concedere a un utente le autorizzazioni per passare un ruolo a un servizio AWS](id_roles_use_passrole.md)
+ [Creazione di un ruolo per fornire le autorizzazioni a un utente IAM](id_roles_create_for-user.md)
+ [Creare un ruolo per delegare le autorizzazioni a un servizio AWS](id_roles_create_for-service.md)
+ [Risoluzione dei problemi relativi ai ruoli IAM](troubleshoot_roles.md)

# Passaggio a un ruolo IAM (AWS CLI)
<a name="id_roles_use_switch-role-cli"></a>

Un *ruolo* specifica un set di autorizzazioni da utilizzare per accedere alle risorse AWS necessarie. In questo senso, è simile a un [utente in AWS Identity and Access Management](https://docs.aws.amazon.com/IAM/latest/UserGuide/id.html) (IAM). Quando effettui l'accesso come utente, ottieni uno specifico set di autorizzazioni. Tuttavia, non effettui l'accesso a un ruolo, ma dopo aver effettuato l'accesso come utente, puoi passare a un ruolo. Ciò consente di accantonare temporaneamente le autorizzazioni utente originali e usufruire invece delle autorizzazioni assegnate al ruolo. Il ruolo può trovarsi nel tuo account o in qualsiasi altro Account AWS. Per ulteriori informazioni sui ruoli e i relativi vantaggi e su come crearli e configurarli, consulta [Ruoli IAM](id_roles.md) e [Creazione di ruoli IAM](id_roles_create.md). Per informazioni sui diversi metodi che si possono utilizzare per assumere un ruolo, consulta [Metodi per assumere un ruolo](id_roles_manage-assume.md).

**Importante**  
Le autorizzazioni dell'utente IAM e di qualsiasi ruolo assunto non sono cumulative. Un solo set di autorizzazioni è attivo alla volta. Quando si assume un ruolo, si lascia temporaneamente l'utente precedente o le autorizzazioni del ruolo e si lavora con le autorizzazioni assegnate al ruolo. Quando lasci il ruolo, le autorizzazioni utente vengono automaticamente ripristinate.

Puoi utilizzare un ruolo per eseguire un AWS CLI comando quando accedi come utente IAM. Puoi anche utilizzare un ruolo per eseguire un AWS CLI comando quando accedi come [utente autenticato esternamente](id_roles_providers.md) ([SAML](id_roles_providers_saml.md) o [OIDC](id_roles_providers_oidc.md)) che sta già utilizzando un ruolo. Inoltre, puoi utilizzare un ruolo per eseguire un comando AWS CLI da un'istanza Amazon EC2 collegata a un ruolo tramite il relativo profilo. Non è possibile assumere un ruolo quando si è effettuato l'accesso come Utente root dell'account AWS.

[**Concatenamento del ruolo**](id_roles.md#iam-term-role-chaining): puoi anche utilizzare la concatenamento dei ruoli che utilizza le autorizzazioni di un ruolo per accedere a un secondo ruolo.

Come impostazione predefinita, la sessione del ruolo dura un'ora. Quando si assume questo ruolo utilizzando le operazioni della CLI `assume-role*`, è possibile specificare un valore per il parametro `duration-seconds`. Questo valore può variare da 900 secondi (15 minuti) fino alla durata massima della sessione per il ruolo. Se cambi ruolo nella console, la durata della sessione è limitata a un massimo di un'ora. Per informazioni su come visualizzare il valore massimo per il ruolo, consulta [Aggiornamento della durata massima della sessione per un ruolo](id_roles_update-role-settings.md#id_roles_update-session-duration). 

Se si utilizza il concatenamento dei ruoli, la tua durata della sessione è limitata a un massimo di un'ora. Se successivamente utilizzi il parametro `duration-seconds` per fornire un valore superiore a un'ora, l'operazione ha esito negativo.

## Scenario di esempio: passaggio a un ruolo di produzione
<a name="switch-role-cli-scenario-prod-env"></a>

Immagina di essere un utente IAM per utilizzare l'ambiente di sviluppo. In questo scenario, a volte è necessario utilizzare l'ambiente di produzione nella riga di comando con l'[AWS CLI](https://aws.amazon.com/cli/). Disponi già di un set di credenziali con chiave di accesso. Questa può essere la coppia di chiavi di accesso assegnata all'utente IAM standard. Oppure, se hai effettuato l’accesso come principale federato SAML o OIDC, può essere la coppia di chiavi di accesso per il ruolo che ti è stato inizialmente assegnato. Se le autorizzazioni attuali ti garantiscono la possibilità di assumere un ruolo IAM specifico, puoi identificare quel ruolo in un «profilo» nei file di configurazione. AWS CLI Questo comando viene quindi eseguito con le autorizzazioni del ruolo IAM specificato, non con l'identità originale. Nota che quando specifichi quel profilo in un AWS CLI comando, stai usando il nuovo ruolo. In questa situazione, non puoi utilizzare le autorizzazioni originali nell'account di sviluppo nello stesso momento. Il motivo è che solo un set di autorizzazioni può essere attivo alla volta.

**Nota**  
Per motivi di sicurezza, gli amministratori possono [esaminare AWS CloudTrail i registri](cloudtrail-integration.md#cloudtrail-integration_signin-tempcreds) per scoprire chi ha eseguito un'azione in. AWS L'amministratore potrebbe richiedere di specificare una identità di origine o un nome della sessione del ruolo quando si assume il ruolo. Per ulteriori informazioni, consultare [`sts:SourceIdentity`](reference_policies_iam-condition-keys.md#ck_sourceidentity) e [`sts:RoleSessionName`](reference_policies_iam-condition-keys.md#ck_rolesessionname).

**Per passare a un ruolo di produzione (AWS CLI)**

1. <a name="step-configure-default"></a>Se non hai mai usato il AWS CLI, devi prima configurare il tuo profilo CLI predefinito. Apri un prompt dei comandi e configura AWS CLI l'installazione per utilizzare la chiave di accesso del tuo utente IAM o del tuo ruolo federato. Per ulteriori informazioni, consulta [Configurazione della AWS Command Line Interface](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-getting-started.html#cli-quick-configuration) nella *Guida per l'utente di AWS Command Line Interface *.

   Esegui il comando [aws configure](https://docs.aws.amazon.com/cli/latest/reference/configure/) come riportato di seguito:

   ```
   aws configure
   ```

   Quando viene richiesto, fornire le seguenti informazioni:

   ```
   AWS Access Key ID [None]: AKIAIOSFODNN7EXAMPLE
   AWS Secret Access Key [None]: wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY
   Default region name [None]: us-east-2
   Default output format [None]: json
   ```

1. Creare un nuovo profilo per il ruolo nel file `.aws/config` in Unix o Linux, oppure nel file `C:\Users\USERNAME\.aws\config` in Windows. L'esempio seguente crea un profilo denominato `prodaccess` che passa al ruolo `ProductionAccessRole` nell'account `123456789012`. L'ARN del ruolo si ottiene dall'amministratore dell'account che ha creato il ruolo. Quando questo profilo viene richiamato, AWS CLI utilizza le credenziali di `source_profile` per richiedere le credenziali per il ruolo. Per questo motivo, l'identità alla quale viene fatto riferimento come `source_profile` deve disporre delle autorizzazioni `sts:AssumeRole` per il ruolo specificato in `role_arn`.

   ```
   [profile prodaccess]
       role_arn = arn:aws:iam::123456789012:role/ProductionAccessRole
       source_profile = default
   ```

1. Dopo aver creato il nuovo profilo, qualsiasi AWS CLI comando che specifica il parametro `--profile prodaccess` viene eseguito con le autorizzazioni associate al ruolo IAM `ProductionAccessRole` anziché con l'utente predefinito.

   ```
   aws iam list-users --profile prodaccess
   ```

   Questo comando funziona se le autorizzazioni assegnate a `ProductionAccessRole` permettono di elencare gli utenti nell'account attuale AWS .

1. Per ripristinare le autorizzazioni concesse dalle credenziali originali, eseguire i comandi senza il parametro `--profile`. Torna a AWS CLI utilizzare le credenziali nel tuo profilo predefinito, in cui hai configurato. [Step 1](#step-configure-default)

Per ulteriori informazioni, consulta [Assunzione di un ruolo](https://docs.aws.amazon.com/cli/latest/userguide/cli-roles.html) nella *Guida per l'utente di AWS Command Line Interface *.

## Scenario di esempio: consentire a un ruolo del profilo dell'istanza di passare a un ruolo in un altro account
<a name="switch-role-cli-scenario-ec2-instance"></a>

Immagina di usarne due Account AWS e di voler consentire a un'applicazione in esecuzione su un'istanza Amazon EC2 di eseguire [AWS CLI](https://aws.amazon.com/cli/)comandi in entrambi gli account. Supponiamo che l'istanza EC2 esista nell'account `111111111111`. Tale istanza include il ruolo del profilo dell'istanza `abcd` che consente all'applicazione di eseguire attività Amazon S3 di sola lettura nel bucket `amzn-s3-demo-bucket1` all'interno dello stesso account `111111111111`. Tuttavia, l'applicazione deve anche poter assumere il ruolo tra più account `efgh` per eseguire attività nell'account `222222222222`. A questo scopo, il ruolo del profilo dell'istanza EC2 `abcd` deve disporre della policy di autorizzazioni seguente:

***Policy di autorizzazioni del ruolo `abcd` 111111111111 dell'account***

------
#### [ JSON ]

****  

```
{
    "Version":"2012-10-17",		 	 	 
    "Statement": [
        {
            "Sid": "AllowAccountLevelS3Actions",
            "Effect": "Allow",
            "Action": [
                "s3:GetBucketLocation",
                "s3:GetAccountPublicAccessBlock",
                "s3:ListAccessPoints",
                "s3:ListAllMyBuckets"
            ],
            "Resource": "arn:aws:s3:::*"
        },
        {
            "Sid": "AllowListAndReadS3ActionOnMyBucket",
            "Effect": "Allow",
            "Action": [
                "s3:Get*",
                "s3:List*"
            ],
            "Resource": [
                "arn:aws:s3:::amzn-s3-demo-bucket1/*",
                "arn:aws:s3:::amzn-s3-demo-bucket1"
            ]
        },
        {
            "Sid": "AllowIPToAssumeCrossAccountRole",
            "Effect": "Allow",
            "Action": "sts:AssumeRole",
            "Resource": "arn:aws:iam::222222222222:role/efgh"
        }
    ]
}
```

------

Supponiamo che il ruolo tra account `efgh` consenta attività Amazon S3 di sola lettura nel bucket `amzn-s3-demo-bucket2` all'interno dello stesso account `222222222222`. A tale scopo, il ruolo tra account `efgh` deve disporre della seguente policy di autorizzazioni:

***Policy di autorizzazioni del ruolo `efgh` 222222222222 dell'account***

------
#### [ JSON ]

****  

```
{
    "Version":"2012-10-17",		 	 	 
    "Statement": [
        {
            "Sid": "AllowAccountLevelS3Actions",
            "Effect": "Allow",
            "Action": [
                "s3:GetBucketLocation",
                "s3:GetAccountPublicAccessBlock",
                "s3:ListAccessPoints",
                "s3:ListAllMyBuckets"
            ],
            "Resource": "arn:aws:s3:::*"
        },
        {
            "Sid": "AllowListAndReadS3ActionOnMyBucket",
            "Effect": "Allow",
            "Action": [
                "s3:Get*",
                "s3:List*"
            ],
            "Resource": [
                "arn:aws:s3:::amzn-s3-demo-bucket2/*",
                "arn:aws:s3:::amzn-s3-demo-bucket2"
            ]
        }
    ]
}
```

------

Il ruolo `efgh` deve consentire al ruolo del profilo dell'istanza `abcd` di assumerlo. A tale scopo, il ruolo `efgh` deve disporre della seguente policy di attendibilità:

***Policy di attendibilità del ruolo `efgh` dell'account 222222222222***

------
#### [ JSON ]

****  

```
{
    "Version":"2012-10-17",		 	 	 
    "Statement": [
        {
            "Sid": "efghTrustPolicy",
            "Effect": "Allow",
            "Action": "sts:AssumeRole",
            "Principal": {"AWS": "arn:aws:iam::111111111111:role/abcd"}
        }
    ]
}
```

------

Per eseguire quindi AWS CLI i comandi nell'account`222222222222`, è necessario aggiornare il file di configurazione CLI. Identifica il ruolo `efgh` come il "profilo" e il ruolo del profilo dell'istanza EC2 `abcd` come "origine delle credenziali" nel file di configurazione di AWS CLI . I comandi della CLI vengono quindi eseguiti con le autorizzazioni del ruolo `efgh`, non il ruolo `abcd` originale.

**Nota**  
Per motivi di sicurezza, è possibile utilizzare AWS CloudTrail per controllare l'uso dei ruoli nell'account. Per distinguere tra le sessioni di ruolo quando un ruolo viene utilizzato da diversi responsabili nei CloudTrail log, è possibile utilizzare il nome della sessione di ruolo. Quando AWS CLI assume un ruolo per conto di un utente come descritto in questo argomento, viene creato automaticamente un nome di sessione di ruolo come. `AWS-CLI-session-nnnnnnnn` *nnnnnnnn*Ecco un numero intero che rappresenta l'ora espressa in [Unix Epoch Time](http://wikipedia.org/wiki/Unix_time) (il numero di secondi trascorsi dalla mezzanotte UTC del 1° gennaio 1970). *Per ulteriori informazioni, consultate [CloudTrail Event Reference](https://docs.aws.amazon.com/awscloudtrail/latest/userguide/eventreference.html) nella Guida per l'utente.AWS CloudTrail *

**Per consentire a un ruolo del profilo dell'istanza EC2 di passare a un ruolo tra account (AWS CLI)**

1. Non è necessario configurare un profilo predefinito della CLI. Al contrario, puoi caricare le credenziali dai metadati del profilo dell'istanza EC2. Crea un nuovo profilo per il ruolo nel file `.aws/config`. L'esempio seguente crea un profilo `instancecrossaccount` che passa al ruolo `efgh` nell'account `222222222222`. Quando questo profilo viene richiamato, AWS CLI utilizza le credenziali dei metadati del profilo dell'istanza EC2 per richiedere le credenziali per il ruolo. Per questo motivo, il ruolo del profilo dell'istanza EC2 deve disporre delle autorizzazioni `sts:AssumeRole` per il ruolo specificato nel `role_arn`.

   ```
   [profile instancecrossaccount]
   role_arn = arn:aws:iam::222222222222:role/efgh
   credential_source = Ec2InstanceMetadata
   ```

1. Dopo aver creato il nuovo profilo, qualsiasi AWS CLI comando che specifica il parametro `--profile instancecrossaccount` viene eseguito con le autorizzazioni associate al `efgh` ruolo nell'account. `222222222222`

   ```
   aws s3 ls amzn-s3-demo-bucket2 --profile instancecrossaccount
   ```

   Questo comando funziona se le autorizzazioni che vengono assegnate al ruolo `efgh` consentono di elencare gli utenti nell' Account AWS corrente.

1. Per tornare alle autorizzazioni del profilo dell'istanza EC2 originale nell'account `111111111111`, esegui i comandi della CLI senza il parametro `--profile`.

Per ulteriori informazioni, consulta [Assunzione di un ruolo](https://docs.aws.amazon.com/cli/latest/userguide/cli-roles.html) nella *Guida per l'utente di AWS Command Line Interface *.

# Passare a un ruolo IAM (Tools for Windows PowerShell)
<a name="id_roles_use_switch-role-twp"></a>

Un *ruolo* specifica un set di autorizzazioni da utilizzare per accedere alle risorse AWS necessarie. In questo senso, è simile a un [utente in AWS Identity and Access Management](https://docs.aws.amazon.com/IAM/latest/UserGuide/id.html) (IAM). Quando effettui l'accesso come utente, ottieni uno specifico set di autorizzazioni. Tuttavia, non accedi a un ruolo, ma una volta effettuato l'accesso puoi passare a un ruolo. Ciò consente di accantonare temporaneamente le autorizzazioni utente originali e usufruire invece delle autorizzazioni assegnate al ruolo. Il ruolo può trovarsi nel tuo account o in qualsiasi altro Account AWS. Per ulteriori informazioni sui ruoli e i relativi vantaggi e su come crearli e configurarli, consulta [Ruoli IAM](id_roles.md) e [Creazione di ruoli IAM](id_roles_create.md).

**Importante**  
Le autorizzazioni dell'utente IAM e di qualsiasi ruolo a cui si passa non sono cumulative. Un solo set di autorizzazioni è attivo alla volta. Quando passi a un ruolo, lasci temporaneamente le autorizzazioni utente e utilizzi le autorizzazioni assegnate al ruolo. Quando lasci il ruolo, le autorizzazioni utente vengono automaticamente ripristinate.

Questa sezione descrive come cambiare ruoli quando utilizzi la riga di comando con gli AWS Tools for Windows PowerShell.

Immagina di avere un account nell'ambiente di sviluppo e di dover occasionalmente lavorare con l'ambiente di produzione dalla riga di comando utilizzando gli [strumenti per Windows PowerShell](https://aws.amazon.com/powershell/). Disponi già di un set di credenziali con chiave di accesso. Può trattarsi di una coppia di chiavi di accesso assegnata all'utente IAM standard. In alternativa, se hai effettuato l’accesso come principale federato SAML o OIDC, può trattarsi della coppia di chiavi di accesso per il ruolo inizialmente assegnato. Puoi utilizzare queste credenziali per eseguire il cmdlet `Use-STSRole` che passa l'ARN di un nuovo ruolo come parametro. Il comando restituisce le credenziali di sicurezza temporanee per il ruolo richiesto. È quindi possibile utilizzare tali credenziali nei PowerShell comandi successivi con le autorizzazioni del ruolo per accedere alle risorse in produzione. Mentre utilizzi il ruolo, non puoi utilizzare le autorizzazioni utente dell'account di sviluppo perché è attivo un solo set di autorizzazioni alla volta.

**Nota**  
Per motivi di sicurezza, gli amministratori possono [esaminare AWS CloudTrail i registri](cloudtrail-integration.md#cloudtrail-integration_signin-tempcreds) per scoprire chi ha eseguito un'azione in. AWS L'amministratore potrebbe richiedere di specificare una identità di origine o un nome della sessione del ruolo quando si assume il ruolo. Per ulteriori informazioni, consultare [`sts:SourceIdentity`](reference_policies_iam-condition-keys.md#ck_sourceidentity) e [`sts:RoleSessionName`](reference_policies_iam-condition-keys.md#ck_rolesessionname).

Tutte le chiavi di accesso e i token sono solo esempi e non possono essere utilizzati come mostrato. Sostituiscili con i valori appropriati del tuo ambiente reale.

**Per passare a un ruolo (Strumenti per Windows) PowerShell**

1. Apri un PowerShell prompt dei comandi e configura il profilo predefinito per utilizzare la chiave di accesso del tuo attuale utente IAM o del tuo ruolo federato. Se in precedenza hai utilizzato gli Strumenti per Windows PowerShell, probabilmente l'operazione è già stata eseguita. Tieni presente che è possibile cambiare ruolo solo se hai effettuato l'accesso come utente IAM e non come Utente root dell'account AWS.

   ```
   PS C:\> Set-AWSCredentials -AccessKey AKIAIOSFODNN7EXAMPLE -SecretKey wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY -StoreAs MyMainUserProfile
   PS C:\> Initialize-AWSDefaults -ProfileName MyMainUserProfile -Region us-east-2
   ```

   Per ulteriori informazioni, vedere [Utilizzo AWS delle credenziali](https://docs.aws.amazon.com/powershell/latest/userguide/specifying-your-aws-credentials.html) nella *Guida per l'AWS Strumenti per PowerShell utente*.

1. Per recuperare le credenziali per il nuovo ruolo, eseguire il comando seguente per passare al ruolo `RoleName` nell'account 123456789012. L'ARN del ruolo si ottiene dall'amministratore dell'account che ha creato il ruolo. Il comando richiede di fornire anche un nome di sessione. È possibile selezionare qualsiasi testo. Il comando seguente richiede le credenziali e quindi acquisisce l'oggetto proprietà `Credentials` dall'oggetto risultati restituiti e lo memorizza nella variabile `$Creds`.

   ```
   PS C:\> $Creds = (Use-STSRole -RoleArn "arn:aws:iam::123456789012:role/RoleName" -RoleSessionName "MyRoleSessionName").Credentials
   ```

   `$Creds` è un oggetto che ora contiene gli elementi `AccessKeyId`, `SecretAccessKey` e `SessionToken` necessari nelle fasi successive. I seguenti comandi di esempio illustrano valori tipici:

   ```
   PS C:\> $Creds.AccessKeyId
   AKIAIOSFODNN7EXAMPLE
   
   PS C:\> $Creds.SecretAccessKey
   wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY
   
   PS C:\> $Creds.SessionToken
   AQoDYXdzEGcaEXAMPLE2gsYULo+Im5ZEXAMPLEeYjs1M2FUIgIJx9tQqNMBEXAMPLECvSRyh0FW7jEXAMPLEW+vE/7s1HRp
   XviG7b+qYf4nD00EXAMPLEmj4wxS04L/uZEXAMPLECihzFB5lTYLto9dyBgSDyEXAMPLE9/g7QRUhZp4bqbEXAMPLENwGPy
   Oj59pFA4lNKCIkVgkREXAMPLEjlzxQ7y52gekeVEXAMPLEDiB9ST3UuysgsKdEXAMPLE1TVastU1A0SKFEXAMPLEiywCC/C
   s8EXAMPLEpZgOs+6hz4AP4KEXAMPLERbASP+4eZScEXAMPLEsnf87eNhyDHq6ikBQ==
   
   PS C:\> $Creds.Expiration
   Thursday, June 18, 2018 2:28:31 PM
   ```

1. Per utilizzare queste credenziali per ogni successivo comando, includerle con il parametro `-Credential`. Ad esempio, il comando seguente utilizza le credenziali del ruolo e funziona solo se al ruolo viene concessa l'autorizzazione `iam:ListRoles` grazie alla quale può quindi eseguire il cmdlet `Get-IAMRoles`:

   ```
           PS C:\> get-iamroles -Credential $Creds
   ```

1. Per tornare alle credenziali originali, è sufficiente interrompere l'utilizzo del `-Credentials $Creds` parametro e consentire PowerShell il ripristino delle credenziali archiviate nel profilo predefinito.

# Passa a un ruolo IAM (AWS API)
<a name="id_roles_use_switch-role-api"></a>

Un *ruolo* specifica un set di autorizzazioni da utilizzare per accedere alle risorse di AWS . In questo senso, è simile a un [utente IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/id.html). Un principale (persona o applicazione) assume il ruolo di ricevere le autorizzazioni temporanee per svolgere le attività richieste e interagire con AWS le risorse. Il ruolo può trovarsi nel tuo account o in qualsiasi altro Account AWS. Per ulteriori informazioni sui ruoli e i relativi vantaggi e su come crearli e configurarli, consulta [Ruoli IAM](id_roles.md) e [Creazione di ruoli IAM](id_roles_create.md). Per informazioni sui diversi metodi che si possono utilizzare per assumere un ruolo, consulta [Metodi per assumere un ruolo](id_roles_manage-assume.md).

**Importante**  
Le autorizzazioni dell'utente IAM e di qualsiasi ruolo assunto non sono cumulative. Un solo set di autorizzazioni è attivo alla volta. Quando si assume un ruolo, si lascia temporaneamente l'utente precedente o le autorizzazioni del ruolo e si lavora con le autorizzazioni assegnate al ruolo. Quando lasci il ruolo, le autorizzazioni originali vengono automaticamente ripristinate.

Per assumere un ruolo, un'applicazione chiama l'operazione AWS STS [https://docs.aws.amazon.com/STS/latest/APIReference/API_AssumeRole.html](https://docs.aws.amazon.com/STS/latest/APIReference/API_AssumeRole.html)API e passa l'ARN del ruolo da utilizzare. L'operazione crea una nuova sessione con le credenziali temporanee. Questa sessione ha le stesse autorizzazioni delle policy basate su identità per quel ruolo. 

Quando chiami [https://docs.aws.amazon.com/STS/latest/APIReference/API_AssumeRole.html](https://docs.aws.amazon.com/STS/latest/APIReference/API_AssumeRole.html), puoi passare facoltativamente [policy di sessione](access_policies.md#policies_session) inline o gestite. Le policy di sessione sono policy avanzate che vengono passate come un parametro quando si crea a livello di programmazione una sessione di credenziali temporanee per un ruolo o per una sessione dell’utente federato. Puoi passare un singolo documento della policy di sessione inline JSON utilizzando il parametro `Policy`. Puoi utilizzare il parametro `PolicyArns` per specificare fino a 10 policy di sessione gestite. Le autorizzazioni della sessione risultanti sono l'intersezione delle policy basate sull'identità dell'entità e delle policy di sessione. Le policy di sessione sono utili quando occorre fornire le credenziali temporanee del ruolo a un'altra persona, che potrà usare le credenziali temporanee del ruolo nelle chiamate API AWS successive, per accedere alle risorse nell'account che possiede il ruolo. Non è possibile utilizzare policy di sessione per concedere autorizzazioni maggiori rispetto a quelle consentite dalla policy basata su identità. Per ulteriori informazioni su come AWS determina le autorizzazioni effettive di un ruolo, consulta. [Logica di valutazione delle policy](reference_policies_evaluation-logic.md) 

![\[PermissionsWhenPassingRoles_Diagramma\]](http://docs.aws.amazon.com/it_it/IAM/latest/UserGuide/images/role_passed_policy_permissions.png)


Puoi effettuare una chiamata `AssumeRole` quando hai effettuato l’accesso come utente IAM oppure come [utente autenticato esternamente](id_roles_providers.md) ([SAML](id_roles_providers_saml.md) o [OIDC](id_roles_providers_oidc.md)) che sta già utilizzando un ruolo. Puoi anche utilizzare una [*concatenazione dei ruoli*](id_roles.md#iam-term-role-chaining) ovvero usare un ruolo per definirne un secondo. Non è possibile assumere un ruolo quando si è effettuato l'accesso come Utente root dell'account AWS.

Come impostazione predefinita, la sessione del ruolo dura un'ora. Quando assumi questo ruolo utilizzando le operazioni AWS STS [https://docs.aws.amazon.com/STS/latest/APIReference/API_AssumeRole.html](https://docs.aws.amazon.com/STS/latest/APIReference/API_AssumeRole.html)API, puoi specificare un valore per il `DurationSeconds` parametro. Questo valore può variare da 900 secondi (15 minuti) fino alla durata massima della sessione per il ruolo. Per informazioni su come visualizzare il valore massimo per il ruolo, consulta [Aggiornamento della durata massima della sessione per un ruolo](id_roles_update-role-settings.md#id_roles_update-session-duration). 

Se scegli di ricorrere alla concatenazione dei ruoli, la durata della sessione è limitata a un'ora. Se successivamente utilizzi il parametro `DurationSeconds` per fornire un valore superiore a un'ora, l'operazione ha esito negativo.

**Nota**  
Per motivi di sicurezza, gli amministratori possono [esaminare AWS CloudTrail i log](cloudtrail-integration.md#cloudtrail-integration_signin-tempcreds) per scoprire chi ha eseguito un'azione in. AWS L'amministratore potrebbe richiedere di specificare una identità di origine o un nome della sessione del ruolo quando si assume il ruolo. Per ulteriori informazioni, consultare [`sts:SourceIdentity`](reference_policies_iam-condition-keys.md#ck_sourceidentity) e [`sts:RoleSessionName`](reference_policies_iam-condition-keys.md#ck_rolesessionname).

Gli esempi di codice seguenti mostrano come creare un utente e assumere un ruolo.

**avvertimento**  
Per evitare rischi per la sicurezza, non utilizzare gli utenti IAM per l’autenticazione quando sviluppi software creato ad hoc o lavori con dati reali. Utilizza invece la federazione con un provider di identità come [AWS IAM Identity Center](https://docs.aws.amazon.com/singlesignon/latest/userguide/what-is.html).
+ Crea un utente che non disponga di autorizzazioni.
+ Crea un ruolo che conceda l’autorizzazione per elencare i bucket Amazon S3 per l’account.
+ Aggiungi una policy per consentire all’utente di assumere il ruolo.
+ Assumi il ruolo ed elenca i bucket S3 utilizzando le credenziali temporanee, quindi ripulisci le risorse.

------
#### [ .NET ]

**SDK per .NET**  
 C'è altro su. GitHub Trova l'esempio completo e scopri di più sulla configurazione e l'esecuzione nel [Repository di esempi di codice AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/dotnetv3/IAM#code-examples). 

```
global using Amazon.IdentityManagement;
global using Amazon.S3;
global using Amazon.SecurityToken;
global using IAMActions;
global using IamScenariosCommon;
global using Microsoft.Extensions.DependencyInjection;
global using Microsoft.Extensions.Hosting;
global using Microsoft.Extensions.Logging;
global using Microsoft.Extensions.Logging.Console;
global using Microsoft.Extensions.Logging.Debug;


namespace IAMActions;

public class IAMWrapper
{
    private readonly IAmazonIdentityManagementService _IAMService;

    /// <summary>
    /// Constructor for the IAMWrapper class.
    /// </summary>
    /// <param name="IAMService">An IAM client object.</param>
    public IAMWrapper(IAmazonIdentityManagementService IAMService)
    {
        _IAMService = IAMService;
    }

    /// <summary>
    /// Attach an IAM policy to a role.
    /// </summary>
    /// <param name="policyArn">The policy to attach.</param>
    /// <param name="roleName">The role that the policy will be attached to.</param>
    /// <returns>A Boolean value indicating the success of the action.</returns>
    public async Task<bool> AttachRolePolicyAsync(string policyArn, string roleName)
    {
        var response = await _IAMService.AttachRolePolicyAsync(new AttachRolePolicyRequest
        {
            PolicyArn = policyArn,
            RoleName = roleName,
        });

        return response.HttpStatusCode == System.Net.HttpStatusCode.OK;
    }


    /// <summary>
    /// Create an IAM access key for a user.
    /// </summary>
    /// <param name="userName">The username for which to create the IAM access
    /// key.</param>
    /// <returns>The AccessKey.</returns>
    public async Task<AccessKey> CreateAccessKeyAsync(string userName)
    {
        var response = await _IAMService.CreateAccessKeyAsync(new CreateAccessKeyRequest
        {
            UserName = userName,
        });

        return response.AccessKey;

    }


    /// <summary>
    /// Create an IAM policy.
    /// </summary>
    /// <param name="policyName">The name to give the new IAM policy.</param>
    /// <param name="policyDocument">The policy document for the new policy.</param>
    /// <returns>The new IAM policy object.</returns>
    public async Task<ManagedPolicy> CreatePolicyAsync(string policyName, string policyDocument)
    {
        var response = await _IAMService.CreatePolicyAsync(new CreatePolicyRequest
        {
            PolicyDocument = policyDocument,
            PolicyName = policyName,
        });

        return response.Policy;
    }


    /// <summary>
    /// Create a new IAM role.
    /// </summary>
    /// <param name="roleName">The name of the IAM role.</param>
    /// <param name="rolePolicyDocument">The name of the IAM policy document
    /// for the new role.</param>
    /// <returns>The Amazon Resource Name (ARN) of the role.</returns>
    public async Task<string> CreateRoleAsync(string roleName, string rolePolicyDocument)
    {
        var request = new CreateRoleRequest
        {
            RoleName = roleName,
            AssumeRolePolicyDocument = rolePolicyDocument,
        };

        var response = await _IAMService.CreateRoleAsync(request);
        return response.Role.Arn;
    }


    /// <summary>
    /// Create an IAM service-linked role.
    /// </summary>
    /// <param name="serviceName">The name of the AWS Service.</param>
    /// <param name="description">A description of the IAM service-linked role.</param>
    /// <returns>The IAM role that was created.</returns>
    public async Task<Role> CreateServiceLinkedRoleAsync(string serviceName, string description)
    {
        var request = new CreateServiceLinkedRoleRequest
        {
            AWSServiceName = serviceName,
            Description = description
        };

        var response = await _IAMService.CreateServiceLinkedRoleAsync(request);
        return response.Role;
    }


    /// <summary>
    /// Create an IAM user.
    /// </summary>
    /// <param name="userName">The username for the new IAM user.</param>
    /// <returns>The IAM user that was created.</returns>
    public async Task<User> CreateUserAsync(string userName)
    {
        var response = await _IAMService.CreateUserAsync(new CreateUserRequest { UserName = userName });
        return response.User;
    }


    /// <summary>
    /// Delete an IAM user's access key.
    /// </summary>
    /// <param name="accessKeyId">The Id for the IAM access key.</param>
    /// <param name="userName">The username of the user that owns the IAM
    /// access key.</param>
    /// <returns>A Boolean value indicating the success of the action.</returns>
    public async Task<bool> DeleteAccessKeyAsync(string accessKeyId, string userName)
    {
        var response = await _IAMService.DeleteAccessKeyAsync(new DeleteAccessKeyRequest
        {
            AccessKeyId = accessKeyId,
            UserName = userName,
        });

        return response.HttpStatusCode == System.Net.HttpStatusCode.OK;
    }


    /// <summary>
    /// Delete an IAM policy.
    /// </summary>
    /// <param name="policyArn">The Amazon Resource Name (ARN) of the policy to
    /// delete.</param>
    /// <returns>A Boolean value indicating the success of the action.</returns>
    public async Task<bool> DeletePolicyAsync(string policyArn)
    {
        var response = await _IAMService.DeletePolicyAsync(new DeletePolicyRequest { PolicyArn = policyArn });
        return response.HttpStatusCode == System.Net.HttpStatusCode.OK;
    }


    /// <summary>
    /// Delete an IAM role.
    /// </summary>
    /// <param name="roleName">The name of the IAM role to delete.</param>
    /// <returns>A Boolean value indicating the success of the action.</returns>
    public async Task<bool> DeleteRoleAsync(string roleName)
    {
        var response = await _IAMService.DeleteRoleAsync(new DeleteRoleRequest { RoleName = roleName });
        return response.HttpStatusCode == System.Net.HttpStatusCode.OK;
    }


    /// <summary>
    /// Delete an IAM role policy.
    /// </summary>
    /// <param name="roleName">The name of the IAM role.</param>
    /// <param name="policyName">The name of the IAM role policy to delete.</param>
    /// <returns>A Boolean value indicating the success of the action.</returns>
    public async Task<bool> DeleteRolePolicyAsync(string roleName, string policyName)
    {
        var response = await _IAMService.DeleteRolePolicyAsync(new DeleteRolePolicyRequest
        {
            PolicyName = policyName,
            RoleName = roleName,
        });

        return response.HttpStatusCode == System.Net.HttpStatusCode.OK;
    }


    /// <summary>
    /// Delete an IAM user.
    /// </summary>
    /// <param name="userName">The username of the IAM user to delete.</param>
    /// <returns>A Boolean value indicating the success of the action.</returns>
    public async Task<bool> DeleteUserAsync(string userName)
    {
        var response = await _IAMService.DeleteUserAsync(new DeleteUserRequest { UserName = userName });

        return response.HttpStatusCode == System.Net.HttpStatusCode.OK;
    }


    /// <summary>
    /// Delete an IAM user policy.
    /// </summary>
    /// <param name="policyName">The name of the IAM policy to delete.</param>
    /// <param name="userName">The username of the IAM user.</param>
    /// <returns>A Boolean value indicating the success of the action.</returns>
    public async Task<bool> DeleteUserPolicyAsync(string policyName, string userName)
    {
        var response = await _IAMService.DeleteUserPolicyAsync(new DeleteUserPolicyRequest { PolicyName = policyName, UserName = userName });

        return response.HttpStatusCode == System.Net.HttpStatusCode.OK;
    }


    /// <summary>
    /// Detach an IAM policy from an IAM role.
    /// </summary>
    /// <param name="policyArn">The Amazon Resource Name (ARN) of the IAM policy.</param>
    /// <param name="roleName">The name of the IAM role.</param>
    /// <returns>A Boolean value indicating the success of the action.</returns>
    public async Task<bool> DetachRolePolicyAsync(string policyArn, string roleName)
    {
        var response = await _IAMService.DetachRolePolicyAsync(new DetachRolePolicyRequest
        {
            PolicyArn = policyArn,
            RoleName = roleName,
        });

        return response.HttpStatusCode == System.Net.HttpStatusCode.OK;
    }


    /// <summary>
    /// Gets the IAM password policy for an AWS account.
    /// </summary>
    /// <returns>The PasswordPolicy for the AWS account.</returns>
    public async Task<PasswordPolicy> GetAccountPasswordPolicyAsync()
    {
        var response = await _IAMService.GetAccountPasswordPolicyAsync(new GetAccountPasswordPolicyRequest());
        return response.PasswordPolicy;
    }


    /// <summary>
    /// Get information about an IAM policy.
    /// </summary>
    /// <param name="policyArn">The IAM policy to retrieve information for.</param>
    /// <returns>The IAM policy.</returns>
    public async Task<ManagedPolicy> GetPolicyAsync(string policyArn)
    {

        var response = await _IAMService.GetPolicyAsync(new GetPolicyRequest { PolicyArn = policyArn });
        return response.Policy;
    }


    /// <summary>
    /// Get information about an IAM role.
    /// </summary>
    /// <param name="roleName">The name of the IAM role to retrieve information
    /// for.</param>
    /// <returns>The IAM role that was retrieved.</returns>
    public async Task<Role> GetRoleAsync(string roleName)
    {
        var response = await _IAMService.GetRoleAsync(new GetRoleRequest
        {
            RoleName = roleName,
        });

        return response.Role;
    }


    /// <summary>
    /// Get information about an IAM user.
    /// </summary>
    /// <param name="userName">The username of the user.</param>
    /// <returns>An IAM user object.</returns>
    public async Task<User> GetUserAsync(string userName)
    {
        var response = await _IAMService.GetUserAsync(new GetUserRequest { UserName = userName });
        return response.User;
    }


    /// <summary>
    /// List the IAM role policies that are attached to an IAM role.
    /// </summary>
    /// <param name="roleName">The IAM role to list IAM policies for.</param>
    /// <returns>A list of the IAM policies attached to the IAM role.</returns>
    public async Task<List<AttachedPolicyType>> ListAttachedRolePoliciesAsync(string roleName)
    {
        var attachedPolicies = new List<AttachedPolicyType>();
        var attachedRolePoliciesPaginator = _IAMService.Paginators.ListAttachedRolePolicies(new ListAttachedRolePoliciesRequest { RoleName = roleName });

        await foreach (var response in attachedRolePoliciesPaginator.Responses)
        {
            attachedPolicies.AddRange(response.AttachedPolicies);
        }

        return attachedPolicies;
    }


    /// <summary>
    /// List IAM groups.
    /// </summary>
    /// <returns>A list of IAM groups.</returns>
    public async Task<List<Group>> ListGroupsAsync()
    {
        var groupsPaginator = _IAMService.Paginators.ListGroups(new ListGroupsRequest());
        var groups = new List<Group>();

        await foreach (var response in groupsPaginator.Responses)
        {
            groups.AddRange(response.Groups);
        }

        return groups;
    }


    /// <summary>
    /// List IAM policies.
    /// </summary>
    /// <returns>A list of the IAM policies.</returns>
    public async Task<List<ManagedPolicy>> ListPoliciesAsync()
    {
        var listPoliciesPaginator = _IAMService.Paginators.ListPolicies(new ListPoliciesRequest());
        var policies = new List<ManagedPolicy>();

        await foreach (var response in listPoliciesPaginator.Responses)
        {
            policies.AddRange(response.Policies);
        }

        return policies;
    }


    /// <summary>
    /// List IAM role policies.
    /// </summary>
    /// <param name="roleName">The IAM role for which to list IAM policies.</param>
    /// <returns>A list of IAM policy names.</returns>
    public async Task<List<string>> ListRolePoliciesAsync(string roleName)
    {
        var listRolePoliciesPaginator = _IAMService.Paginators.ListRolePolicies(new ListRolePoliciesRequest { RoleName = roleName });
        var policyNames = new List<string>();

        await foreach (var response in listRolePoliciesPaginator.Responses)
        {
            policyNames.AddRange(response.PolicyNames);
        }

        return policyNames;
    }


    /// <summary>
    /// List IAM roles.
    /// </summary>
    /// <returns>A list of IAM roles.</returns>
    public async Task<List<Role>> ListRolesAsync()
    {
        var listRolesPaginator = _IAMService.Paginators.ListRoles(new ListRolesRequest());
        var roles = new List<Role>();

        await foreach (var response in listRolesPaginator.Responses)
        {
            roles.AddRange(response.Roles);
        }

        return roles;
    }


    /// <summary>
    /// List SAML authentication providers.
    /// </summary>
    /// <returns>A list of SAML providers.</returns>
    public async Task<List<SAMLProviderListEntry>> ListSAMLProvidersAsync()
    {
        var response = await _IAMService.ListSAMLProvidersAsync(new ListSAMLProvidersRequest());
        return response.SAMLProviderList;
    }


    /// <summary>
    /// List IAM users.
    /// </summary>
    /// <returns>A list of IAM users.</returns>
    public async Task<List<User>> ListUsersAsync()
    {
        var listUsersPaginator = _IAMService.Paginators.ListUsers(new ListUsersRequest());
        var users = new List<User>();

        await foreach (var response in listUsersPaginator.Responses)
        {
            users.AddRange(response.Users);
        }

        return users;
    }


    /// <summary>
    /// Update the inline policy document embedded in a role.
    /// </summary>
    /// <param name="policyName">The name of the policy to embed.</param>
    /// <param name="roleName">The name of the role to update.</param>
    /// <param name="policyDocument">The policy document that defines the role.</param>
    /// <returns>A Boolean value indicating the success of the action.</returns>
    public async Task<bool> PutRolePolicyAsync(string policyName, string roleName, string policyDocument)
    {
        var request = new PutRolePolicyRequest
        {
            PolicyName = policyName,
            RoleName = roleName,
            PolicyDocument = policyDocument
        };

        var response = await _IAMService.PutRolePolicyAsync(request);
        return response.HttpStatusCode == HttpStatusCode.OK;
    }


    /// <summary>
    /// Add or update an inline policy document that is embedded in an IAM user.
    /// </summary>
    /// <param name="userName">The name of the IAM user.</param>
    /// <param name="policyName">The name of the IAM policy.</param>
    /// <param name="policyDocument">The policy document defining the IAM policy.</param>
    /// <returns>A Boolean value indicating the success of the action.</returns>
    public async Task<bool> PutUserPolicyAsync(string userName, string policyName, string policyDocument)
    {
        var request = new PutUserPolicyRequest
        {
            UserName = userName,
            PolicyName = policyName,
            PolicyDocument = policyDocument
        };

        var response = await _IAMService.PutUserPolicyAsync(request);
        return response.HttpStatusCode == System.Net.HttpStatusCode.OK;
    }

    /// <summary>
    /// Wait for a new access key to be ready to use.
    /// </summary>
    /// <param name="accessKeyId">The Id of the access key.</param>
    /// <returns>A boolean value indicating the success of the action.</returns>
    public async Task<bool> WaitUntilAccessKeyIsReady(string accessKeyId)
    {
        var keyReady = false;

        do
        {
            try
            {
                var response = await _IAMService.GetAccessKeyLastUsedAsync(
                    new GetAccessKeyLastUsedRequest { AccessKeyId = accessKeyId });
                if (response.UserName is not null)
                {
                    keyReady = true;
                }
            }
            catch (NoSuchEntityException)
            {
                keyReady = false;
            }
        } while (!keyReady);

        return keyReady;
    }
}



using Microsoft.Extensions.Configuration;

namespace IAMBasics;

public class IAMBasics
{
    private static ILogger logger = null!;

    static async Task Main(string[] args)
    {
        // Set up dependency injection for the AWS service.
        using var host = Host.CreateDefaultBuilder(args)
            .ConfigureLogging(logging =>
                logging.AddFilter("System", LogLevel.Debug)
                    .AddFilter<DebugLoggerProvider>("Microsoft", LogLevel.Information)
                    .AddFilter<ConsoleLoggerProvider>("Microsoft", LogLevel.Trace))
            .ConfigureServices((_, services) =>
            services.AddAWSService<IAmazonIdentityManagementService>()
            .AddTransient<IAMWrapper>()
            .AddTransient<UIWrapper>()
            )
            .Build();

        logger = LoggerFactory.Create(builder => { builder.AddConsole(); })
            .CreateLogger<IAMBasics>();


        IConfiguration configuration = new ConfigurationBuilder()
            .SetBasePath(Directory.GetCurrentDirectory())
            .AddJsonFile("settings.json") // Load test settings from .json file.
            .AddJsonFile("settings.local.json",
                true) // Optionally load local settings.
            .Build();

        // Values needed for user, role, and policies.
        string userName = configuration["UserName"]!;
        string s3PolicyName = configuration["S3PolicyName"]!;
        string roleName = configuration["RoleName"]!;


        var iamWrapper = host.Services.GetRequiredService<IAMWrapper>();
        var uiWrapper = host.Services.GetRequiredService<UIWrapper>();

        uiWrapper.DisplayBasicsOverview();
        uiWrapper.PressEnter();

        // First create a user. By default, the new user has
        // no permissions.
        uiWrapper.DisplayTitle("Create User");
        Console.WriteLine($"Creating a new user with user name: {userName}.");
        var user = await iamWrapper.CreateUserAsync(userName);
        var userArn = user.Arn;

        Console.WriteLine($"Successfully created user: {userName} with ARN: {userArn}.");
        uiWrapper.WaitABit(15, "Now let's wait for the user to be ready for use.");

        // Define a role policy document that allows the new user
        // to assume the role.
        string assumeRolePolicyDocument = "{" +
          "\"Version\": \"2012-10-17\"," +
          "\"Statement\": [{" +
              "\"Effect\": \"Allow\"," +
              "\"Principal\": {" +
              $"	\"AWS\": \"{userArn}\"" +
              "}," +
              "\"Action\": \"sts:AssumeRole\"" +
          "}]" +
        "}";

        // Permissions to list all buckets.
        string policyDocument = "{" +
            "\"Version\": \"2012-10-17\"," +
            "	\"Statement\" : [{" +
                "	\"Action\" : [\"s3:ListAllMyBuckets\"]," +
                "	\"Effect\" : \"Allow\"," +
                "	\"Resource\" : \"*\"" +
            "}]" +
        "}";

        // Create an AccessKey for the user.
        uiWrapper.DisplayTitle("Create access key");
        Console.WriteLine("Now let's create an access key for the new user.");
        var accessKey = await iamWrapper.CreateAccessKeyAsync(userName);

        var accessKeyId = accessKey.AccessKeyId;
        var secretAccessKey = accessKey.SecretAccessKey;

        Console.WriteLine($"We have created the access key with Access key id: {accessKeyId}.");

        Console.WriteLine("Now let's wait until the IAM access key is ready to use.");
        var keyReady = await iamWrapper.WaitUntilAccessKeyIsReady(accessKeyId);

        // Now try listing the Amazon Simple Storage Service (Amazon S3)
        // buckets. This should fail at this point because the user doesn't
        // have permissions to perform this task.
        uiWrapper.DisplayTitle("Try to display Amazon S3 buckets");
        Console.WriteLine("Now let's try to display a list of the user's Amazon S3 buckets.");
        var s3Client1 = new AmazonS3Client(accessKeyId, secretAccessKey);
        var stsClient1 = new AmazonSecurityTokenServiceClient(accessKeyId, secretAccessKey);

        var s3Wrapper = new S3Wrapper(s3Client1, stsClient1);
        var buckets = await s3Wrapper.ListMyBucketsAsync();

        Console.WriteLine(buckets is null
            ? "As expected, the call to list the buckets has returned a null list."
            : "Something went wrong. This shouldn't have worked.");

        uiWrapper.PressEnter();

        uiWrapper.DisplayTitle("Create IAM role");
        Console.WriteLine($"Creating the role: {roleName}");

        // Creating an IAM role to allow listing the S3 buckets. A role name
        // is not case sensitive and must be unique to the account for which it
        // is created.
        var roleArn = await iamWrapper.CreateRoleAsync(roleName, assumeRolePolicyDocument);

        uiWrapper.PressEnter();

        // Create a policy with permissions to list S3 buckets.
        uiWrapper.DisplayTitle("Create IAM policy");
        Console.WriteLine($"Creating the policy: {s3PolicyName}");
        Console.WriteLine("with permissions to list the Amazon S3 buckets for the account.");
        var policy = await iamWrapper.CreatePolicyAsync(s3PolicyName, policyDocument);

        // Wait 15 seconds for the IAM policy to be available.
        uiWrapper.WaitABit(15, "Waiting for the policy to be available.");

        // Attach the policy to the role you created earlier.
        uiWrapper.DisplayTitle("Attach new IAM policy");
        Console.WriteLine("Now let's attach the policy to the role.");
        await iamWrapper.AttachRolePolicyAsync(policy.Arn, roleName);

        // Wait 15 seconds for the role to be updated.
        Console.WriteLine();
        uiWrapper.WaitABit(15, "Waiting for the policy to be attached.");

        // Use the AWS Security Token Service (AWS STS) to have the user
        // assume the role we created.
        var stsClient2 = new AmazonSecurityTokenServiceClient(accessKeyId, secretAccessKey);

        // Wait for the new credentials to become valid.
        uiWrapper.WaitABit(10, "Waiting for the credentials to be valid.");

        var assumedRoleCredentials = await s3Wrapper.AssumeS3RoleAsync("temporary-session", roleArn);

        // Try again to list the buckets using the client created with
        // the new user's credentials. This time, it should work.
        var s3Client2 = new AmazonS3Client(assumedRoleCredentials);

        s3Wrapper.UpdateClients(s3Client2, stsClient2);

        buckets = await s3Wrapper.ListMyBucketsAsync();

        uiWrapper.DisplayTitle("List Amazon S3 buckets");
        Console.WriteLine("This time we should have buckets to list.");
        if (buckets is not null)
        {
            buckets.ForEach(bucket =>
            {
                Console.WriteLine($"{bucket.BucketName} created: {bucket.CreationDate}");
            });
        }

        uiWrapper.PressEnter();

        // Now clean up all the resources used in the example.
        uiWrapper.DisplayTitle("Clean up resources");
        Console.WriteLine("Thank you for watching. The IAM Basics demo is complete.");
        Console.WriteLine("Please wait while we clean up the resources we created.");

        await iamWrapper.DetachRolePolicyAsync(policy.Arn, roleName);

        await iamWrapper.DeletePolicyAsync(policy.Arn);

        await iamWrapper.DeleteRoleAsync(roleName);

        await iamWrapper.DeleteAccessKeyAsync(accessKeyId, userName);

        await iamWrapper.DeleteUserAsync(userName);

        uiWrapper.PressEnter();

        Console.WriteLine("All done cleaning up our resources. Thank you for your patience.");
    }
}


namespace IamScenariosCommon;

using System.Net;

/// <summary>
/// A class to perform Amazon Simple Storage Service (Amazon S3) actions for
/// the IAM Basics scenario.
/// </summary>
public class S3Wrapper
{
    private IAmazonS3 _s3Service;
    private IAmazonSecurityTokenService _stsService;

    /// <summary>
    /// Constructor for the S3Wrapper class.
    /// </summary>
    /// <param name="s3Service">An Amazon S3 client object.</param>
    /// <param name="stsService">An AWS Security Token Service (AWS STS)
    /// client object.</param>
    public S3Wrapper(IAmazonS3 s3Service, IAmazonSecurityTokenService stsService)
    {
        _s3Service = s3Service;
        _stsService = stsService;
    }

    /// <summary>
    /// Assumes an AWS Identity and Access Management (IAM) role that allows
    /// Amazon S3 access for the current session.
    /// </summary>
    /// <param name="roleSession">A string representing the current session.</param>
    /// <param name="roleToAssume">The name of the IAM role to assume.</param>
    /// <returns>Credentials for the newly assumed IAM role.</returns>
    public async Task<Credentials> AssumeS3RoleAsync(string roleSession, string roleToAssume)
    {
        // Create the request to use with the AssumeRoleAsync call.
        var request = new AssumeRoleRequest()
        {
            RoleSessionName = roleSession,
            RoleArn = roleToAssume,
        };

        var response = await _stsService.AssumeRoleAsync(request);

        return response.Credentials;
    }


    /// <summary>
    /// Delete an S3 bucket.
    /// </summary>
    /// <param name="bucketName">Name of the S3 bucket to delete.</param>
    /// <returns>A Boolean value indicating the success of the action.</returns>
    public async Task<bool> DeleteBucketAsync(string bucketName)
    {
        var result = await _s3Service.DeleteBucketAsync(new DeleteBucketRequest { BucketName = bucketName });
        return result.HttpStatusCode == HttpStatusCode.OK;
    }

    /// <summary>
    /// List the buckets that are owned by the user's account.
    /// </summary>
    /// <returns>Async Task.</returns>
    public async Task<List<S3Bucket>?> ListMyBucketsAsync()
    {
        try
        {
            // Get the list of buckets accessible by the new user.
            var response = await _s3Service.ListBucketsAsync();

            return response.Buckets;
        }
        catch (AmazonS3Exception ex)
        {
            // Something else went wrong. Display the error message.
            Console.WriteLine($"Error: {ex.Message}");
            return null;
        }
    }

    /// <summary>
    /// Create a new S3 bucket.
    /// </summary>
    /// <param name="bucketName">The name for the new bucket.</param>
    /// <returns>A Boolean value indicating whether the action completed
    /// successfully.</returns>
    public async Task<bool> PutBucketAsync(string bucketName)
    {
        var response = await _s3Service.PutBucketAsync(new PutBucketRequest { BucketName = bucketName });
        return response.HttpStatusCode == HttpStatusCode.OK;
    }

    /// <summary>
    /// Update the client objects with new client objects. This is available
    /// because the scenario uses the methods of this class without and then
    /// with the proper permissions to list S3 buckets.
    /// </summary>
    /// <param name="s3Service">The Amazon S3 client object.</param>
    /// <param name="stsService">The AWS STS client object.</param>
    public void UpdateClients(IAmazonS3 s3Service, IAmazonSecurityTokenService stsService)
    {
        _s3Service = s3Service;
        _stsService = stsService;
    }
}


namespace IamScenariosCommon;

public class UIWrapper
{
    public readonly string SepBar = new('-', Console.WindowWidth);

    /// <summary>
    /// Show information about the IAM Groups scenario.
    /// </summary>
    public void DisplayGroupsOverview()
    {
        Console.Clear();

        DisplayTitle("Welcome to the IAM Groups Demo");
        Console.WriteLine("This example application does the following:");
        Console.WriteLine("\t1. Creates an Amazon Identity and Access Management (IAM) group.");
        Console.WriteLine("\t2. Adds an IAM policy to the IAM group giving it full access to Amazon S3.");
        Console.WriteLine("\t3. Creates a new IAM user.");
        Console.WriteLine("\t4. Creates an IAM access key for the user.");
        Console.WriteLine("\t5. Adds the user to the IAM group.");
        Console.WriteLine("\t6. Lists the buckets on the account.");
        Console.WriteLine("\t7. Proves that the user has full Amazon S3 access by creating a bucket.");
        Console.WriteLine("\t8. List the buckets again to show the new bucket.");
        Console.WriteLine("\t9. Cleans up all the resources created.");
    }

    /// <summary>
    /// Show information about the IAM Basics scenario.
    /// </summary>
    public void DisplayBasicsOverview()
    {
        Console.Clear();

        DisplayTitle("Welcome to IAM Basics");
        Console.WriteLine("This example application does the following:");
        Console.WriteLine("\t1. Creates a user with no permissions.");
        Console.WriteLine("\t2. Creates a role and policy that grant s3:ListAllMyBuckets permission.");
        Console.WriteLine("\t3. Grants the user permission to assume the role.");
        Console.WriteLine("\t4. Creates an S3 client object as the user and tries to list buckets (this will fail).");
        Console.WriteLine("\t5. Gets temporary credentials by assuming the role.");
        Console.WriteLine("\t6. Creates a new S3 client object with the temporary credentials and lists the buckets (this will succeed).");
        Console.WriteLine("\t7. Deletes all the resources.");
    }

    /// <summary>
    /// Display a message and wait until the user presses enter.
    /// </summary>
    public void PressEnter()
    {
        Console.Write("\nPress <Enter> to continue. ");
        _ = Console.ReadLine();
        Console.WriteLine();
    }

    /// <summary>
    /// Pad a string with spaces to center it on the console display.
    /// </summary>
    /// <param name="strToCenter">The string to be centered.</param>
    /// <returns>The padded string.</returns>
    public string CenterString(string strToCenter)
    {
        var padAmount = (Console.WindowWidth - strToCenter.Length) / 2;
        var leftPad = new string(' ', padAmount);
        return $"{leftPad}{strToCenter}";
    }

    /// <summary>
    /// Display a line of hyphens, the centered text of the title, and another
    /// line of hyphens.
    /// </summary>
    /// <param name="strTitle">The string to be displayed.</param>
    public void DisplayTitle(string strTitle)
    {
        Console.WriteLine(SepBar);
        Console.WriteLine(CenterString(strTitle));
        Console.WriteLine(SepBar);
    }

    /// <summary>
    /// Display a countdown and wait for a number of seconds.
    /// </summary>
    /// <param name="numSeconds">The number of seconds to wait.</param>
    public void WaitABit(int numSeconds, string msg)
    {
        Console.WriteLine(msg);

        // Wait for the requested number of seconds.
        for (int i = numSeconds; i > 0; i--)
        {
            System.Threading.Thread.Sleep(1000);
            Console.Write($"{i}...");
        }

        PressEnter();
    }
}
```
+ Per informazioni dettagliate sull'API, consulta i seguenti argomenti nella *documentazione di riferimento dell’API AWS SDK per .NET *.
  + [AttachRolePolicy](https://docs.aws.amazon.com/goto/DotNetSDKV3/iam-2010-05-08/AttachRolePolicy)
  + [CreateAccessKey](https://docs.aws.amazon.com/goto/DotNetSDKV3/iam-2010-05-08/CreateAccessKey)
  + [CreatePolicy](https://docs.aws.amazon.com/goto/DotNetSDKV3/iam-2010-05-08/CreatePolicy)
  + [CreateRole](https://docs.aws.amazon.com/goto/DotNetSDKV3/iam-2010-05-08/CreateRole)
  + [CreateUser](https://docs.aws.amazon.com/goto/DotNetSDKV3/iam-2010-05-08/CreateUser)
  + [DeleteAccessKey](https://docs.aws.amazon.com/goto/DotNetSDKV3/iam-2010-05-08/DeleteAccessKey)
  + [DeletePolicy](https://docs.aws.amazon.com/goto/DotNetSDKV3/iam-2010-05-08/DeletePolicy)
  + [DeleteRole](https://docs.aws.amazon.com/goto/DotNetSDKV3/iam-2010-05-08/DeleteRole)
  + [DeleteUser](https://docs.aws.amazon.com/goto/DotNetSDKV3/iam-2010-05-08/DeleteUser)
  + [DeleteUserPolicy](https://docs.aws.amazon.com/goto/DotNetSDKV3/iam-2010-05-08/DeleteUserPolicy)
  + [DetachRolePolicy](https://docs.aws.amazon.com/goto/DotNetSDKV3/iam-2010-05-08/DetachRolePolicy)
  + [PutUserPolicy](https://docs.aws.amazon.com/goto/DotNetSDKV3/iam-2010-05-08/PutUserPolicy)

------
#### [ Bash ]

**AWS CLI con lo script Bash**  
 C'è altro da fare. GitHub Trova l'esempio completo e scopri di più sulla configurazione e l'esecuzione nel [Repository di esempi di codice AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/aws-cli/bash-linux/iam#code-examples). 

```
###############################################################################
# function iam_create_user_assume_role
#
# Scenario to create an IAM user, create an IAM role, and apply the role to the user.
#
#     "IAM access" permissions are needed to run this code.
#     "STS assume role" permissions are needed to run this code. (Note: It might be necessary to
#           create a custom policy).
#
# Returns:
#       0 - If successful.
#       1 - If an error occurred.
###############################################################################
function iam_create_user_assume_role() {
  {
    if [ "$IAM_OPERATIONS_SOURCED" != "True" ]; then

      source ./iam_operations.sh
    fi
  }

  echo_repeat "*" 88
  echo "Welcome to the IAM create user and assume role demo."
  echo
  echo "This demo will create an IAM user, create an IAM role, and apply the role to the user."
  echo_repeat "*" 88
  echo

  echo -n "Enter a name for a new IAM user: "
  get_input
  user_name=$get_input_result

  local user_arn
  user_arn=$(iam_create_user -u "$user_name")

  # shellcheck disable=SC2181
  if [[ ${?} == 0 ]]; then
    echo "Created demo IAM user named $user_name"
  else
    errecho "$user_arn"
    errecho "The user failed to create. This demo will exit."
    return 1
  fi

  local access_key_response
  access_key_response=$(iam_create_user_access_key -u "$user_name")
  # shellcheck disable=SC2181
  if [[ ${?} != 0 ]]; then
    errecho "The access key failed to create. This demo will exit."
    clean_up "$user_name"
    return 1
  fi

  IFS=$'\t ' read -r -a access_key_values <<<"$access_key_response"
  local key_name=${access_key_values[0]}
  local key_secret=${access_key_values[1]}

  echo "Created access key named $key_name"

  echo "Wait 10 seconds for the user to be ready."
  sleep 10
  echo_repeat "*" 88
  echo

  local iam_role_name
  iam_role_name=$(generate_random_name "test-role")
  echo "Creating a role named $iam_role_name with user $user_name as the principal."

  local assume_role_policy_document="{
    \"Version\": \"2012-10-17\",
    \"Statement\": [{
        \"Effect\": \"Allow\",
        \"Principal\": {\"AWS\": \"$user_arn\"},
        \"Action\": \"sts:AssumeRole\"
        }]
    }"

  local role_arn
  role_arn=$(iam_create_role -n "$iam_role_name" -p "$assume_role_policy_document")

  # shellcheck disable=SC2181
  if [ ${?} == 0 ]; then
    echo "Created IAM role named $iam_role_name"
  else
    errecho "The role failed to create. This demo will exit."
    clean_up "$user_name" "$key_name"
    return 1
  fi

  local policy_name
  policy_name=$(generate_random_name "test-policy")
  local policy_document="{
                \"Version\": \"2012-10-17\",
                \"Statement\": [{
                    \"Effect\": \"Allow\",
                    \"Action\": \"s3:ListAllMyBuckets\",
                    \"Resource\": \"arn:aws:s3:::*\"}]}"

  local policy_arn
  policy_arn=$(iam_create_policy -n "$policy_name" -p "$policy_document")
  # shellcheck disable=SC2181
  if [[ ${?} == 0 ]]; then
    echo "Created  IAM policy named $policy_name"
  else
    errecho "The policy failed to create."
    clean_up "$user_name" "$key_name" "$iam_role_name"
    return 1
  fi

  if (iam_attach_role_policy -n "$iam_role_name" -p "$policy_arn"); then
    echo "Attached policy $policy_arn to role $iam_role_name"
  else
    errecho "The policy failed to attach."
    clean_up "$user_name" "$key_name" "$iam_role_name" "$policy_arn"
    return 1
  fi

  local assume_role_policy_document="{
                \"Version\": \"2012-10-17\",
                \"Statement\": [{
                    \"Effect\": \"Allow\",
                    \"Action\": \"sts:AssumeRole\",
                    \"Resource\": \"$role_arn\"}]}"

  local assume_role_policy_name
  assume_role_policy_name=$(generate_random_name "test-assume-role-")

  # shellcheck disable=SC2181
  local assume_role_policy_arn
  assume_role_policy_arn=$(iam_create_policy -n "$assume_role_policy_name" -p "$assume_role_policy_document")
  # shellcheck disable=SC2181
  if [ ${?} == 0 ]; then
    echo "Created  IAM policy named $assume_role_policy_name for sts assume role"
  else
    errecho "The policy failed to create."
    clean_up "$user_name" "$key_name" "$iam_role_name" "$policy_arn" "$policy_arn"
    return 1
  fi

  echo "Wait 10 seconds to give AWS time to propagate these new resources and connections."
  sleep 10
  echo_repeat "*" 88
  echo

  echo "Try to list buckets without the new user assuming the role."
  echo_repeat "*" 88
  echo

  # Set the environment variables for the created user.
  # bashsupport disable=BP2001
  export AWS_ACCESS_KEY_ID=$key_name
  # bashsupport disable=BP2001
  export AWS_SECRET_ACCESS_KEY=$key_secret

  local buckets
  buckets=$(s3_list_buckets)

  # shellcheck disable=SC2181
  if [ ${?} == 0 ]; then
    local bucket_count
    bucket_count=$(echo "$buckets" | wc -w | xargs)
    echo "There are $bucket_count buckets in the account. This should not have happened."
  else
    errecho "Because the role with permissions has not been assumed, listing buckets failed."
  fi

  echo
  echo_repeat "*" 88
  echo "Now assume the role $iam_role_name and list the buckets."
  echo_repeat "*" 88
  echo

  local credentials

  credentials=$(sts_assume_role -r "$role_arn" -n "AssumeRoleDemoSession")
  # shellcheck disable=SC2181
  if [ ${?} == 0 ]; then
    echo "Assumed role $iam_role_name"
  else
    errecho "Failed to assume role."
    export AWS_ACCESS_KEY_ID=""
    export AWS_SECRET_ACCESS_KEY=""
    clean_up "$user_name" "$key_name" "$iam_role_name" "$policy_arn" "$policy_arn" "$assume_role_policy_arn"
    return 1
  fi

  IFS=$'\t ' read -r -a credentials <<<"$credentials"

  export AWS_ACCESS_KEY_ID=${credentials[0]}
  export AWS_SECRET_ACCESS_KEY=${credentials[1]}
  # bashsupport disable=BP2001
  export AWS_SESSION_TOKEN=${credentials[2]}

  buckets=$(s3_list_buckets)

  # shellcheck disable=SC2181
  if [ ${?} == 0 ]; then
    local bucket_count
    bucket_count=$(echo "$buckets" | wc -w | xargs)
    echo "There are $bucket_count buckets in the account. Listing buckets succeeded because of "
    echo "the assumed role."
  else
    errecho "Failed to list buckets. This should not happen."
    export AWS_ACCESS_KEY_ID=""
    export AWS_SECRET_ACCESS_KEY=""
    export AWS_SESSION_TOKEN=""
    clean_up "$user_name" "$key_name" "$iam_role_name" "$policy_arn" "$policy_arn" "$assume_role_policy_arn"
    return 1
  fi

  local result=0
  export AWS_ACCESS_KEY_ID=""
  export AWS_SECRET_ACCESS_KEY=""

  echo
  echo_repeat "*" 88
  echo "The created resources will now be deleted."
  echo_repeat "*" 88
  echo

  clean_up "$user_name" "$key_name" "$iam_role_name" "$policy_arn" "$policy_arn" "$assume_role_policy_arn"

  # shellcheck disable=SC2181
  if [[ ${?} -ne 0 ]]; then
    result=1
  fi

  return $result
}
```
Le funzioni IAM utilizzate in questo scenario.  

```
###############################################################################
# function iam_user_exists
#
# This function checks to see if the specified AWS Identity and Access Management (IAM) user already exists.
#
# Parameters:
#       $1 - The name of the IAM user to check.
#
# Returns:
#       0 - If the user already exists.
#       1 - If the user doesn't exist.
###############################################################################
function iam_user_exists() {
  local user_name
  user_name=$1

  # Check whether the IAM user already exists.
  # We suppress all output - we're interested only in the return code.

  local errors
  errors=$(aws iam get-user \
    --user-name "$user_name" 2>&1 >/dev/null)

  local error_code=${?}

  if [[ $error_code -eq 0 ]]; then
    return 0 # 0 in Bash script means true.
  else
    if [[ $errors != *"error"*"(NoSuchEntity)"* ]]; then
      aws_cli_error_log $error_code
      errecho "Error calling iam get-user $errors"
    fi

    return 1 # 1 in Bash script means false.
  fi
}

###############################################################################
# function iam_create_user
#
# This function creates the specified IAM user, unless
# it already exists.
#
# Parameters:
#       -u user_name  -- The name of the user to create.
#
# Returns:
#       The ARN of the user.
#     And:
#       0 - If successful.
#       1 - If it fails.
###############################################################################
function iam_create_user() {
  local user_name response
  local option OPTARG # Required to use getopts command in a function.

  # bashsupport disable=BP5008
  function usage() {
    echo "function iam_create_user"
    echo "Creates an AWS Identity and Access Management (IAM) user. You must supply a username:"
    echo "  -u user_name    The name of the user. It must be unique within the account."
    echo ""
  }

  # Retrieve the calling parameters.
  while getopts "u:h" option; do
    case "${option}" in
      u) user_name="${OPTARG}" ;;
      h)
        usage
        return 0
        ;;
      \?)
        echo "Invalid parameter"
        usage
        return 1
        ;;
    esac
  done
  export OPTIND=1

  if [[ -z "$user_name" ]]; then
    errecho "ERROR: You must provide a username with the -u parameter."
    usage
    return 1
  fi

  iecho "Parameters:\n"
  iecho "    User name:   $user_name"
  iecho ""

  # If the user already exists, we don't want to try to create it.
  if (iam_user_exists "$user_name"); then
    errecho "ERROR: A user with that name already exists in the account."
    return 1
  fi

  response=$(aws iam create-user --user-name "$user_name" \
    --output text \
    --query 'User.Arn')

  local error_code=${?}

  if [[ $error_code -ne 0 ]]; then
    aws_cli_error_log $error_code
    errecho "ERROR: AWS reports create-user operation failed.$response"
    return 1
  fi

  echo "$response"

  return 0
}

###############################################################################
# function iam_create_user_access_key
#
# This function creates an IAM access key for the specified user.
#
# Parameters:
#       -u user_name -- The name of the IAM user.
#       [-f file_name] -- The optional file name for the access key output.
#
# Returns:
#       [access_key_id access_key_secret]
#     And:
#       0 - If successful.
#       1 - If it fails.
###############################################################################
function iam_create_user_access_key() {
  local user_name file_name response
  local option OPTARG # Required to use getopts command in a function.

  # bashsupport disable=BP5008
  function usage() {
    echo "function iam_create_user_access_key"
    echo "Creates an AWS Identity and Access Management (IAM) key pair."
    echo "  -u user_name   The name of the IAM user."
    echo "  [-f file_name]   Optional file name for the access key output."
    echo ""
  }

  # Retrieve the calling parameters.
  while getopts "u:f:h" option; do
    case "${option}" in
      u) user_name="${OPTARG}" ;;
      f) file_name="${OPTARG}" ;;
      h)
        usage
        return 0
        ;;
      \?)
        echo "Invalid parameter"
        usage
        return 1
        ;;
    esac
  done
  export OPTIND=1

  if [[ -z "$user_name" ]]; then
    errecho "ERROR: You must provide a username with the -u parameter."
    usage
    return 1
  fi

  response=$(aws iam create-access-key \
    --user-name "$user_name" \
    --output text)

  local error_code=${?}

  if [[ $error_code -ne 0 ]]; then
    aws_cli_error_log $error_code
    errecho "ERROR: AWS reports create-access-key operation failed.$response"
    return 1
  fi

  if [[ -n "$file_name" ]]; then
    echo "$response" >"$file_name"
  fi

  local key_id key_secret
  # shellcheck disable=SC2086
  key_id=$(echo $response | cut -f 2 -d ' ')
  # shellcheck disable=SC2086
  key_secret=$(echo $response | cut -f 4 -d ' ')

  echo "$key_id $key_secret"

  return 0
}

###############################################################################
# function iam_create_role
#
# This function creates an IAM role.
#
# Parameters:
#       -n role_name -- The name of the IAM role.
#       -p policy_json -- The assume role policy document.
#
# Returns:
#       The ARN of the role.
#     And:
#       0 - If successful.
#       1 - If it fails.
###############################################################################
function iam_create_role() {
  local role_name policy_document response
  local option OPTARG # Required to use getopts command in a function.

  # bashsupport disable=BP5008
  function usage() {
    echo "function iam_create_user_access_key"
    echo "Creates an AWS Identity and Access Management (IAM) role."
    echo "  -n role_name   The name of the IAM role."
    echo "  -p policy_json -- The assume role policy document."
    echo ""
  }

  # Retrieve the calling parameters.
  while getopts "n:p:h" option; do
    case "${option}" in
      n) role_name="${OPTARG}" ;;
      p) policy_document="${OPTARG}" ;;
      h)
        usage
        return 0
        ;;
      \?)
        echo "Invalid parameter"
        usage
        return 1
        ;;
    esac
  done
  export OPTIND=1

  if [[ -z "$role_name" ]]; then
    errecho "ERROR: You must provide a role name with the -n parameter."
    usage
    return 1
  fi

  if [[ -z "$policy_document" ]]; then
    errecho "ERROR: You must provide a policy document with the -p parameter."
    usage
    return 1
  fi

  response=$(aws iam create-role \
    --role-name "$role_name" \
    --assume-role-policy-document "$policy_document" \
    --output text \
    --query Role.Arn)

  local error_code=${?}

  if [[ $error_code -ne 0 ]]; then
    aws_cli_error_log $error_code
    errecho "ERROR: AWS reports create-role operation failed.\n$response"
    return 1
  fi

  echo "$response"

  return 0
}

###############################################################################
# function iam_create_policy
#
# This function creates an IAM policy.
#
# Parameters:
#       -n policy_name -- The name of the IAM policy.
#       -p policy_json -- The policy document.
#
# Returns:
#       0 - If successful.
#       1 - If it fails.
###############################################################################
function iam_create_policy() {
  local policy_name policy_document response
  local option OPTARG # Required to use getopts command in a function.

  # bashsupport disable=BP5008
  function usage() {
    echo "function iam_create_policy"
    echo "Creates an AWS Identity and Access Management (IAM) policy."
    echo "  -n policy_name   The name of the IAM policy."
    echo "  -p policy_json -- The policy document."
    echo ""
  }

  # Retrieve the calling parameters.
  while getopts "n:p:h" option; do
    case "${option}" in
      n) policy_name="${OPTARG}" ;;
      p) policy_document="${OPTARG}" ;;
      h)
        usage
        return 0
        ;;
      \?)
        echo "Invalid parameter"
        usage
        return 1
        ;;
    esac
  done
  export OPTIND=1

  if [[ -z "$policy_name" ]]; then
    errecho "ERROR: You must provide a policy name with the -n parameter."
    usage
    return 1
  fi

  if [[ -z "$policy_document" ]]; then
    errecho "ERROR: You must provide a policy document with the -p parameter."
    usage
    return 1
  fi

  response=$(aws iam create-policy \
    --policy-name "$policy_name" \
    --policy-document "$policy_document" \
    --output text \
    --query Policy.Arn)

  local error_code=${?}

  if [[ $error_code -ne 0 ]]; then
    aws_cli_error_log $error_code
    errecho "ERROR: AWS reports create-policy operation failed.\n$response"
    return 1
  fi

  echo "$response"
}

###############################################################################
# function iam_attach_role_policy
#
# This function attaches an IAM policy to a tole.
#
# Parameters:
#       -n role_name -- The name of the IAM role.
#       -p policy_ARN -- The IAM policy document ARN..
#
# Returns:
#       0 - If successful.
#       1 - If it fails.
###############################################################################
function iam_attach_role_policy() {
  local role_name policy_arn response
  local option OPTARG # Required to use getopts command in a function.

  # bashsupport disable=BP5008
  function usage() {
    echo "function iam_attach_role_policy"
    echo "Attaches an AWS Identity and Access Management (IAM) policy to an IAM role."
    echo "  -n role_name   The name of the IAM role."
    echo "  -p policy_ARN -- The IAM policy document ARN."
    echo ""
  }

  # Retrieve the calling parameters.
  while getopts "n:p:h" option; do
    case "${option}" in
      n) role_name="${OPTARG}" ;;
      p) policy_arn="${OPTARG}" ;;
      h)
        usage
        return 0
        ;;
      \?)
        echo "Invalid parameter"
        usage
        return 1
        ;;
    esac
  done
  export OPTIND=1

  if [[ -z "$role_name" ]]; then
    errecho "ERROR: You must provide a role name with the -n parameter."
    usage
    return 1
  fi

  if [[ -z "$policy_arn" ]]; then
    errecho "ERROR: You must provide a policy ARN with the -p parameter."
    usage
    return 1
  fi

  response=$(aws iam attach-role-policy \
    --role-name "$role_name" \
    --policy-arn "$policy_arn")

  local error_code=${?}

  if [[ $error_code -ne 0 ]]; then
    aws_cli_error_log $error_code
    errecho "ERROR: AWS reports attach-role-policy operation failed.\n$response"
    return 1
  fi

  echo "$response"

  return 0
}

###############################################################################
# function iam_detach_role_policy
#
# This function detaches an IAM policy to a tole.
#
# Parameters:
#       -n role_name -- The name of the IAM role.
#       -p policy_ARN -- The IAM policy document ARN..
#
# Returns:
#       0 - If successful.
#       1 - If it fails.
###############################################################################
function iam_detach_role_policy() {
  local role_name policy_arn response
  local option OPTARG # Required to use getopts command in a function.

  # bashsupport disable=BP5008
  function usage() {
    echo "function iam_detach_role_policy"
    echo "Detaches an AWS Identity and Access Management (IAM) policy to an IAM role."
    echo "  -n role_name   The name of the IAM role."
    echo "  -p policy_ARN -- The IAM policy document ARN."
    echo ""
  }

  # Retrieve the calling parameters.
  while getopts "n:p:h" option; do
    case "${option}" in
      n) role_name="${OPTARG}" ;;
      p) policy_arn="${OPTARG}" ;;
      h)
        usage
        return 0
        ;;
      \?)
        echo "Invalid parameter"
        usage
        return 1
        ;;
    esac
  done
  export OPTIND=1

  if [[ -z "$role_name" ]]; then
    errecho "ERROR: You must provide a role name with the -n parameter."
    usage
    return 1
  fi

  if [[ -z "$policy_arn" ]]; then
    errecho "ERROR: You must provide a policy ARN with the -p parameter."
    usage
    return 1
  fi

  response=$(aws iam detach-role-policy \
    --role-name "$role_name" \
    --policy-arn "$policy_arn")

  local error_code=${?}

  if [[ $error_code -ne 0 ]]; then
    aws_cli_error_log $error_code
    errecho "ERROR: AWS reports detach-role-policy operation failed.\n$response"
    return 1
  fi

  echo "$response"

  return 0
}

###############################################################################
# function iam_delete_policy
#
# This function deletes an IAM policy.
#
# Parameters:
#       -n policy_arn -- The name of the IAM policy arn.
#
# Returns:
#       0 - If successful.
#       1 - If it fails.
###############################################################################
function iam_delete_policy() {
  local policy_arn response
  local option OPTARG # Required to use getopts command in a function.

  # bashsupport disable=BP5008
  function usage() {
    echo "function iam_delete_policy"
    echo "Deletes an AWS Identity and Access Management (IAM) policy"
    echo "  -n policy_arn -- The name of the IAM policy arn."
    echo ""
  }

  # Retrieve the calling parameters.
  while getopts "n:h" option; do
    case "${option}" in
      n) policy_arn="${OPTARG}" ;;
      h)
        usage
        return 0
        ;;
      \?)
        echo "Invalid parameter"
        usage
        return 1
        ;;
    esac
  done
  export OPTIND=1

  if [[ -z "$policy_arn" ]]; then
    errecho "ERROR: You must provide a policy arn with the -n parameter."
    usage
    return 1
  fi

  iecho "Parameters:\n"
  iecho "    Policy arn:  $policy_arn"
  iecho ""

  response=$(aws iam delete-policy \
    --policy-arn "$policy_arn")

  local error_code=${?}

  if [[ $error_code -ne 0 ]]; then
    aws_cli_error_log $error_code
    errecho "ERROR: AWS reports delete-policy operation failed.\n$response"
    return 1
  fi

  iecho "delete-policy response:$response"
  iecho

  return 0
}

###############################################################################
# function iam_delete_role
#
# This function deletes an IAM role.
#
# Parameters:
#       -n role_name -- The name of the IAM role.
#
# Returns:
#       0 - If successful.
#       1 - If it fails.
###############################################################################
function iam_delete_role() {
  local role_name response
  local option OPTARG # Required to use getopts command in a function.

  # bashsupport disable=BP5008
  function usage() {
    echo "function iam_delete_role"
    echo "Deletes an AWS Identity and Access Management (IAM) role"
    echo "  -n role_name -- The name of the IAM role."
    echo ""
  }

  # Retrieve the calling parameters.
  while getopts "n:h" option; do
    case "${option}" in
      n) role_name="${OPTARG}" ;;
      h)
        usage
        return 0
        ;;
      \?)
        echo "Invalid parameter"
        usage
        return 1
        ;;
    esac
  done
  export OPTIND=1

  echo "role_name:$role_name"
  if [[ -z "$role_name" ]]; then
    errecho "ERROR: You must provide a role name with the -n parameter."
    usage
    return 1
  fi

  iecho "Parameters:\n"
  iecho "    Role name:  $role_name"
  iecho ""

  response=$(aws iam delete-role \
    --role-name "$role_name")

  local error_code=${?}

  if [[ $error_code -ne 0 ]]; then
    aws_cli_error_log $error_code
    errecho "ERROR: AWS reports delete-role operation failed.\n$response"
    return 1
  fi

  iecho "delete-role response:$response"
  iecho

  return 0
}

###############################################################################
# function iam_delete_access_key
#
# This function deletes an IAM access key for the specified IAM user.
#
# Parameters:
#       -u user_name  -- The name of the user.
#       -k access_key -- The access key to delete.
#
# Returns:
#       0 - If successful.
#       1 - If it fails.
###############################################################################
function iam_delete_access_key() {
  local user_name access_key response
  local option OPTARG # Required to use getopts command in a function.

  # bashsupport disable=BP5008
  function usage() {
    echo "function iam_delete_access_key"
    echo "Deletes an AWS Identity and Access Management (IAM) access key for the specified IAM user"
    echo "  -u user_name    The name of the user."
    echo "  -k access_key   The access key to delete."
    echo ""
  }

  # Retrieve the calling parameters.
  while getopts "u:k:h" option; do
    case "${option}" in
      u) user_name="${OPTARG}" ;;
      k) access_key="${OPTARG}" ;;
      h)
        usage
        return 0
        ;;
      \?)
        echo "Invalid parameter"
        usage
        return 1
        ;;
    esac
  done
  export OPTIND=1

  if [[ -z "$user_name" ]]; then
    errecho "ERROR: You must provide a username with the -u parameter."
    usage
    return 1
  fi

  if [[ -z "$access_key" ]]; then
    errecho "ERROR: You must provide an access key with the -k parameter."
    usage
    return 1
  fi

  iecho "Parameters:\n"
  iecho "    Username:   $user_name"
  iecho "    Access key:   $access_key"
  iecho ""

  response=$(aws iam delete-access-key \
    --user-name "$user_name" \
    --access-key-id "$access_key")

  local error_code=${?}

  if [[ $error_code -ne 0 ]]; then
    aws_cli_error_log $error_code
    errecho "ERROR: AWS reports delete-access-key operation failed.\n$response"
    return 1
  fi

  iecho "delete-access-key response:$response"
  iecho

  return 0
}

###############################################################################
# function iam_delete_user
#
# This function deletes the specified IAM user.
#
# Parameters:
#       -u user_name  -- The name of the user to create.
#
# Returns:
#       0 - If successful.
#       1 - If it fails.
###############################################################################
function iam_delete_user() {
  local user_name response
  local option OPTARG # Required to use getopts command in a function.

  # bashsupport disable=BP5008
  function usage() {
    echo "function iam_delete_user"
    echo "Deletes an AWS Identity and Access Management (IAM) user. You must supply a username:"
    echo "  -u user_name    The name of the user."
    echo ""
  }

  # Retrieve the calling parameters.
  while getopts "u:h" option; do
    case "${option}" in
      u) user_name="${OPTARG}" ;;
      h)
        usage
        return 0
        ;;
      \?)
        echo "Invalid parameter"
        usage
        return 1
        ;;
    esac
  done
  export OPTIND=1

  if [[ -z "$user_name" ]]; then
    errecho "ERROR: You must provide a username with the -u parameter."
    usage
    return 1
  fi

  iecho "Parameters:\n"
  iecho "    User name:   $user_name"
  iecho ""

  # If the user does not exist, we don't want to try to delete it.
  if (! iam_user_exists "$user_name"); then
    errecho "ERROR: A user with that name does not exist in the account."
    return 1
  fi

  response=$(aws iam delete-user \
    --user-name "$user_name")

  local error_code=${?}

  if [[ $error_code -ne 0 ]]; then
    aws_cli_error_log $error_code
    errecho "ERROR: AWS reports delete-user operation failed.$response"
    return 1
  fi

  iecho "delete-user response:$response"
  iecho

  return 0
}
```
+ Per informazioni dettagliate sull’API, consulta i seguenti argomenti nella *documentazione di riferimento dei comandi della AWS CLI *.
  + [AttachRolePolicy](https://docs.aws.amazon.com/goto/aws-cli/iam-2010-05-08/AttachRolePolicy)
  + [CreateAccessKey](https://docs.aws.amazon.com/goto/aws-cli/iam-2010-05-08/CreateAccessKey)
  + [CreatePolicy](https://docs.aws.amazon.com/goto/aws-cli/iam-2010-05-08/CreatePolicy)
  + [CreateRole](https://docs.aws.amazon.com/goto/aws-cli/iam-2010-05-08/CreateRole)
  + [CreateUser](https://docs.aws.amazon.com/goto/aws-cli/iam-2010-05-08/CreateUser)
  + [DeleteAccessKey](https://docs.aws.amazon.com/goto/aws-cli/iam-2010-05-08/DeleteAccessKey)
  + [DeletePolicy](https://docs.aws.amazon.com/goto/aws-cli/iam-2010-05-08/DeletePolicy)
  + [DeleteRole](https://docs.aws.amazon.com/goto/aws-cli/iam-2010-05-08/DeleteRole)
  + [DeleteUser](https://docs.aws.amazon.com/goto/aws-cli/iam-2010-05-08/DeleteUser)
  + [DeleteUserPolicy](https://docs.aws.amazon.com/goto/aws-cli/iam-2010-05-08/DeleteUserPolicy)
  + [DetachRolePolicy](https://docs.aws.amazon.com/goto/aws-cli/iam-2010-05-08/DetachRolePolicy)
  + [PutUserPolicy](https://docs.aws.amazon.com/goto/aws-cli/iam-2010-05-08/PutUserPolicy)

------
#### [ C\$1\$1 ]

**SDK per C\$1\$1**  
 C'è dell'altro GitHub. Trova l'esempio completo e scopri di più sulla configurazione e l'esecuzione nel [Repository di esempi di codice AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/cpp/example_code/iam#code-examples). 

```
namespace AwsDoc {
    namespace IAM {
  
        //! Cleanup by deleting created entities.
        /*!
          \sa DeleteCreatedEntities
          \param client: IAM client.
          \param role: IAM role.
          \param user: IAM user.
          \param policy: IAM policy.
        */
        static bool DeleteCreatedEntities(const Aws::IAM::IAMClient &client,
                                          const Aws::IAM::Model::Role &role,
                                          const Aws::IAM::Model::User &user,
                                          const Aws::IAM::Model::Policy &policy);
    }

    static const int LIST_BUCKETS_WAIT_SEC = 20;

    static const char ALLOCATION_TAG[] = "example_code";
}

//! Scenario to create an IAM user, create an IAM role, and apply the role to the user.
// "IAM access" permissions are needed to run this code.
// "STS assume role" permissions are needed to run this code. (Note: It might be necessary to
//    create a custom policy).
/*!
  \sa iamCreateUserAssumeRoleScenario
  \param clientConfig: Aws client configuration.
  \return bool: Successful completion.
*/
bool AwsDoc::IAM::iamCreateUserAssumeRoleScenario(
        const Aws::Client::ClientConfiguration &clientConfig) {

    Aws::IAM::IAMClient client(clientConfig);
    Aws::IAM::Model::User user;
    Aws::IAM::Model::Role role;
    Aws::IAM::Model::Policy policy;

    // 1. Create a user.
    {
        Aws::IAM::Model::CreateUserRequest request;
        Aws::String uuid = Aws::Utils::UUID::RandomUUID();
        Aws::String userName = "iam-demo-user-" +
                               Aws::Utils::StringUtils::ToLower(uuid.c_str());
        request.SetUserName(userName);

        Aws::IAM::Model::CreateUserOutcome outcome = client.CreateUser(request);
        if (!outcome.IsSuccess()) {
            std::cout << "Error creating IAM user " << userName << ":" <<
                      outcome.GetError().GetMessage() << std::endl;
            return false;
        }
        else {
            std::cout << "Successfully created IAM user " << userName << std::endl;
        }

        user = outcome.GetResult().GetUser();
    }

    // 2. Create a role.
    {
        // Get the IAM user for the current client in order to access its ARN.
        Aws::String iamUserArn;
        {
            Aws::IAM::Model::GetUserRequest request;
            Aws::IAM::Model::GetUserOutcome outcome = client.GetUser(request);
            if (!outcome.IsSuccess()) {
                std::cerr << "Error getting Iam user. " <<
                          outcome.GetError().GetMessage() << std::endl;

                DeleteCreatedEntities(client, role, user, policy);
                return false;
            }
            else {
                std::cout << "Successfully retrieved Iam user "
                          << outcome.GetResult().GetUser().GetUserName()
                          << std::endl;
            }

            iamUserArn = outcome.GetResult().GetUser().GetArn();
        }

        Aws::IAM::Model::CreateRoleRequest request;

        Aws::String uuid = Aws::Utils::UUID::RandomUUID();
        Aws::String roleName = "iam-demo-role-" +
                               Aws::Utils::StringUtils::ToLower(uuid.c_str());
        request.SetRoleName(roleName);

        // Build policy document for role.
        Aws::Utils::Document jsonStatement;
        jsonStatement.WithString("Effect", "Allow");

        Aws::Utils::Document jsonPrincipal;
        jsonPrincipal.WithString("AWS", iamUserArn);
        jsonStatement.WithObject("Principal", jsonPrincipal);
        jsonStatement.WithString("Action", "sts:AssumeRole");
        jsonStatement.WithObject("Condition", Aws::Utils::Document());

        Aws::Utils::Document policyDocument;
        policyDocument.WithString("Version", "2012-10-17");

        Aws::Utils::Array<Aws::Utils::Document> statements(1);
        statements[0] = jsonStatement;
        policyDocument.WithArray("Statement", statements);

        std::cout << "Setting policy for role\n   "
                  << policyDocument.View().WriteCompact() << std::endl;

        // Set role policy document as JSON string.
        request.SetAssumeRolePolicyDocument(policyDocument.View().WriteCompact());

        Aws::IAM::Model::CreateRoleOutcome outcome = client.CreateRole(request);
        if (!outcome.IsSuccess()) {
            std::cerr << "Error creating role. " <<
                      outcome.GetError().GetMessage() << std::endl;

            DeleteCreatedEntities(client, role, user, policy);
            return false;
        }
        else {
            std::cout << "Successfully created a role with name " << roleName
                      << std::endl;
        }

        role = outcome.GetResult().GetRole();
    }

    // 3. Create an IAM policy.
    {
        Aws::IAM::Model::CreatePolicyRequest request;
        Aws::String uuid = Aws::Utils::UUID::RandomUUID();
        Aws::String policyName = "iam-demo-policy-" +
                                 Aws::Utils::StringUtils::ToLower(uuid.c_str());
        request.SetPolicyName(policyName);

        // Build IAM policy document.
        Aws::Utils::Document jsonStatement;
        jsonStatement.WithString("Effect", "Allow");
        jsonStatement.WithString("Action", "s3:ListAllMyBuckets");
        jsonStatement.WithString("Resource", "arn:aws:s3:::*");

        Aws::Utils::Document policyDocument;
        policyDocument.WithString("Version", "2012-10-17");

        Aws::Utils::Array<Aws::Utils::Document> statements(1);
        statements[0] = jsonStatement;
        policyDocument.WithArray("Statement", statements);

        std::cout << "Creating a policy.\n   " << policyDocument.View().WriteCompact()
                  << std::endl;

        // Set IAM policy document as JSON string.
        request.SetPolicyDocument(policyDocument.View().WriteCompact());

        Aws::IAM::Model::CreatePolicyOutcome outcome = client.CreatePolicy(request);
        if (!outcome.IsSuccess()) {
            std::cerr << "Error creating policy. " <<
                      outcome.GetError().GetMessage() << std::endl;

            DeleteCreatedEntities(client, role, user, policy);
            return false;
        }
        else {
            std::cout << "Successfully created a policy with name, " << policyName <<
                      "." << std::endl;
        }

        policy = outcome.GetResult().GetPolicy();
    }

    // 4. Assume the new role using the AWS Security Token Service (STS).
    Aws::STS::Model::Credentials credentials;
    {
        Aws::STS::STSClient stsClient(clientConfig);

        Aws::STS::Model::AssumeRoleRequest request;
        request.SetRoleArn(role.GetArn());
        Aws::String uuid = Aws::Utils::UUID::RandomUUID();
        Aws::String roleSessionName = "iam-demo-role-session-" +
                                      Aws::Utils::StringUtils::ToLower(uuid.c_str());
        request.SetRoleSessionName(roleSessionName);

        Aws::STS::Model::AssumeRoleOutcome assumeRoleOutcome;

        // Repeatedly call AssumeRole, because there is often a delay
        // before the role is available to be assumed.
        // Repeat at most 20 times when access is denied.
        int count = 0;
        while (true) {
            assumeRoleOutcome = stsClient.AssumeRole(request);
            if (!assumeRoleOutcome.IsSuccess()) {
                if (count > 20 ||
                    assumeRoleOutcome.GetError().GetErrorType() !=
                    Aws::STS::STSErrors::ACCESS_DENIED) {
                    std::cerr << "Error assuming role after 20 tries. " <<
                              assumeRoleOutcome.GetError().GetMessage() << std::endl;

                    DeleteCreatedEntities(client, role, user, policy);
                    return false;
                }
                std::this_thread::sleep_for(std::chrono::seconds(1));
            }
            else {
                std::cout << "Successfully assumed the role after " << count
                          << " seconds." << std::endl;
                break;
            }
            count++;
        }

        credentials = assumeRoleOutcome.GetResult().GetCredentials();
    }


    // 5. List objects in the bucket (This should fail).
    {
        Aws::S3::S3Client s3Client(
                Aws::Auth::AWSCredentials(credentials.GetAccessKeyId(),
                                          credentials.GetSecretAccessKey(),
                                          credentials.GetSessionToken()),
                Aws::MakeShared<Aws::S3::S3EndpointProvider>(ALLOCATION_TAG),
                clientConfig);
        Aws::S3::Model::ListBucketsOutcome listBucketsOutcome = s3Client.ListBuckets();
        if (!listBucketsOutcome.IsSuccess()) {
            if (listBucketsOutcome.GetError().GetErrorType() !=
                Aws::S3::S3Errors::ACCESS_DENIED) {
                std::cerr << "Could not lists buckets. " <<
                          listBucketsOutcome.GetError().GetMessage() << std::endl;
            }
            else {
                std::cout
                        << "Access to list buckets denied because privileges have not been applied."
                        << std::endl;
            }
        }
        else {
            std::cerr
                    << "Successfully retrieved bucket lists when this should not happen."
                    << std::endl;
        }
    }

    // 6. Attach the policy to the role.
    {
        Aws::IAM::Model::AttachRolePolicyRequest request;
        request.SetRoleName(role.GetRoleName());
        request.WithPolicyArn(policy.GetArn());

        Aws::IAM::Model::AttachRolePolicyOutcome outcome = client.AttachRolePolicy(
                request);
        if (!outcome.IsSuccess()) {
            std::cerr << "Error creating policy. " <<
                      outcome.GetError().GetMessage() << std::endl;

            DeleteCreatedEntities(client, role, user, policy);
            return false;
        }
        else {
            std::cout << "Successfully attached the policy with name, "
                      << policy.GetPolicyName() <<
                      ", to the role, " << role.GetRoleName() << "." << std::endl;
        }
    }

    int count = 0;
    // 7. List objects in the bucket (this should succeed).
    // Repeatedly call ListBuckets, because there is often a delay
    // before the policy with ListBucket permissions has been applied to the role.
    // Repeat at most LIST_BUCKETS_WAIT_SEC times when access is denied.
    while (true) {
        Aws::S3::S3Client s3Client(
                Aws::Auth::AWSCredentials(credentials.GetAccessKeyId(),
                                          credentials.GetSecretAccessKey(),
                                          credentials.GetSessionToken()),
                Aws::MakeShared<Aws::S3::S3EndpointProvider>(ALLOCATION_TAG),
                clientConfig);
        Aws::S3::Model::ListBucketsOutcome listBucketsOutcome = s3Client.ListBuckets();
        if (!listBucketsOutcome.IsSuccess()) {
            if ((count > LIST_BUCKETS_WAIT_SEC) ||
                listBucketsOutcome.GetError().GetErrorType() !=
                Aws::S3::S3Errors::ACCESS_DENIED) {
                std::cerr << "Could not lists buckets after " << LIST_BUCKETS_WAIT_SEC << " seconds. " <<
                          listBucketsOutcome.GetError().GetMessage() << std::endl;
                DeleteCreatedEntities(client, role, user, policy);
                return false;
            }

            std::this_thread::sleep_for(std::chrono::seconds(1));
        }
        else {

            std::cout << "Successfully retrieved bucket lists after " << count
                      << " seconds." << std::endl;
            break;
        }
        count++;
    }

    // 8. Delete all the created resources.
    return DeleteCreatedEntities(client, role, user, policy);
}

bool AwsDoc::IAM::DeleteCreatedEntities(const Aws::IAM::IAMClient &client,
                                        const Aws::IAM::Model::Role &role,
                                        const Aws::IAM::Model::User &user,
                                        const Aws::IAM::Model::Policy &policy) {
    bool result = true;
    if (policy.ArnHasBeenSet()) {
        // Detach the policy from the role.
        {
            Aws::IAM::Model::DetachRolePolicyRequest request;
            request.SetPolicyArn(policy.GetArn());
            request.SetRoleName(role.GetRoleName());

            Aws::IAM::Model::DetachRolePolicyOutcome outcome = client.DetachRolePolicy(
                    request);
            if (!outcome.IsSuccess()) {
                std::cerr << "Error Detaching policy from roles. " <<
                          outcome.GetError().GetMessage() << std::endl;
                result = false;
            }
            else {
                std::cout << "Successfully detached the policy with arn "
                          << policy.GetArn()
                          << " from role " << role.GetRoleName() << "." << std::endl;
            }
        }

        // Delete the policy.
        {
            Aws::IAM::Model::DeletePolicyRequest request;
            request.WithPolicyArn(policy.GetArn());

            Aws::IAM::Model::DeletePolicyOutcome outcome = client.DeletePolicy(request);
            if (!outcome.IsSuccess()) {
                std::cerr << "Error deleting policy. " <<
                          outcome.GetError().GetMessage() << std::endl;
                result = false;
            }
            else {
                std::cout << "Successfully deleted the policy with arn "
                          << policy.GetArn() << std::endl;
            }
        }

    }

    if (role.RoleIdHasBeenSet()) {
        // Delete the role.
        Aws::IAM::Model::DeleteRoleRequest request;
        request.SetRoleName(role.GetRoleName());

        Aws::IAM::Model::DeleteRoleOutcome outcome = client.DeleteRole(request);
        if (!outcome.IsSuccess()) {
            std::cerr << "Error deleting role. " <<
                      outcome.GetError().GetMessage() << std::endl;
            result = false;
        }
        else {
            std::cout << "Successfully deleted the role with name "
                      << role.GetRoleName() << std::endl;
        }
    }

    if (user.ArnHasBeenSet()) {
        // Delete the user.
        Aws::IAM::Model::DeleteUserRequest request;
        request.WithUserName(user.GetUserName());

        Aws::IAM::Model::DeleteUserOutcome outcome = client.DeleteUser(request);
        if (!outcome.IsSuccess()) {
            std::cerr << "Error deleting user. " <<
                      outcome.GetError().GetMessage() << std::endl;
            result = false;
        }
        else {
            std::cout << "Successfully deleted the user with name "
                      << user.GetUserName() << std::endl;
        }
    }

    return result;
}
```
+ Per informazioni dettagliate sull'API, consulta i seguenti argomenti nella *documentazione di riferimento dell’API AWS SDK per C\$1\$1 *.
  + [AttachRolePolicy](https://docs.aws.amazon.com/goto/SdkForCpp/iam-2010-05-08/AttachRolePolicy)
  + [CreateAccessKey](https://docs.aws.amazon.com/goto/SdkForCpp/iam-2010-05-08/CreateAccessKey)
  + [CreatePolicy](https://docs.aws.amazon.com/goto/SdkForCpp/iam-2010-05-08/CreatePolicy)
  + [CreateRole](https://docs.aws.amazon.com/goto/SdkForCpp/iam-2010-05-08/CreateRole)
  + [CreateUser](https://docs.aws.amazon.com/goto/SdkForCpp/iam-2010-05-08/CreateUser)
  + [DeleteAccessKey](https://docs.aws.amazon.com/goto/SdkForCpp/iam-2010-05-08/DeleteAccessKey)
  + [DeletePolicy](https://docs.aws.amazon.com/goto/SdkForCpp/iam-2010-05-08/DeletePolicy)
  + [DeleteRole](https://docs.aws.amazon.com/goto/SdkForCpp/iam-2010-05-08/DeleteRole)
  + [DeleteUser](https://docs.aws.amazon.com/goto/SdkForCpp/iam-2010-05-08/DeleteUser)
  + [DeleteUserPolicy](https://docs.aws.amazon.com/goto/SdkForCpp/iam-2010-05-08/DeleteUserPolicy)
  + [DetachRolePolicy](https://docs.aws.amazon.com/goto/SdkForCpp/iam-2010-05-08/DetachRolePolicy)
  + [PutUserPolicy](https://docs.aws.amazon.com/goto/SdkForCpp/iam-2010-05-08/PutUserPolicy)

------
#### [ Go ]

**SDK per Go V2**  
 C'è dell'altro GitHub. Trova l'esempio completo e scopri di più sulla configurazione e l'esecuzione nel [Repository di esempi di codice AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/gov2/iam#code-examples). 
Esegui uno scenario interattivo al prompt dei comandi.  

```
import (
	"context"
	"errors"
	"fmt"
	"log"
	"math/rand"
	"strings"
	"time"

	"github.com/aws/aws-sdk-go-v2/aws"
	"github.com/aws/aws-sdk-go-v2/config"
	"github.com/aws/aws-sdk-go-v2/credentials"
	"github.com/aws/aws-sdk-go-v2/service/iam"
	"github.com/aws/aws-sdk-go-v2/service/iam/types"
	"github.com/aws/aws-sdk-go-v2/service/s3"
	"github.com/aws/aws-sdk-go-v2/service/sts"
	"github.com/aws/smithy-go"
	"github.com/awsdocs/aws-doc-sdk-examples/gov2/demotools"
	"github.com/awsdocs/aws-doc-sdk-examples/gov2/iam/actions"
)

// AssumeRoleScenario shows you how to use the AWS Identity and Access Management (IAM)
// service to perform the following actions:
//
//  1. Create a user who has no permissions.
//  2. Create a role that grants permission to list Amazon Simple Storage Service
//     (Amazon S3) buckets for the account.
//  3. Add a policy to let the user assume the role.
//  4. Try and fail to list buckets without permissions.
//  5. Assume the role and list S3 buckets using temporary credentials.
//  6. Delete the policy, role, and user.
type AssumeRoleScenario struct {
	sdkConfig      aws.Config
	accountWrapper actions.AccountWrapper
	policyWrapper  actions.PolicyWrapper
	roleWrapper    actions.RoleWrapper
	userWrapper    actions.UserWrapper
	questioner     demotools.IQuestioner
	helper         IScenarioHelper
	isTestRun      bool
}

// NewAssumeRoleScenario constructs an AssumeRoleScenario instance from a configuration.
// It uses the specified config to get an IAM client and create wrappers for the actions
// used in the scenario.
func NewAssumeRoleScenario(sdkConfig aws.Config, questioner demotools.IQuestioner,
	helper IScenarioHelper) AssumeRoleScenario {
	iamClient := iam.NewFromConfig(sdkConfig)
	return AssumeRoleScenario{
		sdkConfig:      sdkConfig,
		accountWrapper: actions.AccountWrapper{IamClient: iamClient},
		policyWrapper:  actions.PolicyWrapper{IamClient: iamClient},
		roleWrapper:    actions.RoleWrapper{IamClient: iamClient},
		userWrapper:    actions.UserWrapper{IamClient: iamClient},
		questioner:     questioner,
		helper:         helper,
	}
}

// addTestOptions appends the API options specified in the original configuration to
// another configuration. This is used to attach the middleware stubber to clients
// that are constructed during the scenario, which is needed for unit testing.
func (scenario AssumeRoleScenario) addTestOptions(scenarioConfig *aws.Config) {
	if scenario.isTestRun {
		scenarioConfig.APIOptions = append(scenarioConfig.APIOptions, scenario.sdkConfig.APIOptions...)
	}
}

// Run runs the interactive scenario.
func (scenario AssumeRoleScenario) Run(ctx context.Context) {
	defer func() {
		if r := recover(); r != nil {
			log.Printf("Something went wrong with the demo.\n")
			log.Println(r)
		}
	}()

	log.Println(strings.Repeat("-", 88))
	log.Println("Welcome to the AWS Identity and Access Management (IAM) assume role demo.")
	log.Println(strings.Repeat("-", 88))

	user := scenario.CreateUser(ctx)
	accessKey := scenario.CreateAccessKey(ctx, user)
	role := scenario.CreateRoleAndPolicies(ctx, user)
	noPermsConfig := scenario.ListBucketsWithoutPermissions(ctx, accessKey)
	scenario.ListBucketsWithAssumedRole(ctx, noPermsConfig, role)
	scenario.Cleanup(ctx, user, role)

	log.Println(strings.Repeat("-", 88))
	log.Println("Thanks for watching!")
	log.Println(strings.Repeat("-", 88))
}

// CreateUser creates a new IAM user. This user has no permissions.
func (scenario AssumeRoleScenario) CreateUser(ctx context.Context) *types.User {
	log.Println("Let's create an example user with no permissions.")
	userName := scenario.questioner.Ask("Enter a name for the example user:", demotools.NotEmpty{})
	user, err := scenario.userWrapper.GetUser(ctx, userName)
	if err != nil {
		panic(err)
	}
	if user == nil {
		user, err = scenario.userWrapper.CreateUser(ctx, userName)
		if err != nil {
			panic(err)
		}
		log.Printf("Created user %v.\n", *user.UserName)
	} else {
		log.Printf("User %v already exists.\n", *user.UserName)
	}
	log.Println(strings.Repeat("-", 88))
	return user
}

// CreateAccessKey creates an access key for the user.
func (scenario AssumeRoleScenario) CreateAccessKey(ctx context.Context, user *types.User) *types.AccessKey {
	accessKey, err := scenario.userWrapper.CreateAccessKeyPair(ctx, *user.UserName)
	if err != nil {
		panic(err)
	}
	log.Printf("Created access key %v for your user.", *accessKey.AccessKeyId)
	log.Println("Waiting a few seconds for your user to be ready...")
	scenario.helper.Pause(10)
	log.Println(strings.Repeat("-", 88))
	return accessKey
}

// CreateRoleAndPolicies creates a policy that grants permission to list S3 buckets for
// the current account and attaches the policy to a newly created role. It also adds an
// inline policy to the specified user that grants the user permission to assume the role.
func (scenario AssumeRoleScenario) CreateRoleAndPolicies(ctx context.Context, user *types.User) *types.Role {
	log.Println("Let's create a role and policy that grant permission to list S3 buckets.")
	scenario.questioner.Ask("Press Enter when you're ready.")
	listBucketsRole, err := scenario.roleWrapper.CreateRole(ctx, scenario.helper.GetName(), *user.Arn)
	if err != nil {
		panic(err)
	}
	log.Printf("Created role %v.\n", *listBucketsRole.RoleName)
	listBucketsPolicy, err := scenario.policyWrapper.CreatePolicy(
		ctx, scenario.helper.GetName(), []string{"s3:ListAllMyBuckets"}, "arn:aws:s3:::*")
	if err != nil {
		panic(err)
	}
	log.Printf("Created policy %v.\n", *listBucketsPolicy.PolicyName)
	err = scenario.roleWrapper.AttachRolePolicy(ctx, *listBucketsPolicy.Arn, *listBucketsRole.RoleName)
	if err != nil {
		panic(err)
	}
	log.Printf("Attached policy %v to role %v.\n", *listBucketsPolicy.PolicyName,
		*listBucketsRole.RoleName)
	err = scenario.userWrapper.CreateUserPolicy(ctx, *user.UserName, scenario.helper.GetName(),
		[]string{"sts:AssumeRole"}, *listBucketsRole.Arn)
	if err != nil {
		panic(err)
	}
	log.Printf("Created an inline policy for user %v that lets the user assume the role.\n",
		*user.UserName)
	log.Println("Let's give AWS a few seconds to propagate these new resources and connections...")
	scenario.helper.Pause(10)
	log.Println(strings.Repeat("-", 88))
	return listBucketsRole
}

// ListBucketsWithoutPermissions creates an Amazon S3 client from the user's access key
// credentials and tries to list buckets for the account. Because the user does not have
// permission to perform this action, the action fails.
func (scenario AssumeRoleScenario) ListBucketsWithoutPermissions(ctx context.Context, accessKey *types.AccessKey) *aws.Config {
	log.Println("Let's try to list buckets without permissions. This should return an AccessDenied error.")
	scenario.questioner.Ask("Press Enter when you're ready.")
	noPermsConfig, err := config.LoadDefaultConfig(ctx,
		config.WithCredentialsProvider(credentials.NewStaticCredentialsProvider(
			*accessKey.AccessKeyId, *accessKey.SecretAccessKey, ""),
		))
	if err != nil {
		panic(err)
	}

	// Add test options if this is a test run. This is needed only for testing purposes.
	scenario.addTestOptions(&noPermsConfig)

	s3Client := s3.NewFromConfig(noPermsConfig)
	_, err = s3Client.ListBuckets(ctx, &s3.ListBucketsInput{})
	if err != nil {
		// The SDK for Go does not model the AccessDenied error, so check ErrorCode directly.
		var ae smithy.APIError
		if errors.As(err, &ae) {
			switch ae.ErrorCode() {
			case "AccessDenied":
				log.Println("Got AccessDenied error, which is the expected result because\n" +
					"the ListBuckets call was made without permissions.")
			default:
				log.Println("Expected AccessDenied, got something else.")
				panic(err)
			}
		}
	} else {
		log.Println("Expected AccessDenied error when calling ListBuckets without permissions,\n" +
			"but the call succeeded. Continuing the example anyway...")
	}
	log.Println(strings.Repeat("-", 88))
	return &noPermsConfig
}

// ListBucketsWithAssumedRole performs the following actions:
//
//  1. Creates an AWS Security Token Service (AWS STS) client from the config created from
//     the user's access key credentials.
//  2. Gets temporary credentials by assuming the role that grants permission to list the
//     buckets.
//  3. Creates an Amazon S3 client from the temporary credentials.
//  4. Lists buckets for the account. Because the temporary credentials are generated by
//     assuming the role that grants permission, the action succeeds.
func (scenario AssumeRoleScenario) ListBucketsWithAssumedRole(ctx context.Context, noPermsConfig *aws.Config, role *types.Role) {
	log.Println("Let's assume the role that grants permission to list buckets and try again.")
	scenario.questioner.Ask("Press Enter when you're ready.")
	stsClient := sts.NewFromConfig(*noPermsConfig)
	tempCredentials, err := stsClient.AssumeRole(ctx, &sts.AssumeRoleInput{
		RoleArn:         role.Arn,
		RoleSessionName: aws.String("AssumeRoleExampleSession"),
		DurationSeconds: aws.Int32(900),
	})
	if err != nil {
		log.Printf("Couldn't assume role %v.\n", *role.RoleName)
		panic(err)
	}
	log.Printf("Assumed role %v, got temporary credentials.\n", *role.RoleName)
	assumeRoleConfig, err := config.LoadDefaultConfig(ctx,
		config.WithCredentialsProvider(credentials.NewStaticCredentialsProvider(
			*tempCredentials.Credentials.AccessKeyId,
			*tempCredentials.Credentials.SecretAccessKey,
			*tempCredentials.Credentials.SessionToken),
		),
	)
	if err != nil {
		panic(err)
	}

	// Add test options if this is a test run. This is needed only for testing purposes.
	scenario.addTestOptions(&assumeRoleConfig)

	s3Client := s3.NewFromConfig(assumeRoleConfig)
	result, err := s3Client.ListBuckets(ctx, &s3.ListBucketsInput{})
	if err != nil {
		log.Println("Couldn't list buckets with assumed role credentials.")
		panic(err)
	}
	log.Println("Successfully called ListBuckets with assumed role credentials, \n" +
		"here are some of them:")
	for i := 0; i < len(result.Buckets) && i < 5; i++ {
		log.Printf("\t%v\n", *result.Buckets[i].Name)
	}
	log.Println(strings.Repeat("-", 88))
}

// Cleanup deletes all resources created for the scenario.
func (scenario AssumeRoleScenario) Cleanup(ctx context.Context, user *types.User, role *types.Role) {
	if scenario.questioner.AskBool(
		"Do you want to delete the resources created for this example? (y/n)", "y",
	) {
		policies, err := scenario.roleWrapper.ListAttachedRolePolicies(ctx, *role.RoleName)
		if err != nil {
			panic(err)
		}
		for _, policy := range policies {
			err = scenario.roleWrapper.DetachRolePolicy(ctx, *role.RoleName, *policy.PolicyArn)
			if err != nil {
				panic(err)
			}
			err = scenario.policyWrapper.DeletePolicy(ctx, *policy.PolicyArn)
			if err != nil {
				panic(err)
			}
			log.Printf("Detached policy %v from role %v and deleted the policy.\n",
				*policy.PolicyName, *role.RoleName)
		}
		err = scenario.roleWrapper.DeleteRole(ctx, *role.RoleName)
		if err != nil {
			panic(err)
		}
		log.Printf("Deleted role %v.\n", *role.RoleName)

		userPols, err := scenario.userWrapper.ListUserPolicies(ctx, *user.UserName)
		if err != nil {
			panic(err)
		}
		for _, userPol := range userPols {
			err = scenario.userWrapper.DeleteUserPolicy(ctx, *user.UserName, userPol)
			if err != nil {
				panic(err)
			}
			log.Printf("Deleted policy %v from user %v.\n", userPol, *user.UserName)
		}
		keys, err := scenario.userWrapper.ListAccessKeys(ctx, *user.UserName)
		if err != nil {
			panic(err)
		}
		for _, key := range keys {
			err = scenario.userWrapper.DeleteAccessKey(ctx, *user.UserName, *key.AccessKeyId)
			if err != nil {
				panic(err)
			}
			log.Printf("Deleted access key %v from user %v.\n", *key.AccessKeyId, *user.UserName)
		}
		err = scenario.userWrapper.DeleteUser(ctx, *user.UserName)
		if err != nil {
			panic(err)
		}
		log.Printf("Deleted user %v.\n", *user.UserName)
		log.Println(strings.Repeat("-", 88))
	}

}

// IScenarioHelper abstracts input and wait functions from a scenario so that they
// can be mocked for unit testing.
type IScenarioHelper interface {
	GetName() string
	Pause(secs int)
}

const rMax = 100000

type ScenarioHelper struct {
	Prefix string
	Random *rand.Rand
}

// GetName returns a unique name formed of a prefix and a random number.
func (helper *ScenarioHelper) GetName() string {
	return fmt.Sprintf("%v%v", helper.Prefix, helper.Random.Intn(rMax))
}

// Pause waits for the specified number of seconds.
func (helper ScenarioHelper) Pause(secs int) {
	time.Sleep(time.Duration(secs) * time.Second)
}
```
Definisci una struttura che racchiude le azioni dell’account.  

```
import (
	"context"
	"log"

	"github.com/aws/aws-sdk-go-v2/service/iam"
	"github.com/aws/aws-sdk-go-v2/service/iam/types"
)

// AccountWrapper encapsulates AWS Identity and Access Management (IAM) account actions
// used in the examples.
// It contains an IAM service client that is used to perform account actions.
type AccountWrapper struct {
	IamClient *iam.Client
}



// GetAccountPasswordPolicy gets the account password policy for the current account.
// If no policy has been set, a NoSuchEntityException is error is returned.
func (wrapper AccountWrapper) GetAccountPasswordPolicy(ctx context.Context) (*types.PasswordPolicy, error) {
	var pwPolicy *types.PasswordPolicy
	result, err := wrapper.IamClient.GetAccountPasswordPolicy(ctx,
		&iam.GetAccountPasswordPolicyInput{})
	if err != nil {
		log.Printf("Couldn't get account password policy. Here's why: %v\n", err)
	} else {
		pwPolicy = result.PasswordPolicy
	}
	return pwPolicy, err
}



// ListSAMLProviders gets the SAML providers for the account.
func (wrapper AccountWrapper) ListSAMLProviders(ctx context.Context) ([]types.SAMLProviderListEntry, error) {
	var providers []types.SAMLProviderListEntry
	result, err := wrapper.IamClient.ListSAMLProviders(ctx, &iam.ListSAMLProvidersInput{})
	if err != nil {
		log.Printf("Couldn't list SAML providers. Here's why: %v\n", err)
	} else {
		providers = result.SAMLProviderList
	}
	return providers, err
}
```
Definisci una struttura che racchiude le azioni della policy.  

```
import (
	"context"
	"encoding/json"
	"log"

	"github.com/aws/aws-sdk-go-v2/aws"
	"github.com/aws/aws-sdk-go-v2/service/iam"
	"github.com/aws/aws-sdk-go-v2/service/iam/types"
)

// PolicyWrapper encapsulates AWS Identity and Access Management (IAM) policy actions
// used in the examples.
// It contains an IAM service client that is used to perform policy actions.
type PolicyWrapper struct {
	IamClient *iam.Client
}



// ListPolicies gets up to maxPolicies policies.
func (wrapper PolicyWrapper) ListPolicies(ctx context.Context, maxPolicies int32) ([]types.Policy, error) {
	var policies []types.Policy
	result, err := wrapper.IamClient.ListPolicies(ctx, &iam.ListPoliciesInput{
		MaxItems: aws.Int32(maxPolicies),
	})
	if err != nil {
		log.Printf("Couldn't list policies. Here's why: %v\n", err)
	} else {
		policies = result.Policies
	}
	return policies, err
}



// PolicyDocument defines a policy document as a Go struct that can be serialized
// to JSON.
type PolicyDocument struct {
	Version   string
	Statement []PolicyStatement
}

// PolicyStatement defines a statement in a policy document.
type PolicyStatement struct {
	Effect    string
	Action    []string
	Principal map[string]string `json:",omitempty"`
	Resource  *string           `json:",omitempty"`
}

// CreatePolicy creates a policy that grants a list of actions to the specified resource.
// PolicyDocument shows how to work with a policy document as a data structure and
// serialize it to JSON by using Go's JSON marshaler.
func (wrapper PolicyWrapper) CreatePolicy(ctx context.Context, policyName string, actions []string,
	resourceArn string) (*types.Policy, error) {
	var policy *types.Policy
	policyDoc := PolicyDocument{
		Version: "2012-10-17",
		Statement: []PolicyStatement{{
			Effect:   "Allow",
			Action:   actions,
			Resource: aws.String(resourceArn),
		}},
	}
	policyBytes, err := json.Marshal(policyDoc)
	if err != nil {
		log.Printf("Couldn't create policy document for %v. Here's why: %v\n", resourceArn, err)
		return nil, err
	}
	result, err := wrapper.IamClient.CreatePolicy(ctx, &iam.CreatePolicyInput{
		PolicyDocument: aws.String(string(policyBytes)),
		PolicyName:     aws.String(policyName),
	})
	if err != nil {
		log.Printf("Couldn't create policy %v. Here's why: %v\n", policyName, err)
	} else {
		policy = result.Policy
	}
	return policy, err
}



// GetPolicy gets data about a policy.
func (wrapper PolicyWrapper) GetPolicy(ctx context.Context, policyArn string) (*types.Policy, error) {
	var policy *types.Policy
	result, err := wrapper.IamClient.GetPolicy(ctx, &iam.GetPolicyInput{
		PolicyArn: aws.String(policyArn),
	})
	if err != nil {
		log.Printf("Couldn't get policy %v. Here's why: %v\n", policyArn, err)
	} else {
		policy = result.Policy
	}
	return policy, err
}



// DeletePolicy deletes a policy.
func (wrapper PolicyWrapper) DeletePolicy(ctx context.Context, policyArn string) error {
	_, err := wrapper.IamClient.DeletePolicy(ctx, &iam.DeletePolicyInput{
		PolicyArn: aws.String(policyArn),
	})
	if err != nil {
		log.Printf("Couldn't delete policy %v. Here's why: %v\n", policyArn, err)
	}
	return err
}
```
Definisci una struttura che racchiude le azioni del ruolo.  

```
import (
	"context"
	"encoding/json"
	"log"

	"github.com/aws/aws-sdk-go-v2/aws"
	"github.com/aws/aws-sdk-go-v2/service/iam"
	"github.com/aws/aws-sdk-go-v2/service/iam/types"
)

// RoleWrapper encapsulates AWS Identity and Access Management (IAM) role actions
// used in the examples.
// It contains an IAM service client that is used to perform role actions.
type RoleWrapper struct {
	IamClient *iam.Client
}



// ListRoles gets up to maxRoles roles.
func (wrapper RoleWrapper) ListRoles(ctx context.Context, maxRoles int32) ([]types.Role, error) {
	var roles []types.Role
	result, err := wrapper.IamClient.ListRoles(ctx,
		&iam.ListRolesInput{MaxItems: aws.Int32(maxRoles)},
	)
	if err != nil {
		log.Printf("Couldn't list roles. Here's why: %v\n", err)
	} else {
		roles = result.Roles
	}
	return roles, err
}



// CreateRole creates a role that trusts a specified user. The trusted user can assume
// the role to acquire its permissions.
// PolicyDocument shows how to work with a policy document as a data structure and
// serialize it to JSON by using Go's JSON marshaler.
func (wrapper RoleWrapper) CreateRole(ctx context.Context, roleName string, trustedUserArn string) (*types.Role, error) {
	var role *types.Role
	trustPolicy := PolicyDocument{
		Version: "2012-10-17",
		Statement: []PolicyStatement{{
			Effect:    "Allow",
			Principal: map[string]string{"AWS": trustedUserArn},
			Action:    []string{"sts:AssumeRole"},
		}},
	}
	policyBytes, err := json.Marshal(trustPolicy)
	if err != nil {
		log.Printf("Couldn't create trust policy for %v. Here's why: %v\n", trustedUserArn, err)
		return nil, err
	}
	result, err := wrapper.IamClient.CreateRole(ctx, &iam.CreateRoleInput{
		AssumeRolePolicyDocument: aws.String(string(policyBytes)),
		RoleName:                 aws.String(roleName),
	})
	if err != nil {
		log.Printf("Couldn't create role %v. Here's why: %v\n", roleName, err)
	} else {
		role = result.Role
	}
	return role, err
}



// GetRole gets data about a role.
func (wrapper RoleWrapper) GetRole(ctx context.Context, roleName string) (*types.Role, error) {
	var role *types.Role
	result, err := wrapper.IamClient.GetRole(ctx,
		&iam.GetRoleInput{RoleName: aws.String(roleName)})
	if err != nil {
		log.Printf("Couldn't get role %v. Here's why: %v\n", roleName, err)
	} else {
		role = result.Role
	}
	return role, err
}



// CreateServiceLinkedRole creates a service-linked role that is owned by the specified service.
func (wrapper RoleWrapper) CreateServiceLinkedRole(ctx context.Context, serviceName string, description string) (
	*types.Role, error) {
	var role *types.Role
	result, err := wrapper.IamClient.CreateServiceLinkedRole(ctx, &iam.CreateServiceLinkedRoleInput{
		AWSServiceName: aws.String(serviceName),
		Description:    aws.String(description),
	})
	if err != nil {
		log.Printf("Couldn't create service-linked role %v. Here's why: %v\n", serviceName, err)
	} else {
		role = result.Role
	}
	return role, err
}



// DeleteServiceLinkedRole deletes a service-linked role.
func (wrapper RoleWrapper) DeleteServiceLinkedRole(ctx context.Context, roleName string) error {
	_, err := wrapper.IamClient.DeleteServiceLinkedRole(ctx, &iam.DeleteServiceLinkedRoleInput{
		RoleName: aws.String(roleName)},
	)
	if err != nil {
		log.Printf("Couldn't delete service-linked role %v. Here's why: %v\n", roleName, err)
	}
	return err
}



// AttachRolePolicy attaches a policy to a role.
func (wrapper RoleWrapper) AttachRolePolicy(ctx context.Context, policyArn string, roleName string) error {
	_, err := wrapper.IamClient.AttachRolePolicy(ctx, &iam.AttachRolePolicyInput{
		PolicyArn: aws.String(policyArn),
		RoleName:  aws.String(roleName),
	})
	if err != nil {
		log.Printf("Couldn't attach policy %v to role %v. Here's why: %v\n", policyArn, roleName, err)
	}
	return err
}



// ListAttachedRolePolicies lists the policies that are attached to the specified role.
func (wrapper RoleWrapper) ListAttachedRolePolicies(ctx context.Context, roleName string) ([]types.AttachedPolicy, error) {
	var policies []types.AttachedPolicy
	result, err := wrapper.IamClient.ListAttachedRolePolicies(ctx, &iam.ListAttachedRolePoliciesInput{
		RoleName: aws.String(roleName),
	})
	if err != nil {
		log.Printf("Couldn't list attached policies for role %v. Here's why: %v\n", roleName, err)
	} else {
		policies = result.AttachedPolicies
	}
	return policies, err
}



// DetachRolePolicy detaches a policy from a role.
func (wrapper RoleWrapper) DetachRolePolicy(ctx context.Context, roleName string, policyArn string) error {
	_, err := wrapper.IamClient.DetachRolePolicy(ctx, &iam.DetachRolePolicyInput{
		PolicyArn: aws.String(policyArn),
		RoleName:  aws.String(roleName),
	})
	if err != nil {
		log.Printf("Couldn't detach policy from role %v. Here's why: %v\n", roleName, err)
	}
	return err
}



// ListRolePolicies lists the inline policies for a role.
func (wrapper RoleWrapper) ListRolePolicies(ctx context.Context, roleName string) ([]string, error) {
	var policies []string
	result, err := wrapper.IamClient.ListRolePolicies(ctx, &iam.ListRolePoliciesInput{
		RoleName: aws.String(roleName),
	})
	if err != nil {
		log.Printf("Couldn't list policies for role %v. Here's why: %v\n", roleName, err)
	} else {
		policies = result.PolicyNames
	}
	return policies, err
}



// DeleteRole deletes a role. All attached policies must be detached before a
// role can be deleted.
func (wrapper RoleWrapper) DeleteRole(ctx context.Context, roleName string) error {
	_, err := wrapper.IamClient.DeleteRole(ctx, &iam.DeleteRoleInput{
		RoleName: aws.String(roleName),
	})
	if err != nil {
		log.Printf("Couldn't delete role %v. Here's why: %v\n", roleName, err)
	}
	return err
}
```
Definisci una struttura che racchiude le azioni dell’utente.  

```
import (
	"context"
	"encoding/json"
	"errors"
	"log"

	"github.com/aws/aws-sdk-go-v2/aws"
	"github.com/aws/aws-sdk-go-v2/service/iam"
	"github.com/aws/aws-sdk-go-v2/service/iam/types"
	"github.com/aws/smithy-go"
)

// UserWrapper encapsulates user actions used in the examples.
// It contains an IAM service client that is used to perform user actions.
type UserWrapper struct {
	IamClient *iam.Client
}



// ListUsers gets up to maxUsers number of users.
func (wrapper UserWrapper) ListUsers(ctx context.Context, maxUsers int32) ([]types.User, error) {
	var users []types.User
	result, err := wrapper.IamClient.ListUsers(ctx, &iam.ListUsersInput{
		MaxItems: aws.Int32(maxUsers),
	})
	if err != nil {
		log.Printf("Couldn't list users. Here's why: %v\n", err)
	} else {
		users = result.Users
	}
	return users, err
}



// GetUser gets data about a user.
func (wrapper UserWrapper) GetUser(ctx context.Context, userName string) (*types.User, error) {
	var user *types.User
	result, err := wrapper.IamClient.GetUser(ctx, &iam.GetUserInput{
		UserName: aws.String(userName),
	})
	if err != nil {
		var apiError smithy.APIError
		if errors.As(err, &apiError) {
			switch apiError.(type) {
			case *types.NoSuchEntityException:
				log.Printf("User %v does not exist.\n", userName)
				err = nil
			default:
				log.Printf("Couldn't get user %v. Here's why: %v\n", userName, err)
			}
		}
	} else {
		user = result.User
	}
	return user, err
}



// CreateUser creates a new user with the specified name.
func (wrapper UserWrapper) CreateUser(ctx context.Context, userName string) (*types.User, error) {
	var user *types.User
	result, err := wrapper.IamClient.CreateUser(ctx, &iam.CreateUserInput{
		UserName: aws.String(userName),
	})
	if err != nil {
		log.Printf("Couldn't create user %v. Here's why: %v\n", userName, err)
	} else {
		user = result.User
	}
	return user, err
}



// CreateUserPolicy adds an inline policy to a user. This example creates a policy that
// grants a list of actions on a specified role.
// PolicyDocument shows how to work with a policy document as a data structure and
// serialize it to JSON by using Go's JSON marshaler.
func (wrapper UserWrapper) CreateUserPolicy(ctx context.Context, userName string, policyName string, actions []string,
	roleArn string) error {
	policyDoc := PolicyDocument{
		Version: "2012-10-17",
		Statement: []PolicyStatement{{
			Effect:   "Allow",
			Action:   actions,
			Resource: aws.String(roleArn),
		}},
	}
	policyBytes, err := json.Marshal(policyDoc)
	if err != nil {
		log.Printf("Couldn't create policy document for %v. Here's why: %v\n", roleArn, err)
		return err
	}
	_, err = wrapper.IamClient.PutUserPolicy(ctx, &iam.PutUserPolicyInput{
		PolicyDocument: aws.String(string(policyBytes)),
		PolicyName:     aws.String(policyName),
		UserName:       aws.String(userName),
	})
	if err != nil {
		log.Printf("Couldn't create policy for user %v. Here's why: %v\n", userName, err)
	}
	return err
}



// ListUserPolicies lists the inline policies for the specified user.
func (wrapper UserWrapper) ListUserPolicies(ctx context.Context, userName string) ([]string, error) {
	var policies []string
	result, err := wrapper.IamClient.ListUserPolicies(ctx, &iam.ListUserPoliciesInput{
		UserName: aws.String(userName),
	})
	if err != nil {
		log.Printf("Couldn't list policies for user %v. Here's why: %v\n", userName, err)
	} else {
		policies = result.PolicyNames
	}
	return policies, err
}



// DeleteUserPolicy deletes an inline policy from a user.
func (wrapper UserWrapper) DeleteUserPolicy(ctx context.Context, userName string, policyName string) error {
	_, err := wrapper.IamClient.DeleteUserPolicy(ctx, &iam.DeleteUserPolicyInput{
		PolicyName: aws.String(policyName),
		UserName:   aws.String(userName),
	})
	if err != nil {
		log.Printf("Couldn't delete policy from user %v. Here's why: %v\n", userName, err)
	}
	return err
}



// DeleteUser deletes a user.
func (wrapper UserWrapper) DeleteUser(ctx context.Context, userName string) error {
	_, err := wrapper.IamClient.DeleteUser(ctx, &iam.DeleteUserInput{
		UserName: aws.String(userName),
	})
	if err != nil {
		log.Printf("Couldn't delete user %v. Here's why: %v\n", userName, err)
	}
	return err
}



// CreateAccessKeyPair creates an access key for a user. The returned access key contains
// the ID and secret credentials needed to use the key.
func (wrapper UserWrapper) CreateAccessKeyPair(ctx context.Context, userName string) (*types.AccessKey, error) {
	var key *types.AccessKey
	result, err := wrapper.IamClient.CreateAccessKey(ctx, &iam.CreateAccessKeyInput{
		UserName: aws.String(userName)})
	if err != nil {
		log.Printf("Couldn't create access key pair for user %v. Here's why: %v\n", userName, err)
	} else {
		key = result.AccessKey
	}
	return key, err
}



// DeleteAccessKey deletes an access key from a user.
func (wrapper UserWrapper) DeleteAccessKey(ctx context.Context, userName string, keyId string) error {
	_, err := wrapper.IamClient.DeleteAccessKey(ctx, &iam.DeleteAccessKeyInput{
		AccessKeyId: aws.String(keyId),
		UserName:    aws.String(userName),
	})
	if err != nil {
		log.Printf("Couldn't delete access key %v. Here's why: %v\n", keyId, err)
	}
	return err
}



// ListAccessKeys lists the access keys for the specified user.
func (wrapper UserWrapper) ListAccessKeys(ctx context.Context, userName string) ([]types.AccessKeyMetadata, error) {
	var keys []types.AccessKeyMetadata
	result, err := wrapper.IamClient.ListAccessKeys(ctx, &iam.ListAccessKeysInput{
		UserName: aws.String(userName),
	})
	if err != nil {
		log.Printf("Couldn't list access keys for user %v. Here's why: %v\n", userName, err)
	} else {
		keys = result.AccessKeyMetadata
	}
	return keys, err
}
```
+ Per informazioni dettagliate sull’API, consulta i seguenti argomenti nella *documentazione di riferimento dell’API AWS SDK per Go *.
  + [AttachRolePolicy](https://pkg.go.dev/github.com/aws/aws-sdk-go-v2/service/iam#Client.AttachRolePolicy)
  + [CreateAccessKey](https://pkg.go.dev/github.com/aws/aws-sdk-go-v2/service/iam#Client.CreateAccessKey)
  + [CreatePolicy](https://pkg.go.dev/github.com/aws/aws-sdk-go-v2/service/iam#Client.CreatePolicy)
  + [CreateRole](https://pkg.go.dev/github.com/aws/aws-sdk-go-v2/service/iam#Client.CreateRole)
  + [CreateUser](https://pkg.go.dev/github.com/aws/aws-sdk-go-v2/service/iam#Client.CreateUser)
  + [DeleteAccessKey](https://pkg.go.dev/github.com/aws/aws-sdk-go-v2/service/iam#Client.DeleteAccessKey)
  + [DeletePolicy](https://pkg.go.dev/github.com/aws/aws-sdk-go-v2/service/iam#Client.DeletePolicy)
  + [DeleteRole](https://pkg.go.dev/github.com/aws/aws-sdk-go-v2/service/iam#Client.DeleteRole)
  + [DeleteUser](https://pkg.go.dev/github.com/aws/aws-sdk-go-v2/service/iam#Client.DeleteUser)
  + [DeleteUserPolicy](https://pkg.go.dev/github.com/aws/aws-sdk-go-v2/service/iam#Client.DeleteUserPolicy)
  + [DetachRolePolicy](https://pkg.go.dev/github.com/aws/aws-sdk-go-v2/service/iam#Client.DetachRolePolicy)
  + [PutUserPolicy](https://pkg.go.dev/github.com/aws/aws-sdk-go-v2/service/iam#Client.PutUserPolicy)

------
#### [ Java ]

**SDK per Java 2.x**  
 C'è dell'altro GitHub. Trova l'esempio completo e scopri di più sulla configurazione e l'esecuzione nel [Repository di esempi di codice AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javav2/example_code/iam#code-examples). 
Crea funzioni che eseguono il wrapping delle operazioni degli utenti IAM.  

```
/*
  To run this Java V2 code example, set up your development environment, including your credentials.

  For information, see this documentation topic:

  https://docs.aws.amazon.com/sdk-for-java/latest/developer-guide/get-started.html

  This example performs these operations:

  1. Creates a user that has no permissions.
  2. Creates a role and policy that grants Amazon S3 permissions.
  3. Creates a role.
  4. Grants the user permissions.
  5. Gets temporary credentials by assuming the role.  Creates an Amazon S3 Service client object with the temporary credentials.
  6. Deletes the resources.
 */

public class IAMScenario {
    public static final String DASHES = new String(new char[80]).replace("\0", "-");
    public static final String PolicyDocument = "{" +
            "  \"Version\": \"2012-10-17\"," +
            "  \"Statement\": [" +
            "    {" +
            "        \"Effect\": \"Allow\"," +
            "        \"Action\": [" +
            "            \"s3:*\"" +
            "       ]," +
            "       \"Resource\": \"*\"" +
            "    }" +
            "   ]" +
            "}";

    public static String userArn;

    public static void main(String[] args) throws Exception {

        final String usage = """

                Usage:
                    <username> <policyName> <roleName> <roleSessionName> <bucketName>\s

                Where:
                    username - The name of the IAM user to create.\s
                    policyName - The name of the policy to create.\s
                    roleName - The name of the role to create.\s
                    roleSessionName - The name of the session required for the assumeRole operation.\s
                    bucketName - The name of the Amazon S3 bucket from which objects are read.\s
                """;

        if (args.length != 5) {
            System.out.println(usage);
            System.exit(1);
        }

        String userName = args[0];
        String policyName = args[1];
        String roleName = args[2];
        String roleSessionName = args[3];
        String bucketName = args[4];

        Region region = Region.AWS_GLOBAL;
        IamClient iam = IamClient.builder()
                .region(region)
                .build();

        System.out.println(DASHES);
        System.out.println("Welcome to the AWS IAM example scenario.");
        System.out.println(DASHES);

        System.out.println(DASHES);
        System.out.println(" 1. Create the IAM user.");
        User createUser = createIAMUser(iam, userName);

        System.out.println(DASHES);
        userArn = createUser.arn();

        AccessKey myKey = createIAMAccessKey(iam, userName);
        String accessKey = myKey.accessKeyId();
        String secretKey = myKey.secretAccessKey();
        String assumeRolePolicyDocument = "{" +
                "\"Version\": \"2012-10-17\"," +
                "\"Statement\": [{" +
                "\"Effect\": \"Allow\"," +
                "\"Principal\": {" +
                "	\"AWS\": \"" + userArn + "\"" +
                "}," +
                "\"Action\": \"sts:AssumeRole\"" +
                "}]" +
                "}";

        System.out.println(assumeRolePolicyDocument);
        System.out.println(userName + " was successfully created.");
        System.out.println(DASHES);
        System.out.println("2. Creates a policy.");
        String polArn = createIAMPolicy(iam, policyName);
        System.out.println("The policy " + polArn + " was successfully created.");
        System.out.println(DASHES);

        System.out.println(DASHES);
        System.out.println("3. Creates a role.");
        TimeUnit.SECONDS.sleep(30);
        String roleArn = createIAMRole(iam, roleName, assumeRolePolicyDocument);
        System.out.println(roleArn + " was successfully created.");
        System.out.println(DASHES);

        System.out.println(DASHES);
        System.out.println("4. Grants the user permissions.");
        attachIAMRolePolicy(iam, roleName, polArn);
        System.out.println(DASHES);

        System.out.println(DASHES);
        System.out.println("*** Wait for 30 secs so the resource is available");
        TimeUnit.SECONDS.sleep(30);
        System.out.println("5. Gets temporary credentials by assuming the role.");
        System.out.println("Perform an Amazon S3 Service operation using the temporary credentials.");
        assumeRole(roleArn, roleSessionName, bucketName, accessKey, secretKey);
        System.out.println(DASHES);

        System.out.println(DASHES);
        System.out.println("6 Getting ready to delete the AWS resources");
        deleteKey(iam, userName, accessKey);
        deleteRole(iam, roleName, polArn);
        deleteIAMUser(iam, userName);
        System.out.println(DASHES);

        System.out.println(DASHES);
        System.out.println("This IAM Scenario has successfully completed");
        System.out.println(DASHES);
    }

    public static AccessKey createIAMAccessKey(IamClient iam, String user) {
        try {
            CreateAccessKeyRequest request = CreateAccessKeyRequest.builder()
                    .userName(user)
                    .build();

            CreateAccessKeyResponse response = iam.createAccessKey(request);
            return response.accessKey();

        } catch (IamException e) {
            System.err.println(e.awsErrorDetails().errorMessage());
            System.exit(1);
        }
        return null;
    }

    public static User createIAMUser(IamClient iam, String username) {
        try {
            // Create an IamWaiter object
            IamWaiter iamWaiter = iam.waiter();
            CreateUserRequest request = CreateUserRequest.builder()
                    .userName(username)
                    .build();

            // Wait until the user is created.
            CreateUserResponse response = iam.createUser(request);
            GetUserRequest userRequest = GetUserRequest.builder()
                    .userName(response.user().userName())
                    .build();

            WaiterResponse<GetUserResponse> waitUntilUserExists = iamWaiter.waitUntilUserExists(userRequest);
            waitUntilUserExists.matched().response().ifPresent(System.out::println);
            return response.user();

        } catch (IamException e) {
            System.err.println(e.awsErrorDetails().errorMessage());
            System.exit(1);
        }
        return null;
    }

    public static String createIAMRole(IamClient iam, String rolename, String json) {

        try {
            CreateRoleRequest request = CreateRoleRequest.builder()
                    .roleName(rolename)
                    .assumeRolePolicyDocument(json)
                    .description("Created using the AWS SDK for Java")
                    .build();

            CreateRoleResponse response = iam.createRole(request);
            System.out.println("The ARN of the role is " + response.role().arn());
            return response.role().arn();

        } catch (IamException e) {
            System.err.println(e.awsErrorDetails().errorMessage());
            System.exit(1);
        }
        return "";
    }

    public static String createIAMPolicy(IamClient iam, String policyName) {
        try {
            // Create an IamWaiter object.
            IamWaiter iamWaiter = iam.waiter();
            CreatePolicyRequest request = CreatePolicyRequest.builder()
                    .policyName(policyName)
                    .policyDocument(PolicyDocument).build();

            CreatePolicyResponse response = iam.createPolicy(request);
            GetPolicyRequest polRequest = GetPolicyRequest.builder()
                    .policyArn(response.policy().arn())
                    .build();

            WaiterResponse<GetPolicyResponse> waitUntilPolicyExists = iamWaiter.waitUntilPolicyExists(polRequest);
            waitUntilPolicyExists.matched().response().ifPresent(System.out::println);
            return response.policy().arn();

        } catch (IamException e) {
            System.err.println(e.awsErrorDetails().errorMessage());
            System.exit(1);
        }
        return "";
    }

    public static void attachIAMRolePolicy(IamClient iam, String roleName, String policyArn) {
        try {
            ListAttachedRolePoliciesRequest request = ListAttachedRolePoliciesRequest.builder()
                    .roleName(roleName)
                    .build();

            ListAttachedRolePoliciesResponse response = iam.listAttachedRolePolicies(request);
            List<AttachedPolicy> attachedPolicies = response.attachedPolicies();
            String polArn;
            for (AttachedPolicy policy : attachedPolicies) {
                polArn = policy.policyArn();
                if (polArn.compareTo(policyArn) == 0) {
                    System.out.println(roleName + " policy is already attached to this role.");
                    return;
                }
            }

            AttachRolePolicyRequest attachRequest = AttachRolePolicyRequest.builder()
                    .roleName(roleName)
                    .policyArn(policyArn)
                    .build();

            iam.attachRolePolicy(attachRequest);
            System.out.println("Successfully attached policy " + policyArn + " to role " + roleName);

        } catch (IamException e) {
            System.err.println(e.awsErrorDetails().errorMessage());
            System.exit(1);
        }
    }

    // Invoke an Amazon S3 operation using the Assumed Role.
    public static void assumeRole(String roleArn, String roleSessionName, String bucketName, String keyVal,
            String keySecret) {

        // Use the creds of the new IAM user that was created in this code example.
        AwsBasicCredentials credentials = AwsBasicCredentials.create(keyVal, keySecret);
        StsClient stsClient = StsClient.builder()
                .region(Region.US_EAST_1)
                .credentialsProvider(StaticCredentialsProvider.create(credentials))
                .build();

        try {
            AssumeRoleRequest roleRequest = AssumeRoleRequest.builder()
                    .roleArn(roleArn)
                    .roleSessionName(roleSessionName)
                    .build();

            AssumeRoleResponse roleResponse = stsClient.assumeRole(roleRequest);
            Credentials myCreds = roleResponse.credentials();
            String key = myCreds.accessKeyId();
            String secKey = myCreds.secretAccessKey();
            String secToken = myCreds.sessionToken();

            // List all objects in an Amazon S3 bucket using the temp creds retrieved by
            // invoking assumeRole.
            Region region = Region.US_EAST_1;
            S3Client s3 = S3Client.builder()
                    .credentialsProvider(
                            StaticCredentialsProvider.create(AwsSessionCredentials.create(key, secKey, secToken)))
                    .region(region)
                    .build();

            System.out.println("Created a S3Client using temp credentials.");
            System.out.println("Listing objects in " + bucketName);
            ListObjectsRequest listObjects = ListObjectsRequest.builder()
                    .bucket(bucketName)
                    .build();

            ListObjectsResponse res = s3.listObjects(listObjects);
            List<S3Object> objects = res.contents();
            for (S3Object myValue : objects) {
                System.out.println("The name of the key is " + myValue.key());
                System.out.println("The owner is " + myValue.owner());
            }

        } catch (StsException e) {
            System.err.println(e.getMessage());
            System.exit(1);
        }
    }

    public static void deleteRole(IamClient iam, String roleName, String polArn) {

        try {
            // First the policy needs to be detached.
            DetachRolePolicyRequest rolePolicyRequest = DetachRolePolicyRequest.builder()
                    .policyArn(polArn)
                    .roleName(roleName)
                    .build();

            iam.detachRolePolicy(rolePolicyRequest);

            // Delete the policy.
            DeletePolicyRequest request = DeletePolicyRequest.builder()
                    .policyArn(polArn)
                    .build();

            iam.deletePolicy(request);
            System.out.println("*** Successfully deleted " + polArn);

            // Delete the role.
            DeleteRoleRequest roleRequest = DeleteRoleRequest.builder()
                    .roleName(roleName)
                    .build();

            iam.deleteRole(roleRequest);
            System.out.println("*** Successfully deleted " + roleName);

        } catch (IamException e) {
            System.err.println(e.awsErrorDetails().errorMessage());
            System.exit(1);
        }
    }

    public static void deleteKey(IamClient iam, String username, String accessKey) {
        try {
            DeleteAccessKeyRequest request = DeleteAccessKeyRequest.builder()
                    .accessKeyId(accessKey)
                    .userName(username)
                    .build();

            iam.deleteAccessKey(request);
            System.out.println("Successfully deleted access key " + accessKey +
                    " from user " + username);

        } catch (IamException e) {
            System.err.println(e.awsErrorDetails().errorMessage());
            System.exit(1);
        }
    }

    public static void deleteIAMUser(IamClient iam, String userName) {
        try {
            DeleteUserRequest request = DeleteUserRequest.builder()
                    .userName(userName)
                    .build();

            iam.deleteUser(request);
            System.out.println("*** Successfully deleted " + userName);

        } catch (IamException e) {
            System.err.println(e.awsErrorDetails().errorMessage());
            System.exit(1);
        }
    }
}
```
+ Per informazioni dettagliate sull’API, consulta i seguenti argomenti nella *documentazione di riferimento dell’API AWS SDK for Java 2.x *.
  + [AttachRolePolicy](https://docs.aws.amazon.com/goto/SdkForJavaV2/iam-2010-05-08/AttachRolePolicy)
  + [CreateAccessKey](https://docs.aws.amazon.com/goto/SdkForJavaV2/iam-2010-05-08/CreateAccessKey)
  + [CreatePolicy](https://docs.aws.amazon.com/goto/SdkForJavaV2/iam-2010-05-08/CreatePolicy)
  + [CreateRole](https://docs.aws.amazon.com/goto/SdkForJavaV2/iam-2010-05-08/CreateRole)
  + [CreateUser](https://docs.aws.amazon.com/goto/SdkForJavaV2/iam-2010-05-08/CreateUser)
  + [DeleteAccessKey](https://docs.aws.amazon.com/goto/SdkForJavaV2/iam-2010-05-08/DeleteAccessKey)
  + [DeletePolicy](https://docs.aws.amazon.com/goto/SdkForJavaV2/iam-2010-05-08/DeletePolicy)
  + [DeleteRole](https://docs.aws.amazon.com/goto/SdkForJavaV2/iam-2010-05-08/DeleteRole)
  + [DeleteUser](https://docs.aws.amazon.com/goto/SdkForJavaV2/iam-2010-05-08/DeleteUser)
  + [DeleteUserPolicy](https://docs.aws.amazon.com/goto/SdkForJavaV2/iam-2010-05-08/DeleteUserPolicy)
  + [DetachRolePolicy](https://docs.aws.amazon.com/goto/SdkForJavaV2/iam-2010-05-08/DetachRolePolicy)
  + [PutUserPolicy](https://docs.aws.amazon.com/goto/SdkForJavaV2/iam-2010-05-08/PutUserPolicy)

------
#### [ JavaScript ]

**SDK per JavaScript (v3)**  
 C'è altro da fare. GitHub Trova l'esempio completo e scopri di più sulla configurazione e l'esecuzione nel [Repository di esempi di codice AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javascriptv3/example_code/iam#code-examples). 
Crea un utente IAM che conceda l’autorizzazione per elencare i bucket Amazon S3. L’utente dispone dei diritti soltanto per assumere il ruolo. Dopo aver assunto il ruolo, utilizza le credenziali temporanee per elencare i bucket per l’account.  

```
import {
  CreateUserCommand,
  GetUserCommand,
  CreateAccessKeyCommand,
  CreatePolicyCommand,
  CreateRoleCommand,
  AttachRolePolicyCommand,
  DeleteAccessKeyCommand,
  DeleteUserCommand,
  DeleteRoleCommand,
  DeletePolicyCommand,
  DetachRolePolicyCommand,
  IAMClient,
} from "@aws-sdk/client-iam";
import { ListBucketsCommand, S3Client } from "@aws-sdk/client-s3";
import { AssumeRoleCommand, STSClient } from "@aws-sdk/client-sts";
import { retry } from "@aws-doc-sdk-examples/lib/utils/util-timers.js";
import { ScenarioInput } from "@aws-doc-sdk-examples/lib/scenario/index.js";

// Set the parameters.
const iamClient = new IAMClient({});
const userName = "iam_basic_test_username";
const policyName = "iam_basic_test_policy";
const roleName = "iam_basic_test_role";

/**
 * Create a new IAM user. If the user already exists, give
 * the option to delete and re-create it.
 * @param {string} name
 */
export const createUser = async (name, confirmAll = false) => {
  try {
    const { User } = await iamClient.send(
      new GetUserCommand({ UserName: name }),
    );
    const input = new ScenarioInput(
      "deleteUser",
      "Do you want to delete and remake this user?",
      { type: "confirm" },
    );
    const deleteUser = await input.handle({}, { confirmAll });
    // If the user exists, and you want to delete it, delete the user
    // and then create it again.
    if (deleteUser) {
      await iamClient.send(new DeleteUserCommand({ UserName: User.UserName }));
      await iamClient.send(new CreateUserCommand({ UserName: name }));
    } else {
      console.warn(
        `${name} already exists. The scenario may not work as expected.`,
      );
      return User;
    }
  } catch (caught) {
    // If there is no user by that name, create one.
    if (caught instanceof Error && caught.name === "NoSuchEntityException") {
      const { User } = await iamClient.send(
        new CreateUserCommand({ UserName: name }),
      );
      return User;
    }
    throw caught;
  }
};

export const main = async (confirmAll = false) => {
  // Create a user. The user has no permissions by default.
  const User = await createUser(userName, confirmAll);

  if (!User) {
    throw new Error("User not created");
  }

  // Create an access key. This key is used to authenticate the new user to
  // Amazon Simple Storage Service (Amazon S3) and AWS Security Token Service (AWS STS).
  // It's not best practice to use access keys. For more information, see https://aws.amazon.com/iam/resources/best-practices/.
  const createAccessKeyResponse = await iamClient.send(
    new CreateAccessKeyCommand({ UserName: userName }),
  );

  if (
    !createAccessKeyResponse.AccessKey?.AccessKeyId ||
    !createAccessKeyResponse.AccessKey?.SecretAccessKey
  ) {
    throw new Error("Access key not created");
  }

  const {
    AccessKey: { AccessKeyId, SecretAccessKey },
  } = createAccessKeyResponse;

  let s3Client = new S3Client({
    credentials: {
      accessKeyId: AccessKeyId,
      secretAccessKey: SecretAccessKey,
    },
  });

  // Retry the list buckets operation until it succeeds. InvalidAccessKeyId is
  // thrown while the user and access keys are still stabilizing.
  await retry({ intervalInMs: 1000, maxRetries: 300 }, async () => {
    try {
      return await listBuckets(s3Client);
    } catch (err) {
      if (err instanceof Error && err.name === "InvalidAccessKeyId") {
        throw err;
      }
    }
  });

  // Retry the create role operation until it succeeds. A MalformedPolicyDocument error
  // is thrown while the user and access keys are still stabilizing.
  const { Role } = await retry(
    {
      intervalInMs: 2000,
      maxRetries: 60,
    },
    () =>
      iamClient.send(
        new CreateRoleCommand({
          AssumeRolePolicyDocument: JSON.stringify({
            Version: "2012-10-17",
            Statement: [
              {
                Effect: "Allow",
                Principal: {
                  // Allow the previously created user to assume this role.
                  AWS: User.Arn,
                },
                Action: "sts:AssumeRole",
              },
            ],
          }),
          RoleName: roleName,
        }),
      ),
  );

  if (!Role) {
    throw new Error("Role not created");
  }

  // Create a policy that allows the user to list S3 buckets.
  const { Policy: listBucketPolicy } = await iamClient.send(
    new CreatePolicyCommand({
      PolicyDocument: JSON.stringify({
        Version: "2012-10-17",
        Statement: [
          {
            Effect: "Allow",
            Action: ["s3:ListAllMyBuckets"],
            Resource: "*",
          },
        ],
      }),
      PolicyName: policyName,
    }),
  );

  if (!listBucketPolicy) {
    throw new Error("Policy not created");
  }

  // Attach the policy granting the 's3:ListAllMyBuckets' action to the role.
  await iamClient.send(
    new AttachRolePolicyCommand({
      PolicyArn: listBucketPolicy.Arn,
      RoleName: Role.RoleName,
    }),
  );

  // Assume the role.
  const stsClient = new STSClient({
    credentials: {
      accessKeyId: AccessKeyId,
      secretAccessKey: SecretAccessKey,
    },
  });

  // Retry the assume role operation until it succeeds.
  const { Credentials } = await retry(
    { intervalInMs: 2000, maxRetries: 60 },
    () =>
      stsClient.send(
        new AssumeRoleCommand({
          RoleArn: Role.Arn,
          RoleSessionName: `iamBasicScenarioSession-${Math.floor(
            Math.random() * 1000000,
          )}`,
          DurationSeconds: 900,
        }),
      ),
  );

  if (!Credentials?.AccessKeyId || !Credentials?.SecretAccessKey) {
    throw new Error("Credentials not created");
  }

  s3Client = new S3Client({
    credentials: {
      accessKeyId: Credentials.AccessKeyId,
      secretAccessKey: Credentials.SecretAccessKey,
      sessionToken: Credentials.SessionToken,
    },
  });

  // List the S3 buckets again.
  // Retry the list buckets operation until it succeeds. AccessDenied might
  // be thrown while the role policy is still stabilizing.
  await retry({ intervalInMs: 2000, maxRetries: 120 }, () =>
    listBuckets(s3Client),
  );

  // Clean up.
  await iamClient.send(
    new DetachRolePolicyCommand({
      PolicyArn: listBucketPolicy.Arn,
      RoleName: Role.RoleName,
    }),
  );

  await iamClient.send(
    new DeletePolicyCommand({
      PolicyArn: listBucketPolicy.Arn,
    }),
  );

  await iamClient.send(
    new DeleteRoleCommand({
      RoleName: Role.RoleName,
    }),
  );

  await iamClient.send(
    new DeleteAccessKeyCommand({
      UserName: userName,
      AccessKeyId,
    }),
  );

  await iamClient.send(
    new DeleteUserCommand({
      UserName: userName,
    }),
  );
};

/**
 *
 * @param {S3Client} s3Client
 */
const listBuckets = async (s3Client) => {
  const { Buckets } = await s3Client.send(new ListBucketsCommand({}));

  if (!Buckets) {
    throw new Error("Buckets not listed");
  }

  console.log(Buckets.map((bucket) => bucket.Name).join("\n"));
};
```
+ Per informazioni dettagliate sull’API, consulta i seguenti argomenti nella *documentazione di riferimento dell’API AWS SDK per JavaScript *.
  + [AttachRolePolicy](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/iam/command/AttachRolePolicyCommand)
  + [CreateAccessKey](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/iam/command/CreateAccessKeyCommand)
  + [CreatePolicy](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/iam/command/CreatePolicyCommand)
  + [CreateRole](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/iam/command/CreateRoleCommand)
  + [CreateUser](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/iam/command/CreateUserCommand)
  + [DeleteAccessKey](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/iam/command/DeleteAccessKeyCommand)
  + [DeletePolicy](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/iam/command/DeletePolicyCommand)
  + [DeleteRole](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/iam/command/DeleteRoleCommand)
  + [DeleteUser](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/iam/command/DeleteUserCommand)
  + [DeleteUserPolicy](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/iam/command/DeleteUserPolicyCommand)
  + [DetachRolePolicy](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/iam/command/DetachRolePolicyCommand)
  + [PutUserPolicy](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/iam/command/PutUserPolicyCommand)

------
#### [ Kotlin ]

**SDK per Kotlin**  
 C'è dell'altro GitHub. Trova l'esempio completo e scopri di più sulla configurazione e l'esecuzione nel [Repository di esempi di codice AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/kotlin/services/iam#code-examples). 
Crea funzioni che eseguono il wrapping delle operazioni degli utenti IAM.  

```
suspend fun main(args: Array<String>) {
    val usage = """
    Usage:
        <username> <policyName> <roleName> <roleSessionName> <fileLocation> <bucketName> 

    Where:
        username - The name of the IAM user to create. 
        policyName - The name of the policy to create. 
        roleName - The name of the role to create. 
        roleSessionName - The name of the session required for the assumeRole operation. 
        fileLocation - The file location to the JSON required to create the role (see Readme). 
        bucketName - The name of the Amazon S3 bucket from which objects are read. 
    """

    if (args.size != 6) {
        println(usage)
        exitProcess(1)
    }

    val userName = args[0]
    val policyName = args[1]
    val roleName = args[2]
    val roleSessionName = args[3]
    val fileLocation = args[4]
    val bucketName = args[5]

    createUser(userName)
    println("$userName was successfully created.")

    val polArn = createPolicy(policyName)
    println("The policy $polArn was successfully created.")

    val roleArn = createRole(roleName, fileLocation)
    println("$roleArn was successfully created.")
    attachRolePolicy(roleName, polArn)

    println("*** Wait for 1 MIN so the resource is available.")
    delay(60000)
    assumeGivenRole(roleArn, roleSessionName, bucketName)

    println("*** Getting ready to delete the AWS resources.")
    deleteRole(roleName, polArn)
    deleteUser(userName)
    println("This IAM Scenario has successfully completed.")
}

suspend fun createUser(usernameVal: String?): String? {
    val request =
        CreateUserRequest {
            userName = usernameVal
        }

    IamClient { region = "AWS_GLOBAL" }.use { iamClient ->
        val response = iamClient.createUser(request)
        return response.user?.userName
    }
}

suspend fun createPolicy(policyNameVal: String?): String {
    val policyDocumentValue = """
    {
        "Version":"2012-10-17",		 	 	 
        "Statement": [
            {
                "Effect": "Allow",
                "Action": [
                    "s3:*"
                ],
                "Resource": "*"
            }
        ]
    }
    """.trimIndent()

    val request =
        CreatePolicyRequest {
            policyName = policyNameVal
            policyDocument = policyDocumentValue
        }

    IamClient.fromEnvironment { region = "AWS_GLOBAL" }.use { iamClient ->
        val response = iamClient.createPolicy(request)
        return response.policy?.arn.toString()
    }
}

suspend fun createRole(
    rolenameVal: String?,
    fileLocation: String?,
): String? {
    val jsonObject = fileLocation?.let { readJsonSimpleDemo(it) } as JSONObject

    val request =
        CreateRoleRequest {
            roleName = rolenameVal
            assumeRolePolicyDocument = jsonObject.toJSONString()
            description = "Created using the AWS SDK for Kotlin"
        }

    IamClient { region = "AWS_GLOBAL" }.use { iamClient ->
        val response = iamClient.createRole(request)
        return response.role?.arn
    }
}

suspend fun attachRolePolicy(
    roleNameVal: String,
    policyArnVal: String,
) {
    val request =
        ListAttachedRolePoliciesRequest {
            roleName = roleNameVal
        }

    IamClient.fromEnvironment { region = "AWS_GLOBAL" }.use { iamClient ->
        val response = iamClient.listAttachedRolePolicies(request)
        val attachedPolicies = response.attachedPolicies

        // Ensure that the policy is not attached to this role.
        val checkStatus: Int
        if (attachedPolicies != null) {
            checkStatus = checkMyList(attachedPolicies, policyArnVal)
            if (checkStatus == -1) {
                return
            }
        }

        val policyRequest =
            AttachRolePolicyRequest {
                roleName = roleNameVal
                policyArn = policyArnVal
            }
        iamClient.attachRolePolicy(policyRequest)
        println("Successfully attached policy $policyArnVal to role $roleNameVal")
    }
}

fun checkMyList(
    attachedPolicies: List<AttachedPolicy>,
    policyArnVal: String,
): Int {
    for (policy in attachedPolicies) {
        val polArn = policy.policyArn.toString()

        if (polArn.compareTo(policyArnVal) == 0) {
            println("The policy is already attached to this role.")
            return -1
        }
    }
    return 0
}

suspend fun assumeGivenRole(
    roleArnVal: String?,
    roleSessionNameVal: String?,
    bucketName: String,
) {
    val stsClient = StsClient.fromEnvironment { region = "us-east-1" }
    val roleRequest =
        AssumeRoleRequest {
            roleArn = roleArnVal
            roleSessionName = roleSessionNameVal
        }

    val roleResponse = stsClient.assumeRole(roleRequest)
    val myCreds = roleResponse.credentials
    val key = myCreds?.accessKeyId
    val secKey = myCreds?.secretAccessKey
    val secToken = myCreds?.sessionToken

    val staticCredentials = StaticCredentialsProvider {
        accessKeyId = key
        secretAccessKey = secKey
        sessionToken = secToken
    }

    // List all objects in an Amazon S3 bucket using the temp creds.
    val s3 = S3Client.fromEnvironment {
        region = "us-east-1"
        credentialsProvider = staticCredentials
    }

    println("Created a S3Client using temp credentials.")
    println("Listing objects in $bucketName")

    val listObjects =
        ListObjectsRequest {
            bucket = bucketName
        }

    val response = s3.listObjects(listObjects)
    response.contents?.forEach { myObject ->
        println("The name of the key is ${myObject.key}")
        println("The owner is ${myObject.owner}")
    }
}

suspend fun deleteRole(
    roleNameVal: String,
    polArn: String,
) {
    val iam = IamClient.fromEnvironment { region = "AWS_GLOBAL" }

    // First the policy needs to be detached.
    val rolePolicyRequest =
        DetachRolePolicyRequest {
            policyArn = polArn
            roleName = roleNameVal
        }

    iam.detachRolePolicy(rolePolicyRequest)

    // Delete the policy.
    val request =
        DeletePolicyRequest {
            policyArn = polArn
        }

    iam.deletePolicy(request)
    println("*** Successfully deleted $polArn")

    // Delete the role.
    val roleRequest =
        DeleteRoleRequest {
            roleName = roleNameVal
        }

    iam.deleteRole(roleRequest)
    println("*** Successfully deleted $roleNameVal")
}

suspend fun deleteUser(userNameVal: String) {
    val iam = IamClient.fromEnvironment { region = "AWS_GLOBAL" }
    val request =
        DeleteUserRequest {
            userName = userNameVal
        }

    iam.deleteUser(request)
    println("*** Successfully deleted $userNameVal")
}

@Throws(java.lang.Exception::class)
fun readJsonSimpleDemo(filename: String): Any? {
    val reader = FileReader(filename)
    val jsonParser = JSONParser()
    return jsonParser.parse(reader)
}
```
+ Per informazioni dettagliate sull’API, consulta i seguenti argomenti nella *documentazione di riferimento dell’API AWS SDK per Kotlin*.
  + [AttachRolePolicy](https://sdk.amazonaws.com/kotlin/api/latest/index.html)
  + [CreateAccessKey](https://sdk.amazonaws.com/kotlin/api/latest/index.html)
  + [CreatePolicy](https://sdk.amazonaws.com/kotlin/api/latest/index.html)
  + [CreateRole](https://sdk.amazonaws.com/kotlin/api/latest/index.html)
  + [CreateUser](https://sdk.amazonaws.com/kotlin/api/latest/index.html)
  + [DeleteAccessKey](https://sdk.amazonaws.com/kotlin/api/latest/index.html)
  + [DeletePolicy](https://sdk.amazonaws.com/kotlin/api/latest/index.html)
  + [DeleteRole](https://sdk.amazonaws.com/kotlin/api/latest/index.html)
  + [DeleteUser](https://sdk.amazonaws.com/kotlin/api/latest/index.html)
  + [DeleteUserPolicy](https://sdk.amazonaws.com/kotlin/api/latest/index.html)
  + [DetachRolePolicy](https://sdk.amazonaws.com/kotlin/api/latest/index.html)
  + [PutUserPolicy](https://sdk.amazonaws.com/kotlin/api/latest/index.html)

------
#### [ PHP ]

**SDK per PHP**  
 C'è dell'altro GitHub. Trova l'esempio completo e scopri di più sulla configurazione e l'esecuzione nel [Repository di esempi di codice AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/php/example_code/iam#code-examples). 

```
namespace Iam\Basics;

require 'vendor/autoload.php';

use Aws\Credentials\Credentials;
use Aws\S3\Exception\S3Exception;
use Aws\S3\S3Client;
use Aws\Sts\StsClient;
use Iam\IAMService;

echo("\n");
echo("--------------------------------------\n");
print("Welcome to the IAM getting started demo using PHP!\n");
echo("--------------------------------------\n");

$uuid = uniqid();
$service = new IAMService();

$user = $service->createUser("iam_demo_user_$uuid");
echo "Created user with the arn: {$user['Arn']}\n";

$key = $service->createAccessKey($user['UserName']);
$assumeRolePolicyDocument = "{
                \"Version\": \"2012-10-17\",
                \"Statement\": [{
                    \"Effect\": \"Allow\",
                    \"Principal\": {\"AWS\": \"{$user['Arn']}\"},
                    \"Action\": \"sts:AssumeRole\"
                }]
            }";
$assumeRoleRole = $service->createRole("iam_demo_role_$uuid", $assumeRolePolicyDocument);
echo "Created role: {$assumeRoleRole['RoleName']}\n";

$listAllBucketsPolicyDocument = "{
                \"Version\": \"2012-10-17\",
                \"Statement\": [{
                    \"Effect\": \"Allow\",
                    \"Action\": \"s3:ListAllMyBuckets\",
                    \"Resource\": \"arn:aws:s3:::*\"}]
}";
$listAllBucketsPolicy = $service->createPolicy("iam_demo_policy_$uuid", $listAllBucketsPolicyDocument);
echo "Created policy: {$listAllBucketsPolicy['PolicyName']}\n";

$service->attachRolePolicy($assumeRoleRole['RoleName'], $listAllBucketsPolicy['Arn']);

$inlinePolicyDocument = "{
                \"Version\": \"2012-10-17\",
                \"Statement\": [{
                    \"Effect\": \"Allow\",
                    \"Action\": \"sts:AssumeRole\",
                    \"Resource\": \"{$assumeRoleRole['Arn']}\"}]
}";
$inlinePolicy = $service->createUserPolicy("iam_demo_inline_policy_$uuid", $inlinePolicyDocument, $user['UserName']);
//First, fail to list the buckets with the user
$credentials = new Credentials($key['AccessKeyId'], $key['SecretAccessKey']);
$s3Client = new S3Client(['region' => 'us-west-2', 'version' => 'latest', 'credentials' => $credentials]);
try {
    $s3Client->listBuckets([
    ]);
    echo "this should not run";
} catch (S3Exception $exception) {
    echo "successfully failed!\n";
}

$stsClient = new StsClient(['region' => 'us-west-2', 'version' => 'latest', 'credentials' => $credentials]);
sleep(10);
$assumedRole = $stsClient->assumeRole([
    'RoleArn' => $assumeRoleRole['Arn'],
    'RoleSessionName' => "DemoAssumeRoleSession_$uuid",
]);
$assumedCredentials = [
    'key' => $assumedRole['Credentials']['AccessKeyId'],
    'secret' => $assumedRole['Credentials']['SecretAccessKey'],
    'token' => $assumedRole['Credentials']['SessionToken'],
];
$s3Client = new S3Client(['region' => 'us-west-2', 'version' => 'latest', 'credentials' => $assumedCredentials]);
try {
    $s3Client->listBuckets([]);
    echo "this should now run!\n";
} catch (S3Exception $exception) {
    echo "this should now not fail\n";
}

$service->detachRolePolicy($assumeRoleRole['RoleName'], $listAllBucketsPolicy['Arn']);
$deletePolicy = $service->deletePolicy($listAllBucketsPolicy['Arn']);
echo "Delete policy: {$listAllBucketsPolicy['PolicyName']}\n";
$deletedRole = $service->deleteRole($assumeRoleRole['Arn']);
echo "Deleted role: {$assumeRoleRole['RoleName']}\n";
$deletedKey = $service->deleteAccessKey($key['AccessKeyId'], $user['UserName']);
$deletedUser = $service->deleteUser($user['UserName']);
echo "Delete user: {$user['UserName']}\n";
```
+ Per informazioni dettagliate sull'API, consulta i seguenti argomenti nella *documentazione di riferimento dell’API AWS SDK per PHP *.
  + [AttachRolePolicy](https://docs.aws.amazon.com/goto/SdkForPHPV3/iam-2010-05-08/AttachRolePolicy)
  + [CreateAccessKey](https://docs.aws.amazon.com/goto/SdkForPHPV3/iam-2010-05-08/CreateAccessKey)
  + [CreatePolicy](https://docs.aws.amazon.com/goto/SdkForPHPV3/iam-2010-05-08/CreatePolicy)
  + [CreateRole](https://docs.aws.amazon.com/goto/SdkForPHPV3/iam-2010-05-08/CreateRole)
  + [CreateUser](https://docs.aws.amazon.com/goto/SdkForPHPV3/iam-2010-05-08/CreateUser)
  + [DeleteAccessKey](https://docs.aws.amazon.com/goto/SdkForPHPV3/iam-2010-05-08/DeleteAccessKey)
  + [DeletePolicy](https://docs.aws.amazon.com/goto/SdkForPHPV3/iam-2010-05-08/DeletePolicy)
  + [DeleteRole](https://docs.aws.amazon.com/goto/SdkForPHPV3/iam-2010-05-08/DeleteRole)
  + [DeleteUser](https://docs.aws.amazon.com/goto/SdkForPHPV3/iam-2010-05-08/DeleteUser)
  + [DeleteUserPolicy](https://docs.aws.amazon.com/goto/SdkForPHPV3/iam-2010-05-08/DeleteUserPolicy)
  + [DetachRolePolicy](https://docs.aws.amazon.com/goto/SdkForPHPV3/iam-2010-05-08/DetachRolePolicy)
  + [PutUserPolicy](https://docs.aws.amazon.com/goto/SdkForPHPV3/iam-2010-05-08/PutUserPolicy)

------
#### [ Python ]

**SDK per Python (Boto3)**  
 C'è dell'altro GitHub. Trova l'esempio completo e scopri di più sulla configurazione e l'esecuzione nel [Repository di esempi di codice AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/python/example_code/iam#code-examples). 
Crea un utente IAM che conceda l’autorizzazione per elencare i bucket Amazon S3. L’utente dispone dei diritti soltanto per assumere il ruolo. Dopo aver assunto il ruolo, utilizza le credenziali temporanee per elencare i bucket per l'account.  

```
import json
import sys
import time
from uuid import uuid4

import boto3
from botocore.exceptions import ClientError


def progress_bar(seconds):
    """Shows a simple progress bar in the command window."""
    for _ in range(seconds):
        time.sleep(1)
        print(".", end="")
        sys.stdout.flush()
    print()


def setup(iam_resource):
    """
    Creates a new user with no permissions.
    Creates an access key pair for the user.
    Creates a role with a policy that lets the user assume the role.
    Creates a policy that allows listing Amazon S3 buckets.
    Attaches the policy to the role.
    Creates an inline policy for the user that lets the user assume the role.

    :param iam_resource: A Boto3 AWS Identity and Access Management (IAM) resource
                         that has permissions to create users, roles, and policies
                         in the account.
    :return: The newly created user, user key, and role.
    """
    try:
        user = iam_resource.create_user(UserName=f"demo-user-{uuid4()}")
        print(f"Created user {user.name}.")
    except ClientError as error:
        print(
            f"Couldn't create a user for the demo. Here's why: "
            f"{error.response['Error']['Message']}"
        )
        raise

    try:
        user_key = user.create_access_key_pair()
        print(f"Created access key pair for user.")
    except ClientError as error:
        print(
            f"Couldn't create access keys for user {user.name}. Here's why: "
            f"{error.response['Error']['Message']}"
        )
        raise

    print(f"Wait for user to be ready.", end="")
    progress_bar(10)

    try:
        role = iam_resource.create_role(
            RoleName=f"demo-role-{uuid4()}",
            AssumeRolePolicyDocument=json.dumps(
                {
                    "Version":"2012-10-17",		 	 	 
                    "Statement": [
                        {
                            "Effect": "Allow",
                            "Principal": {"AWS": user.arn},
                            "Action": "sts:AssumeRole",
                        }
                    ],
                }
            ),
        )
        print(f"Created role {role.name}.")
    except ClientError as error:
        print(
            f"Couldn't create a role for the demo. Here's why: "
            f"{error.response['Error']['Message']}"
        )
        raise

    try:
        policy = iam_resource.create_policy(
            PolicyName=f"demo-policy-{uuid4()}",
            PolicyDocument=json.dumps(
                {
                    "Version":"2012-10-17",		 	 	 
                    "Statement": [
                        {
                            "Effect": "Allow",
                            "Action": "s3:ListAllMyBuckets",
                            "Resource": "arn:aws:s3:::*",
                        }
                    ],
                }
            ),
        )
        role.attach_policy(PolicyArn=policy.arn)
        print(f"Created policy {policy.policy_name} and attached it to the role.")
    except ClientError as error:
        print(
            f"Couldn't create a policy and attach it to role {role.name}. Here's why: "
            f"{error.response['Error']['Message']}"
        )
        raise

    try:
        user.create_policy(
            PolicyName=f"demo-user-policy-{uuid4()}",
            PolicyDocument=json.dumps(
                {
                    "Version":"2012-10-17",		 	 	 
                    "Statement": [
                        {
                            "Effect": "Allow",
                            "Action": "sts:AssumeRole",
                            "Resource": role.arn,
                        }
                    ],
                }
            ),
        )
        print(
            f"Created an inline policy for {user.name} that lets the user assume "
            f"the role."
        )
    except ClientError as error:
        print(
            f"Couldn't create an inline policy for user {user.name}. Here's why: "
            f"{error.response['Error']['Message']}"
        )
        raise

    print("Give AWS time to propagate these new resources and connections.", end="")
    progress_bar(10)

    return user, user_key, role


def show_access_denied_without_role(user_key):
    """
    Shows that listing buckets without first assuming the role is not allowed.

    :param user_key: The key of the user created during setup. This user does not
                     have permission to list buckets in the account.
    """
    print(f"Try to list buckets without first assuming the role.")
    s3_denied_resource = boto3.resource(
        "s3", aws_access_key_id=user_key.id, aws_secret_access_key=user_key.secret
    )
    try:
        for bucket in s3_denied_resource.buckets.all():
            print(bucket.name)
        raise RuntimeError("Expected to get AccessDenied error when listing buckets!")
    except ClientError as error:
        if error.response["Error"]["Code"] == "AccessDenied":
            print("Attempt to list buckets with no permissions: AccessDenied.")
        else:
            raise


def list_buckets_from_assumed_role(user_key, assume_role_arn, session_name):
    """
    Assumes a role that grants permission to list the Amazon S3 buckets in the account.
    Uses the temporary credentials from the role to list the buckets that are owned
    by the assumed role's account.

    :param user_key: The access key of a user that has permission to assume the role.
    :param assume_role_arn: The Amazon Resource Name (ARN) of the role that
                            grants access to list the other account's buckets.
    :param session_name: The name of the STS session.
    """
    sts_client = boto3.client(
        "sts", aws_access_key_id=user_key.id, aws_secret_access_key=user_key.secret
    )
    try:
        response = sts_client.assume_role(
            RoleArn=assume_role_arn, RoleSessionName=session_name
        )
        temp_credentials = response["Credentials"]
        print(f"Assumed role {assume_role_arn} and got temporary credentials.")
    except ClientError as error:
        print(
            f"Couldn't assume role {assume_role_arn}. Here's why: "
            f"{error.response['Error']['Message']}"
        )
        raise

    # Create an S3 resource that can access the account with the temporary credentials.
    s3_resource = boto3.resource(
        "s3",
        aws_access_key_id=temp_credentials["AccessKeyId"],
        aws_secret_access_key=temp_credentials["SecretAccessKey"],
        aws_session_token=temp_credentials["SessionToken"],
    )
    print(f"Listing buckets for the assumed role's account:")
    try:
        for bucket in s3_resource.buckets.all():
            print(bucket.name)
    except ClientError as error:
        print(
            f"Couldn't list buckets for the account. Here's why: "
            f"{error.response['Error']['Message']}"
        )
        raise




def teardown(user, role):
    """
    Removes all resources created during setup.

    :param user: The demo user.
    :param role: The demo role.
    """
    try:
        for attached in role.attached_policies.all():
            policy_name = attached.policy_name
            role.detach_policy(PolicyArn=attached.arn)
            attached.delete()
            print(f"Detached and deleted {policy_name}.")
        role.delete()
        print(f"Deleted {role.name}.")
    except ClientError as error:
        print(
            "Couldn't detach policy, delete policy, or delete role. Here's why: "
            f"{error.response['Error']['Message']}"
        )
        raise

    try:
        for user_pol in user.policies.all():
            user_pol.delete()
            print("Deleted inline user policy.")
        for key in user.access_keys.all():
            key.delete()
            print("Deleted user's access key.")
        user.delete()
        print(f"Deleted {user.name}.")
    except ClientError as error:
        print(
            "Couldn't delete user policy or delete user. Here's why: "
            f"{error.response['Error']['Message']}"
        )


def usage_demo():
    """Drives the demonstration."""
    print("-" * 88)
    print(f"Welcome to the IAM create user and assume role demo.")
    print("-" * 88)
    iam_resource = boto3.resource("iam")
    user = None
    role = None
    try:
        user, user_key, role = setup(iam_resource)
        print(f"Created {user.name} and {role.name}.")
        show_access_denied_without_role(user_key)
        list_buckets_from_assumed_role(user_key, role.arn, "AssumeRoleDemoSession")
    except Exception:
        print("Something went wrong!")
    finally:
        if user is not None and role is not None:
            teardown(user, role)
        print("Thanks for watching!")


if __name__ == "__main__":
    usage_demo()
```
+ Per informazioni dettagliate sull’API, consulta i seguenti argomenti nella *documentazione di riferimento dell’API AWS SDK per Python (Boto3)*.
  + [AttachRolePolicy](https://docs.aws.amazon.com/goto/boto3/iam-2010-05-08/AttachRolePolicy)
  + [CreateAccessKey](https://docs.aws.amazon.com/goto/boto3/iam-2010-05-08/CreateAccessKey)
  + [CreatePolicy](https://docs.aws.amazon.com/goto/boto3/iam-2010-05-08/CreatePolicy)
  + [CreateRole](https://docs.aws.amazon.com/goto/boto3/iam-2010-05-08/CreateRole)
  + [CreateUser](https://docs.aws.amazon.com/goto/boto3/iam-2010-05-08/CreateUser)
  + [DeleteAccessKey](https://docs.aws.amazon.com/goto/boto3/iam-2010-05-08/DeleteAccessKey)
  + [DeletePolicy](https://docs.aws.amazon.com/goto/boto3/iam-2010-05-08/DeletePolicy)
  + [DeleteRole](https://docs.aws.amazon.com/goto/boto3/iam-2010-05-08/DeleteRole)
  + [DeleteUser](https://docs.aws.amazon.com/goto/boto3/iam-2010-05-08/DeleteUser)
  + [DeleteUserPolicy](https://docs.aws.amazon.com/goto/boto3/iam-2010-05-08/DeleteUserPolicy)
  + [DetachRolePolicy](https://docs.aws.amazon.com/goto/boto3/iam-2010-05-08/DetachRolePolicy)
  + [PutUserPolicy](https://docs.aws.amazon.com/goto/boto3/iam-2010-05-08/PutUserPolicy)

------
#### [ Ruby ]

**SDK per Ruby**  
 C'è dell'altro GitHub. Trova l'esempio completo e scopri di più sulla configurazione e l'esecuzione nel [Repository di esempi di codice AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/ruby/example_code/iam#code-examples). 
Crea un utente IAM che conceda l’autorizzazione per elencare i bucket Amazon S3. L’utente dispone dei diritti soltanto per assumere il ruolo. Dopo aver assunto il ruolo, utilizza le credenziali temporanee per elencare i bucket per l’account.  

```
# Wraps the scenario actions.
class ScenarioCreateUserAssumeRole
  attr_reader :iam_client

  # @param [Aws::IAM::Client] iam_client: The AWS IAM client.
  def initialize(iam_client, logger: Logger.new($stdout))
    @iam_client = iam_client
    @logger = logger
  end

  # Waits for the specified number of seconds.
  #
  # @param duration [Integer] The number of seconds to wait.
  def wait(duration)
    puts('Give AWS time to propagate resources...')
    sleep(duration)
  end

  # Creates a user.
  #
  # @param user_name [String] The name to give the user.
  # @return [Aws::IAM::User] The newly created user.
  def create_user(user_name)
    user = @iam_client.create_user(user_name: user_name).user
    @logger.info("Created demo user named #{user.user_name}.")
  rescue Aws::Errors::ServiceError => e
    @logger.info('Tried and failed to create demo user.')
    @logger.info("\t#{e.code}: #{e.message}")
    @logger.info("\nCan't continue the demo without a user!")
    raise
  else
    user
  end

  # Creates an access key for a user.
  #
  # @param user [Aws::IAM::User] The user that owns the key.
  # @return [Aws::IAM::AccessKeyPair] The newly created access key.
  def create_access_key_pair(user)
    user_key = @iam_client.create_access_key(user_name: user.user_name).access_key
    @logger.info("Created accesskey pair for user #{user.user_name}.")
  rescue Aws::Errors::ServiceError => e
    @logger.info("Couldn't create access keys for user #{user.user_name}.")
    @logger.info("\t#{e.code}: #{e.message}")
    raise
  else
    user_key
  end

  # Creates a role that can be assumed by a user.
  #
  # @param role_name [String] The name to give the role.
  # @param user [Aws::IAM::User] The user who is granted permission to assume the role.
  # @return [Aws::IAM::Role] The newly created role.
  def create_role(role_name, user)
    trust_policy = {
      Version: '2012-10-17',
      Statement: [{
        Effect: 'Allow',
        Principal: { 'AWS': user.arn },
        Action: 'sts:AssumeRole'
      }]
    }.to_json
    role = @iam_client.create_role(
      role_name: role_name,
      assume_role_policy_document: trust_policy
    ).role
    @logger.info("Created role #{role.role_name}.")
  rescue Aws::Errors::ServiceError => e
    @logger.info("Couldn't create a role for the demo. Here's why: ")
    @logger.info("\t#{e.code}: #{e.message}")
    raise
  else
    role
  end

  # Creates a policy that grants permission to list S3 buckets in the account, and
  # then attaches the policy to a role.
  #
  # @param policy_name [String] The name to give the policy.
  # @param role [Aws::IAM::Role] The role that the policy is attached to.
  # @return [Aws::IAM::Policy] The newly created policy.
  def create_and_attach_role_policy(policy_name, role)
    policy_document = {
      Version: '2012-10-17',
      Statement: [{
        Effect: 'Allow',
        Action: 's3:ListAllMyBuckets',
        Resource: 'arn:aws:s3:::*'
      }]
    }.to_json
    policy = @iam_client.create_policy(
      policy_name: policy_name,
      policy_document: policy_document
    ).policy
    @iam_client.attach_role_policy(
      role_name: role.role_name,
      policy_arn: policy.arn
    )
    @logger.info("Created policy #{policy.policy_name} and attached it to role #{role.role_name}.")
  rescue Aws::Errors::ServiceError => e
    @logger.info("Couldn't create a policy and attach it to role #{role.role_name}. Here's why: ")
    @logger.info("\t#{e.code}: #{e.message}")
    raise
  end

  # Creates an inline policy for a user that lets the user assume a role.
  #
  # @param policy_name [String] The name to give the policy.
  # @param user [Aws::IAM::User] The user that owns the policy.
  # @param role [Aws::IAM::Role] The role that can be assumed.
  # @return [Aws::IAM::UserPolicy] The newly created policy.
  def create_user_policy(policy_name, user, role)
    policy_document = {
      Version: '2012-10-17',
      Statement: [{
        Effect: 'Allow',
        Action: 'sts:AssumeRole',
        Resource: role.arn
      }]
    }.to_json
    @iam_client.put_user_policy(
      user_name: user.user_name,
      policy_name: policy_name,
      policy_document: policy_document
    )
    puts("Created an inline policy for #{user.user_name} that lets the user assume role #{role.role_name}.")
  rescue Aws::Errors::ServiceError => e
    @logger.info("Couldn't create an inline policy for user #{user.user_name}. Here's why: ")
    @logger.info("\t#{e.code}: #{e.message}")
    raise
  end

  # Creates an Amazon S3 resource with specified credentials. This is separated into a
  # factory function so that it can be mocked for unit testing.
  #
  # @param credentials [Aws::Credentials] The credentials used by the Amazon S3 resource.
  def create_s3_resource(credentials)
    Aws::S3::Resource.new(client: Aws::S3::Client.new(credentials: credentials))
  end

  # Lists the S3 buckets for the account, using the specified Amazon S3 resource.
  # Because the resource uses credentials with limited access, it may not be able to
  # list the S3 buckets.
  #
  # @param s3_resource [Aws::S3::Resource] An Amazon S3 resource.
  def list_buckets(s3_resource)
    count = 10
    s3_resource.buckets.each do |bucket|
      @logger.info "\t#{bucket.name}"
      count -= 1
      break if count.zero?
    end
  rescue Aws::Errors::ServiceError => e
    if e.code == 'AccessDenied'
      puts('Attempt to list buckets with no permissions: AccessDenied.')
    else
      @logger.info("Couldn't list buckets for the account. Here's why: ")
      @logger.info("\t#{e.code}: #{e.message}")
      raise
    end
  end

  # Creates an AWS Security Token Service (AWS STS) client with specified credentials.
  # This is separated into a factory function so that it can be mocked for unit testing.
  #
  # @param key_id [String] The ID of the access key used by the STS client.
  # @param key_secret [String] The secret part of the access key used by the STS client.
  def create_sts_client(key_id, key_secret)
    Aws::STS::Client.new(access_key_id: key_id, secret_access_key: key_secret)
  end

  # Gets temporary credentials that can be used to assume a role.
  #
  # @param role_arn [String] The ARN of the role that is assumed when these credentials
  #                          are used.
  # @param sts_client [AWS::STS::Client] An AWS STS client.
  # @return [Aws::AssumeRoleCredentials] The credentials that can be used to assume the role.
  def assume_role(role_arn, sts_client)
    credentials = Aws::AssumeRoleCredentials.new(
      client: sts_client,
      role_arn: role_arn,
      role_session_name: 'create-use-assume-role-scenario'
    )
    @logger.info("Assumed role '#{role_arn}', got temporary credentials.")
    credentials
  end

  # Deletes a role. If the role has policies attached, they are detached and
  # deleted before the role is deleted.
  #
  # @param role_name [String] The name of the role to delete.
  def delete_role(role_name)
    @iam_client.list_attached_role_policies(role_name: role_name).attached_policies.each do |policy|
      @iam_client.detach_role_policy(role_name: role_name, policy_arn: policy.policy_arn)
      @iam_client.delete_policy(policy_arn: policy.policy_arn)
      @logger.info("Detached and deleted policy #{policy.policy_name}.")
    end
    @iam_client.delete_role({ role_name: role_name })
    @logger.info("Role deleted: #{role_name}.")
  rescue Aws::Errors::ServiceError => e
    @logger.info("Couldn't detach policies and delete role #{role.name}. Here's why:")
    @logger.info("\t#{e.code}: #{e.message}")
    raise
  end

  # Deletes a user. If the user has inline policies or access keys, they are deleted
  # before the user is deleted.
  #
  # @param user [Aws::IAM::User] The user to delete.
  def delete_user(user_name)
    user = @iam_client.list_access_keys(user_name: user_name).access_key_metadata
    user.each do |key|
      @iam_client.delete_access_key({ access_key_id: key.access_key_id, user_name: user_name })
      @logger.info("Deleted access key #{key.access_key_id} for user '#{user_name}'.")
    end

    @iam_client.delete_user(user_name: user_name)
    @logger.info("Deleted user '#{user_name}'.")
  rescue Aws::IAM::Errors::ServiceError => e
    @logger.error("Error deleting user '#{user_name}': #{e.message}")
  end
end

# Runs the IAM create a user and assume a role scenario.
def run_scenario(scenario)
  puts('-' * 88)
  puts('Welcome to the IAM create a user and assume a role demo!')
  puts('-' * 88)
  user = scenario.create_user("doc-example-user-#{Random.uuid}")
  user_key = scenario.create_access_key_pair(user)
  scenario.wait(10)
  role = scenario.create_role("doc-example-role-#{Random.uuid}", user)
  scenario.create_and_attach_role_policy("doc-example-role-policy-#{Random.uuid}", role)
  scenario.create_user_policy("doc-example-user-policy-#{Random.uuid}", user, role)
  scenario.wait(10)
  puts('Try to list buckets with credentials for a user who has no permissions.')
  puts('Expect AccessDenied from this call.')
  scenario.list_buckets(
    scenario.create_s3_resource(Aws::Credentials.new(user_key.access_key_id, user_key.secret_access_key))
  )
  puts('Now, assume the role that grants permission.')
  temp_credentials = scenario.assume_role(
    role.arn, scenario.create_sts_client(user_key.access_key_id, user_key.secret_access_key)
  )
  puts('Here are your buckets:')
  scenario.list_buckets(scenario.create_s3_resource(temp_credentials))
  puts("Deleting role '#{role.role_name}' and attached policies.")
  scenario.delete_role(role.role_name)
  puts("Deleting user '#{user.user_name}', policies, and keys.")
  scenario.delete_user(user.user_name)
  puts('Thanks for watching!')
  puts('-' * 88)
rescue Aws::Errors::ServiceError => e
  puts('Something went wrong with the demo.')
  puts("\t#{e.code}: #{e.message}")
end

run_scenario(ScenarioCreateUserAssumeRole.new(Aws::IAM::Client.new)) if $PROGRAM_NAME == __FILE__
```
+ Per informazioni dettagliate sull’API, consulta i seguenti argomenti nella *documentazione di riferimento dell’API AWS SDK per Ruby *.
  + [AttachRolePolicy](https://docs.aws.amazon.com/goto/SdkForRubyV3/iam-2010-05-08/AttachRolePolicy)
  + [CreateAccessKey](https://docs.aws.amazon.com/goto/SdkForRubyV3/iam-2010-05-08/CreateAccessKey)
  + [CreatePolicy](https://docs.aws.amazon.com/goto/SdkForRubyV3/iam-2010-05-08/CreatePolicy)
  + [CreateRole](https://docs.aws.amazon.com/goto/SdkForRubyV3/iam-2010-05-08/CreateRole)
  + [CreateUser](https://docs.aws.amazon.com/goto/SdkForRubyV3/iam-2010-05-08/CreateUser)
  + [DeleteAccessKey](https://docs.aws.amazon.com/goto/SdkForRubyV3/iam-2010-05-08/DeleteAccessKey)
  + [DeletePolicy](https://docs.aws.amazon.com/goto/SdkForRubyV3/iam-2010-05-08/DeletePolicy)
  + [DeleteRole](https://docs.aws.amazon.com/goto/SdkForRubyV3/iam-2010-05-08/DeleteRole)
  + [DeleteUser](https://docs.aws.amazon.com/goto/SdkForRubyV3/iam-2010-05-08/DeleteUser)
  + [DeleteUserPolicy](https://docs.aws.amazon.com/goto/SdkForRubyV3/iam-2010-05-08/DeleteUserPolicy)
  + [DetachRolePolicy](https://docs.aws.amazon.com/goto/SdkForRubyV3/iam-2010-05-08/DetachRolePolicy)
  + [PutUserPolicy](https://docs.aws.amazon.com/goto/SdkForRubyV3/iam-2010-05-08/PutUserPolicy)

------
#### [ Rust ]

**SDK per Rust**  
 C'è altro da fare. GitHub Trova l'esempio completo e scopri di più sulla configurazione e l'esecuzione nel [Repository di esempi di codice AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/rustv1/examples/iam#code-examples). 

```
use aws_config::meta::region::RegionProviderChain;
use aws_sdk_iam::Error as iamError;
use aws_sdk_iam::{config::Credentials as iamCredentials, config::Region, Client as iamClient};
use aws_sdk_s3::Client as s3Client;
use aws_sdk_sts::Client as stsClient;
use tokio::time::{sleep, Duration};
use uuid::Uuid;

#[tokio::main]
async fn main() -> Result<(), iamError> {
    let (client, uuid, list_all_buckets_policy_document, inline_policy_document) =
        initialize_variables().await;

    if let Err(e) = run_iam_operations(
        client,
        uuid,
        list_all_buckets_policy_document,
        inline_policy_document,
    )
    .await
    {
        println!("{:?}", e);
    };

    Ok(())
}

async fn initialize_variables() -> (iamClient, String, String, String) {
    let region_provider = RegionProviderChain::first_try(Region::new("us-west-2"));

    let shared_config = aws_config::from_env().region(region_provider).load().await;
    let client = iamClient::new(&shared_config);
    let uuid = Uuid::new_v4().to_string();

    let list_all_buckets_policy_document = "{
                \"Version\": \"2012-10-17\",
                \"Statement\": [{
                    \"Effect\": \"Allow\",
                    \"Action\": \"s3:ListAllMyBuckets\",
                    \"Resource\": \"arn:aws:s3:::*\"}]
    }"
    .to_string();
    let inline_policy_document = "{
                \"Version\": \"2012-10-17\",
                \"Statement\": [{
                    \"Effect\": \"Allow\",
                    \"Action\": \"sts:AssumeRole\",
                    \"Resource\": \"{}\"}]
    }"
    .to_string();

    (
        client,
        uuid,
        list_all_buckets_policy_document,
        inline_policy_document,
    )
}

async fn run_iam_operations(
    client: iamClient,
    uuid: String,
    list_all_buckets_policy_document: String,
    inline_policy_document: String,
) -> Result<(), iamError> {
    let user = iam_service::create_user(&client, &format!("{}{}", "iam_demo_user_", uuid)).await?;
    println!("Created the user with the name: {}", user.user_name());
    let key = iam_service::create_access_key(&client, user.user_name()).await?;

    let assume_role_policy_document = "{
        \"Version\": \"2012-10-17\",
                \"Statement\": [{
                    \"Effect\": \"Allow\",
                    \"Principal\": {\"AWS\": \"{}\"},
                    \"Action\": \"sts:AssumeRole\"
                }]
            }"
    .to_string()
    .replace("{}", user.arn());

    let assume_role_role = iam_service::create_role(
        &client,
        &format!("{}{}", "iam_demo_role_", uuid),
        &assume_role_policy_document,
    )
    .await?;
    println!("Created the role with the ARN: {}", assume_role_role.arn());

    let list_all_buckets_policy = iam_service::create_policy(
        &client,
        &format!("{}{}", "iam_demo_policy_", uuid),
        &list_all_buckets_policy_document,
    )
    .await?;
    println!(
        "Created policy: {}",
        list_all_buckets_policy.policy_name.as_ref().unwrap()
    );

    let attach_role_policy_result =
        iam_service::attach_role_policy(&client, &assume_role_role, &list_all_buckets_policy)
            .await?;
    println!(
        "Attached the policy to the role: {:?}",
        attach_role_policy_result
    );

    let inline_policy_name = format!("{}{}", "iam_demo_inline_policy_", uuid);
    let inline_policy_document = inline_policy_document.replace("{}", assume_role_role.arn());
    iam_service::create_user_policy(&client, &user, &inline_policy_name, &inline_policy_document)
        .await?;
    println!("Created inline policy.");

    //First, fail to list the buckets with the user.
    let creds = iamCredentials::from_keys(key.access_key_id(), key.secret_access_key(), None);
    let fail_config = aws_config::from_env()
        .credentials_provider(creds.clone())
        .load()
        .await;
    println!("Fail config: {:?}", fail_config);
    let fail_client: s3Client = s3Client::new(&fail_config);
    match fail_client.list_buckets().send().await {
        Ok(e) => {
            println!("This should not run. {:?}", e);
        }
        Err(e) => {
            println!("Successfully failed with error: {:?}", e)
        }
    }

    let sts_config = aws_config::from_env()
        .credentials_provider(creds.clone())
        .load()
        .await;
    let sts_client: stsClient = stsClient::new(&sts_config);
    sleep(Duration::from_secs(10)).await;
    let assumed_role = sts_client
        .assume_role()
        .role_arn(assume_role_role.arn())
        .role_session_name(format!("iam_demo_assumerole_session_{uuid}"))
        .send()
        .await;
    println!("Assumed role: {:?}", assumed_role);
    sleep(Duration::from_secs(10)).await;

    let assumed_credentials = iamCredentials::from_keys(
        assumed_role
            .as_ref()
            .unwrap()
            .credentials
            .as_ref()
            .unwrap()
            .access_key_id(),
        assumed_role
            .as_ref()
            .unwrap()
            .credentials
            .as_ref()
            .unwrap()
            .secret_access_key(),
        Some(
            assumed_role
                .as_ref()
                .unwrap()
                .credentials
                .as_ref()
                .unwrap()
                .session_token
                .clone(),
        ),
    );

    let succeed_config = aws_config::from_env()
        .credentials_provider(assumed_credentials)
        .load()
        .await;
    println!("succeed config: {:?}", succeed_config);
    let succeed_client: s3Client = s3Client::new(&succeed_config);
    sleep(Duration::from_secs(10)).await;
    match succeed_client.list_buckets().send().await {
        Ok(_) => {
            println!("This should now run successfully.")
        }
        Err(e) => {
            println!("This should not run. {:?}", e);
            panic!()
        }
    }

    //Clean up.
    iam_service::detach_role_policy(
        &client,
        assume_role_role.role_name(),
        list_all_buckets_policy.arn().unwrap_or_default(),
    )
    .await?;
    iam_service::delete_policy(&client, list_all_buckets_policy).await?;
    iam_service::delete_role(&client, &assume_role_role).await?;
    println!("Deleted role {}", assume_role_role.role_name());
    iam_service::delete_access_key(&client, &user, &key).await?;
    println!("Deleted key for {}", key.user_name());
    iam_service::delete_user_policy(&client, &user, &inline_policy_name).await?;
    println!("Deleted inline user policy: {}", inline_policy_name);
    iam_service::delete_user(&client, &user).await?;
    println!("Deleted user {}", user.user_name());

    Ok(())
}
```
+ Per informazioni dettagliate sull’API, consulta i seguenti argomenti nella *documentazione di riferimento dell’API SDK AWS per Rust*.
  + [AttachRolePolicy](https://docs.rs/aws-sdk-iam/latest/aws_sdk_iam/client/struct.Client.html#method.attach_role_policy)
  + [CreateAccessKey](https://docs.rs/aws-sdk-iam/latest/aws_sdk_iam/client/struct.Client.html#method.create_access_key)
  + [CreatePolicy](https://docs.rs/aws-sdk-iam/latest/aws_sdk_iam/client/struct.Client.html#method.create_policy)
  + [CreateRole](https://docs.rs/aws-sdk-iam/latest/aws_sdk_iam/client/struct.Client.html#method.create_role)
  + [CreateUser](https://docs.rs/aws-sdk-iam/latest/aws_sdk_iam/client/struct.Client.html#method.create_user)
  + [DeleteAccessKey](https://docs.rs/aws-sdk-iam/latest/aws_sdk_iam/client/struct.Client.html#method.delete_access_key)
  + [DeletePolicy](https://docs.rs/aws-sdk-iam/latest/aws_sdk_iam/client/struct.Client.html#method.delete_policy)
  + [DeleteRole](https://docs.rs/aws-sdk-iam/latest/aws_sdk_iam/client/struct.Client.html#method.delete_role)
  + [DeleteUser](https://docs.rs/aws-sdk-iam/latest/aws_sdk_iam/client/struct.Client.html#method.delete_user)
  + [DeleteUserPolicy](https://docs.rs/aws-sdk-iam/latest/aws_sdk_iam/client/struct.Client.html#method.delete_user_policy)
  + [DetachRolePolicy](https://docs.rs/aws-sdk-iam/latest/aws_sdk_iam/client/struct.Client.html#method.detach_role_policy)
  + [PutUserPolicy](https://docs.rs/aws-sdk-iam/latest/aws_sdk_iam/client/struct.Client.html#method.put_user_policy)

------

# Utilizzare un ruolo IAM per concedere autorizzazioni alle applicazioni in esecuzione su istanze Amazon EC2
<a name="id_roles_use_switch-role-ec2"></a>

Le applicazioni eseguite su un'istanza Amazon EC2 devono includere AWS credenziali nelle richieste API. AWS Potresti chiedere ai tuoi sviluppatori di archiviare AWS le credenziali direttamente all'interno dell'istanza Amazon EC2 e consentire alle applicazioni in quell'istanza di utilizzare tali credenziali. Tuttavia, in questo caso, gli sviluppatori dovrebbero gestire le credenziali, accertarsi che vengano passate in modo sicuro a ciascuna istanza e aggiornare ogni istanza Amazon EC2 al momento di aggiornare le credenziali. Si tratta di una notevole quantità di lavoro aggiuntivo.

In alternativa, puoi (e devi) utilizzare un ruolo IAM per gestire credenziali *temporanee* per le applicazioni eseguite in un'istanza Amazon EC2. Quando utilizzi un ruolo, non occorre distribuire credenziali a lungo termine (come, ad esempio, credenziali di accesso oppure chiavi di accesso) per un'istanza Amazon EC2. Al contrario, il ruolo fornisce autorizzazioni temporanee che le applicazioni possono utilizzare quando effettuano chiamate ad altre risorse. AWS Quando avvii un'istanza Amazon EC2, devi specificare un ruolo IAM da associare ad essa. Le applicazioni eseguite nell'istanza possono quindi utilizzare le credenziali provvisorie fornite dal ruolo per firmare le richieste API.

L'utilizzo dei ruoli per concedere autorizzazioni alle applicazioni eseguite nelle istanze Amazon EC2 richiede una configurazione leggermente più elaborata Un'applicazione in esecuzione su un'istanza Amazon EC2 viene astratta AWS dal sistema operativo virtualizzato. A causa di questa ulteriore separazione, è necessario un passaggio aggiuntivo per assegnare un AWS ruolo e le relative autorizzazioni a un'istanza Amazon EC2 e renderle disponibili alle sue applicazioni. Tale passaggio aggiuntivo prevede la creazione di un *[profilo dell'istanza](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_use_switch-role-ec2_instance-profiles.html)* collegato all'istanza. Il profilo dell'istanza contiene il ruolo e può fornire le credenziali provvisorie del ruolo a un'applicazione eseguita nell'istanza. Le credenziali provvisorie possono essere utilizzate nelle chiamate dell'API dell'applicazione per accedere alle risorse e limitare l'accesso alle sole risorse specificate dal ruolo.

**Nota**  
A un'istanza Amazon EC2 può essere assegnato soltanto un ruolo alla volta e tutte le applicazioni dell'istanza condividono lo stesso ruolo e le stesse autorizzazioni. Quando si utilizza Amazon ECS per gestire le istanze Amazon EC2, alle attività di Amazon ECS è possibile assegnare dei ruoli che possono essere distinti dal ruolo dell'istanza Amazon EC2 su cui è in esecuzione. L'assegnazione di un ruolo a ciascuna attività è conforme al principio dell'accesso con privilegi minimi e consente un controllo più granulare su operazioni e risorse.  
Per ulteriori informazioni, consulta la pagina [Utilizzo dei ruoli IAM con le attività Amazon ECS](https://docs.aws.amazon.com/AmazonECS/latest/bestpracticesguide/security-iam-roles.html) nella *Guida alle best practice per Amazon Elastic Container Service*.

Questo tipo di utilizzo dei ruoli offre diversi vantaggi. Dato che le credenziali dei ruoli sono temporanee e vengono aggiornate automaticamente, non dovrai preoccuparti della gestione né dei rischi di sicurezza a lungo termine. Inoltre, se utilizzi un singolo ruolo per più istanze, quando apporti una modifica a un ruolo, queste si propaga automaticamente a tutte le istanze. 

**Nota**  
Anche se in genere un ruolo viene assegnato a un'istanza Amazon EC2 all'avvio, puoi comunque effettuare il collegamento anche a un'istanza Amazon EC2 già in esecuzione. Per informazioni sul collegamento di un ruolo a un'istanza in esecuzione, consulta [Ruoli IAM per Amazon EC2](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/iam-roles-for-amazon-ec2.html#attach-iam-role).

**Topics**
+ [Funzionamento dei ruoli per le istanze Amazon EC2](#roles-usingrole-ec2instance-roles)
+ [Autorizzazioni richieste per l'utilizzo dei ruoli con Amazon EC2](#roles-usingrole-ec2instance-permissions)
+ [Come si inizia?](#roles-usingrole-ec2instance-get-started)
+ [Informazioni correlate](#roles-usingrole-ec2instance-related-info)

## Funzionamento dei ruoli per le istanze Amazon EC2
<a name="roles-usingrole-ec2instance-roles"></a>

Nella figura di seguito, uno sviluppatore esegue un'applicazione su un'istanza Amazon EC2 che richiede l'accesso al bucket S3 denominato `amzn-s3-demo-bucket-photos`. Un amministratore crea il ruolo di servizio `Get-pics` e lo collega all'istanza Amazon EC2. Il ruolo include una policy di autorizzazione che consente l'accesso in sola lettura al bucket S3 specificato. Include anche una policy di affidabilità che consente all'istanza Amazon EC2 di assumere il ruolo e recuperare le credenziali provvisorie. Quando l'applicazione viene eseguita sull'istanza, può utilizzare le credenziali provvisorie del ruolo per accedere al bucket delle foto. L'amministratore non ha bisogno di concedere allo sviluppatore l'autorizzazione di accedere al bucket delle foto e lo sviluppatore non si trova mai nella necessità di condividere o gestire credenziali.

![\[Applicazione su un'istanza Amazon EC2 che accede a una risorsa AWS\]](http://docs.aws.amazon.com/it_it/IAM/latest/UserGuide/images/roles-usingrole-ec2roleinstance.png)


1. L'amministratore utilizza IAM per creare il ruolo **Get-pics**. Nella policy di affidabilità del ruolo l'amministratore specifica che solo le istanze Amazon EC2 possono assumere quel ruolo. Nella policy di autorizzazione del ruolo l'amministratore specifica autorizzazioni di sola lettura per il bucket `amzn-s3-demo-bucket-photos`.

1. Uno sviluppatore avvia un'istanza Amazon EC2 e assegna il ruolo `Get-pics` all'istanza.
**Nota**  
Se utilizzi la console IAM, il profilo dell'istanza viene gestito in automatico, con un processo quasi completamente trasparente. Tuttavia, se utilizzi l'API AWS CLI or per creare e gestire il ruolo e l'istanza Amazon EC2, devi creare il profilo dell'istanza e assegnargli il ruolo in fasi separate. Quindi, quando avvii l'istanza dovrai specificare il nome del profilo dell'istanza anziché il nome del ruolo.

1. Quando l'applicazione è in esecuzione, raccoglie le credenziali di sicurezza provvisorie dai [metadati dell'istanza](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-instance-metadata.html) Amazon EC2, come descritto in [Recupero delle credenziali di sicurezza dai metadati delle istanze](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/iam-roles-for-amazon-ec2.html#instance-metadata-security-credentials). Si tratta di [credenziali di sicurezza provvisorie](id_credentials_temp.md) che rappresentano il ruolo e hanno un periodo di validità limitato. 

   In alcuni casi [AWS SDKs](https://aws.amazon.com/tools/), lo sviluppatore può utilizzare un provider che gestisce le credenziali di sicurezza temporanee in modo trasparente. (La documentazione per singoli utenti AWS SDKs descrive le funzionalità supportate da tale SDK per la gestione delle credenziali.)

   In alternativa, l'applicazione può ottenere le credenziali provvisorie direttamente dai metadati dell'istanza Amazon EC2. Le credenziali e i valori correlati sono disponibili nella categoria `iam/security-credentials/role-name` (in questo caso `iam/security-credentials/Get-pics`) dei metadati. Se l'applicazione ottiene le credenziali dai metadati dell'istanza, può memorizzarle nella cache.

1. Grazie all'utilizzo delle credenziali provvisorie recuperate, l'applicazione può accedere al bucket delle foto. In virtù della policy collegata al ruolo **Get-pics** (Ottieni foto), l'applicazione dispone di autorizzazioni di sola lettura. 

   Le credenziali di sicurezza temporanee disponibili nell'istanza vengono aggiornate automaticamente prima della scadenza, in modo da avere un set valido sempre disponibile. L'applicazione deve solo assicurarsi di ottenere un nuovo set di credenziali dai metadati dell'istanza prima della scadenza di quelle esistenti. È possibile utilizzare l' AWS SDK per gestire le credenziali in modo che l'applicazione non debba includere logica aggiuntiva per aggiornare le credenziali. Ad esempio, creando istanze di client con provider di credenziali del profilo dell'istanza. Tuttavia, se l'applicazione ottiene le credenziali di sicurezza provvisorie dai metadati dell'istanza e le memorizza nella cache, è necessario fornire un set di credenziali aggiornato ogni ora o almeno 15 minuti prima della scadenza del set corrente. L'ora di scadenza è indicata nelle informazioni restituite nella categoria `iam/security-credentials/role-name`. 

## Autorizzazioni richieste per l'utilizzo dei ruoli con Amazon EC2
<a name="roles-usingrole-ec2instance-permissions"></a>

Per avviare un'istanza con un ruolo, lo sviluppatore deve avere l'autorizzazione per avviare le istanze Amazon EC2 e per passare i ruoli IAM.

La seguente politica di esempio consente agli utenti di utilizzare per Console di gestione AWS avviare un'istanza con un ruolo. La policy include caratteri jolly (`*`) per consentire a un utente di passare qualsiasi ruolo ed eseguire tutte le operazioni di Amazon EC2 elencate. L'operazione `ListInstanceProfiles` consente agli utenti di visualizzare tutti i ruoli disponibili nell' Account AWS.

**Example Esempio di policy che concede a un utente l'autorizzazione di utilizzare la console Amazon EC2 per avviare un'istanza con qualsiasi ruolo**    
****  

```
{
    "Version":"2012-10-17",		 	 	 
    "Statement": [
        {
            "Sid": "IamPassRole",
            "Effect": "Allow",
            "Action": "iam:PassRole",
            "Resource": "*",
            "Condition": {
                "StringEquals": {
                    "iam:PassedToService": "ec2.amazonaws.com"
                }
            }
        },
        {
            "Sid": "ListEc2AndListInstanceProfiles",
            "Effect": "Allow",
            "Action": [
                "iam:ListInstanceProfiles",
                "ec2:Describe*",
                "ec2:Search*",
                "ec2:Get*"
            ],
            "Resource": "*"
        }
    ]
}
```

### Limitazione dei ruoli che possono essere passati alle istanze Amazon EC2 (utilizzando) PassRole
<a name="roles-usingrole-ec2instance-passrole"></a>

È possibile utilizzare l'autorizzazione `PassRole` per limitare i ruoli che un utente può passare a un'istanza Amazon EC2 quando avvia l'istanza. In questo modo si impedisce all'utente di eseguire le applicazioni che dispongono di più autorizzazioni rispetto a quelle concesse all'utente (ovvero di ottenere privilegi elevati). Ad esempio, immaginiamo che l'utente Alice disponga solo delle autorizzazioni per avviare le istanze Amazon EC2 e per operare con i bucket di Amazon S3, ma che passi a un'istanza Amazon EC2 un ruolo con autorizzazioni per operare con IAM e Amazon DynamoDB. In questo caso, Alice potrebbe essere in grado di avviare l'istanza, accedere a essa, ottenere credenziali di sicurezza temporanee e quindi eseguire operazioni IAM o DynamoDB per cui non dispone dell'autorizzazione.

Per limitare i ruoli che un utente può passare a un'istanza Amazon EC2, devi creare una policy che consenta l'operazione `PassRole`. A quel punto, puoi collegare la policy all'utente (o a un gruppo IAM a cui l'utente appartiene) che avvierà le istanze Amazon EC2. Nell'elemento `Resource` della policy devi elencare il ruolo o i ruoli che l'utente può passare alle istanze Amazon EC2. Quando l'utente avvia un'istanza e la associa a un ruolo, Amazon EC2 verifica se l'utente è autorizzato a inviare quel ruolo. Ovviamente, devi anche accertarti che il ruolo passato dall'utente non includa un numero di autorizzazioni maggiore di quello consentito all'utente.

**Nota**  
`PassRole` non è un'operazione API pari a `RunInstances` o `ListInstanceProfiles`. Si tratta invece di un'autorizzazione che AWS verifica ogni volta che l'ARN di un ruolo viene passato come parametro a un'API (o la console lo fa per conto dell'utente). In questo modo, un amministratore ha la possibilità di controllare quali ruoli possono essere passati dai vari utenti. In questo caso, garantisce che l'utente abbia l'autorizzazione per collegare un ruolo specifico a un'istanza Amazon EC2.

**Example policy che concede a un utente l'autorizzazione di avviare un'istanza Amazon EC2 con un ruolo specifico**  
Il seguente esempio di policy consente agli utenti di utilizzare l'API Amazon EC2 per avviare un'istanza con un ruolo. L'elemento `Resource` specifica l'Amazon Resource Name (ARN) di un ruolo. Specificando l'ARN, la policy concede all'utente l'autorizzazione di passare solo il ruolo `Get-pics`. Se, all'avvio di un'istanza, l'utente cerca di specificare un ruolo diverso, l'operazione ha esito negativo. L'utente non è autorizzato a eseguire alcuna istanza, indipendentemente dal passaggio di un ruolo.    
****  

```
{
    "Version":"2012-10-17",		 	 	 
    "Statement": [
        {
            "Effect": "Allow",
            "Action": "ec2:RunInstances",
            "Resource": "*"
        },
        {
            "Effect": "Allow",
            "Action": "iam:PassRole",
            "Resource": "arn:aws:iam::111122223333:role/Get-pics"
        }
    ]
}
```

### Consentire a un ruolo del profilo dell'istanza di passare a un ruolo in un altro account
<a name="switch-role-ec2-another-account"></a>

Puoi consentire a un'applicazione in esecuzione su un'istanza Amazon EC2 di eseguire comandi in un altro account. A tale scopo, devi consentire al ruolo dell'istanza Amazon EC2 nel primo account di passare a un ruolo nel secondo account.

Immagina di usarne due Account AWS e di voler consentire a un'applicazione in esecuzione su un'istanza Amazon EC2 di eseguire [AWS CLI](https://aws.amazon.com/cli/)comandi in entrambi gli account. Supponiamo che l'istanza Amazon EC2 esista nell'account `111111111111`. Tale istanza include il ruolo del profilo dell'istanza `abcd` che consente all'applicazione di eseguire attività Amazon S3 di sola lettura nel bucket `amzn-s3-demo-bucket1` all'interno dello stesso account `111111111111`. Tuttavia, l'applicazione deve anche poter assumere il ruolo tra account `efgh` per accedere al bucket `amzn-s3-demo-bucket2` di Amazon S3 nell'account `222222222222`.

![\[Il diagramma mostra come uno sviluppatore avvia un'istanza Amazon EC2 con il ruolo per accedere alle foto in un bucket Amazon S3.\]](http://docs.aws.amazon.com/it_it/IAM/latest/UserGuide/images/roles-instance-profile-cross-account.png)


Il ruolo del profilo dell'istanza Amazon EC2 `abcd` deve disporre della policy di autorizzazioni seguente per consentire all'applicazione di accedere al bucket `amzn-s3-demo-bucket1` di Amazon S3:

***Policy di autorizzazioni del ruolo `abcd` 111111111111 dell'account***

------
#### [ JSON ]

****  

```
{
    "Version":"2012-10-17",		 	 	 
    "Statement": [
        {
            "Sid": "AllowAccountLevelS3Actions",
            "Effect": "Allow",
            "Action": [
                "s3:GetBucketLocation",
                "s3:GetAccountPublicAccessBlock",
                "s3:ListAccessPoints",
                "s3:ListAllMyBuckets"
            ],
            "Resource": "arn:aws:s3:::*"
        },
        {
            "Sid": "AllowListAndReadS3ActionOnMyBucket",
            "Effect": "Allow",
            "Action": [
                "s3:Get*",
                "s3:List*"
            ],
            "Resource": [
                "arn:aws:s3:::amzn-s3-demo-bucket1/*",
                "arn:aws:s3:::amzn-s3-demo-bucket1"
            ]
        },
        {
            "Sid": "AllowIPToAssumeCrossAccountRole",
            "Effect": "Allow",
            "Action": "sts:AssumeRole",
            "Resource": "arn:aws:iam::222222222222:role/efgh"
        }
    ]
}
```

------

Il ruolo `abcd` deve considerare il servizio Amazon EC2 come attendibile ad assumere il ruolo. A tale scopo, il ruolo `abcd` deve disporre della seguente policy di attendibilità:

***Policy di attendibilità del ruolo `abcd` dell'account 111111111111***

------
#### [ JSON ]

****  

```
{
    "Version":"2012-10-17",		 	 	 
    "Statement": [
        {
            "Sid": "abcdTrustPolicy",
            "Effect": "Allow",
            "Action": "sts:AssumeRole",
            "Principal": {"Service": "ec2.amazonaws.com"}
        }
    ]
}
```

------

Supponiamo che il ruolo tra account `efgh` consenta attività Amazon S3 di sola lettura nel bucket `amzn-s3-demo-bucket2` all'interno dello stesso account `222222222222`. A tale scopo, il ruolo tra account `efgh` deve disporre della seguente policy di autorizzazioni:

***Policy di autorizzazioni del ruolo `efgh` 222222222222 dell'account***

------
#### [ JSON ]

****  

```
{
    "Version":"2012-10-17",		 	 	 
    "Statement": [
        {
            "Sid": "AllowAccountLevelS3Actions",
            "Effect": "Allow",
            "Action": [
                "s3:GetBucketLocation",
                "s3:GetAccountPublicAccessBlock",
                "s3:ListAccessPoints",
                "s3:ListAllMyBuckets"
            ],
            "Resource": "arn:aws:s3:::*"
        },
        {
            "Sid": "AllowListAndReadS3ActionOnMyBucket",
            "Effect": "Allow",
            "Action": [
                "s3:Get*",
                "s3:List*"
            ],
            "Resource": [
                "arn:aws:s3:::amzn-s3-demo-bucket2/*",
                "arn:aws:s3:::amzn-s3-demo-bucket2"
            ]
        }
    ]
}
```

------

Il ruolo `efgh` deve consentire al ruolo del profilo dell'istanza `abcd` di assumerlo. A tale scopo, il ruolo `efgh` deve disporre della seguente policy di attendibilità:

***Policy di attendibilità del ruolo `efgh` dell'account 222222222222***

------
#### [ JSON ]

****  

```
{
    "Version":"2012-10-17",		 	 	 
    "Statement": [
        {
            "Sid": "efghTrustPolicy",
            "Effect": "Allow",
            "Action": "sts:AssumeRole",
            "Principal": {"AWS": "arn:aws:iam::111111111111:role/abcd"}
        }
    ]
}
```

------

## Come si inizia?
<a name="roles-usingrole-ec2instance-get-started"></a>

Per comprendere come funzionano i ruoli nelle istanze Amazon EC2, crea un ruolo con la console IAM, avvia un'istanza Amazon EC2 che usi tale ruolo e quindi osserva l'istanza in esecuzione. Puoi prendere in esame i [metadati dell'istanza](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-instance-metadata.html) per consultare in che modo le credenziali provvisorie del ruolo vengano rese disponibili a un'istanza. Potrai anche consultare il modo in cui un'applicazione eseguita in un'istanza può utilizzare tale ruolo. Per ottenere ulteriori informazioni, usare le risorse indicate di seguito. 
+ [Tutorial di ruoli IAM per istanze Amazon EC2](https://www.youtube.com/watch?v=TlCuOjviOhk). Il video collegato mostra come utilizzare un ruolo IAM con un'istanza Amazon EC2 per controllare ciò che un'applicazione può fare quando viene eseguita nell'istanza. Il video mostra come l'applicazione (scritta nell' AWS SDK) può ottenere credenziali di sicurezza temporanee tramite il ruolo. 
+ Procedure guidate sugli SDK. La documentazione dell' AWS SDK include procedure dettagliate che mostrano un'applicazione in esecuzione su un'istanza Amazon EC2 che utilizza credenziali temporanee per i ruoli per leggere un bucket Amazon S3. Ogni procedura guidata presenta passaggi simili, ma utilizza un linguaggio di programmazione diverso:
  + [Configurazione dei ruoli IAM per Amazon EC2 con SDK per Java](https://docs.aws.amazon.com/sdk-for-java/latest/developer-guide/java-dg-roles.html) nella *Guida per gli sviluppatori di AWS SDK per Java * 
  + [Avvio di un'istanza Amazon EC2 utilizzando SDK per .NET](https://docs.aws.amazon.com/sdk-for-net/latest/developer-guide/run-instance.html) nella *Guida per gli sviluppatori di AWS SDK per .NET *
  + [Creazione di una istanza Amazon EC2 con SDK for Ruby](https://docs.aws.amazon.com/sdk-for-ruby/latest/developer-guide/ec2-example-create-instance.html) nella *Guida per gli sviluppatori di AWS SDK per Ruby *

## Informazioni correlate
<a name="roles-usingrole-ec2instance-related-info"></a>

Per ulteriori informazioni sulla creazione di ruoli o di ruoli per le istanze Amazon EC2, consulta la seguente documentazione:
+ Per ulteriori informazioni sull'[utilizzo dei ruoli IAM con istanze Amazon EC2](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/iam-roles-for-amazon-ec2.html), consulta la *Guida per l'utente di Amazon EC2*.
+ Per creare un ruolo, consulta [Creazione di ruoli IAM](id_roles_create.md)
+ Per ulteriori informazioni sull'utilizzo delle credenziali di sicurezza provvisorie, vedi [Credenziali di sicurezza temporanee in IAM](id_credentials_temp.md).
+ Se lavori con l'API IAM o la CLI, devi creare e gestire i profili delle istanze IAM. Per ulteriori informazioni sui profili delle istanze, consulta [Usare profili dell'istanza](id_roles_use_switch-role-ec2_instance-profiles.md).
+ Per ulteriori informazioni sulle credenziali di sicurezza provvisorie per i ruoli dei metadati dell'istanza, consulta [Recupero delle credenziali di sicurezza dai metadati delle istanze](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/iam-roles-for-amazon-ec2.html#instance-metadata-security-credentials) nella *Guida per l'utente di Amazon EC2*.

# Usare profili dell'istanza
<a name="id_roles_use_switch-role-ec2_instance-profiles"></a>

Utilizza un profilo dell'istanza per passare un ruolo IAM a un'istanza EC2. Per ulteriori informazioni, consulta [Ruoli IAM per Amazon EC2](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/iam-roles-for-amazon-ec2.html) nella *Guida per l'utente di Amazon EC2*.

## Gestione dei profili delle istanze (console)
<a name="instance-profiles-manage-console"></a>

Se utilizzi il per Console di gestione AWS creare un ruolo per Amazon EC2, la console crea automaticamente un profilo di istanza e gli assegna lo stesso nome del ruolo. Successivamente, quando utilizzi la console Amazon EC2 per avviare un'istanza con un ruolo IAM, potrai selezionare un ruolo da associare all'istanza. L'elenco visualizzato nella console è in effetti elenco di nomi di profili delle istanze. La console non crea un profilo dell'istanza per un ruolo non associato ad Amazon EC2.

Puoi utilizzare il Console di gestione AWS per eliminare i ruoli IAM e i profili di istanza per Amazon EC2 se il ruolo e il profilo dell'istanza hanno lo stesso nome. Per ulteriori informazioni sull'eliminazione dei profili di istanza, consulta [Eliminare i ruoli o i profili delle istanze](id_roles_manage_delete.md).

**Nota**  
Per aggiornare le autorizzazioni di un’istanza, sostituisci il suo profilo dell’istanza. Sconsigliamo di rimuovere un ruolo da un profilo dell’istanza, poiché è necessario attendere fino a un’ora prima che la modifica abbia effetto.

## Gestione dei profili di istanza (AWS CLI o AWS API)
<a name="instance-profiles-manage-cli-api"></a>

Se gestisci i tuoi ruoli dall' AWS CLI o dall' AWS API, crei ruoli e profili di istanza come azioni separate. Poiché ruoli e profili delle istanze possono avere nomi diversi, è importante che tu conosca i nomi dei profili e dei ruoli che contengono. In questo modo,sarà più semplice selezionare il corretto profilo all'avvio di un'istanza EC2. 

È possibile collegare tag alle risorse IAM, inclusi i profili dell'istanza, per identificare, organizzare e controllare l'accesso a tali risorse. Puoi etichettare i profili delle istanze solo quando utilizzi l' AWS API AWS CLI o. 

**Nota**  
Un profilo dell'istanza può contenere un solo ruolo IAM, mentre lo stesso ruolo può essere in più profili delle istanze. Non è possibile aumentare il numero di ruoli per profilo dell'istanza. Tuttavia, puoi rimuovere il ruolo esistente nel profilo dell'istanza e aggiungerne uno diverso. È quindi necessario attendere che la modifica appaia ovunque per AWS motivi di [coerenza finale](https://en.wikipedia.org/wiki/Eventual_consistency). Per forzare la modifica, devi [dissociare il profilo dell'istanza](https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_DisassociateIamInstanceProfile.html) e quindi [associare il profilo dell'istanza](https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_AssociateIamInstanceProfile.html) oppure arrestare l'istanza e riavviarla.

### Gestione dei profili delle istanze AWS CLI
<a name="instance-profiles-manage-cli"></a>

È possibile utilizzare i seguenti AWS CLI comandi per lavorare con i profili di istanza in un AWS account. 
+ Per creare un profilo dell'istanza: [https://docs.aws.amazon.com/cli/latest/reference/iam/create-instance-profile.html](https://docs.aws.amazon.com/cli/latest/reference/iam/create-instance-profile.html)
+ Applicare tag a un profilo dell'istanza: [https://docs.aws.amazon.com/cli/latest/reference/iam/tag-instance-profile.html](https://docs.aws.amazon.com/cli/latest/reference/iam/tag-instance-profile.html)
+ Elencare i tag per un profilo dell'istanza: [https://docs.aws.amazon.com/cli/latest/reference/iam/list-instance-profile-tags.html](https://docs.aws.amazon.com/cli/latest/reference/iam/list-instance-profile-tags.html)
+ Rimuovere i tag da un profilo dell'istanza: [https://docs.aws.amazon.com/cli/latest/reference/iam/untag-instance-profile.html](https://docs.aws.amazon.com/cli/latest/reference/iam/untag-instance-profile.html)
+ Per aggiungere un ruolo a un profilo dell'istanza: [https://docs.aws.amazon.com/cli/latest/reference/iam/add-role-to-instance-profile.html](https://docs.aws.amazon.com/cli/latest/reference/iam/add-role-to-instance-profile.html) 
+ Per elencare i profili delle istanze: [https://docs.aws.amazon.com/cli/latest/reference/iam/list-instance-profiles.html](https://docs.aws.amazon.com/cli/latest/reference/iam/list-instance-profiles.html), [https://docs.aws.amazon.com/cli/latest/reference/iam/list-instance-profiles-for-role.html](https://docs.aws.amazon.com/cli/latest/reference/iam/list-instance-profiles-for-role.html) 
+ Per ottenere informazioni su un profilo dell'istanza: [https://docs.aws.amazon.com/cli/latest/reference/iam/get-instance-profile.html](https://docs.aws.amazon.com/cli/latest/reference/iam/get-instance-profile.html) 
+ Per rimuovere un ruolo da un profilo dell'istanza: [https://docs.aws.amazon.com/cli/latest/reference/iam/remove-role-from-instance-profile.html](https://docs.aws.amazon.com/cli/latest/reference/iam/remove-role-from-instance-profile.html)
+ Per eliminare un profilo dell'istanza: [https://docs.aws.amazon.com/cli/latest/reference/iam/delete-instance-profile.html](https://docs.aws.amazon.com/cli/latest/reference/iam/delete-instance-profile.html) 

È anche possibile collegare un ruolo a un'istanza EC2 già in esecuzione, utilizzando i comandi riportati di seguito. Per ulteriori informazioni, consulta [Ruoli IAM per Amazon EC2](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/iam-roles-for-amazon-ec2.html#attach-iam-role).
+ Collegare un profilo dell'istanza con ruolo a un'istanza EC2 in funzione o arrestata: [https://docs.aws.amazon.com/cli/latest/reference/ec2/associate-iam-instance-profile.html](https://docs.aws.amazon.com/cli/latest/reference/ec2/associate-iam-instance-profile.html) 
+ Ottenere informazioni su un profilo dell'istanza collegato a un'istanza EC2: [https://docs.aws.amazon.com/cli/latest/reference/ec2/describe-iam-instance-profile-associations.html](https://docs.aws.amazon.com/cli/latest/reference/ec2/describe-iam-instance-profile-associations.html) 
+ Distaccare un profilo dell'istanza con ruolo da un'istanza EC2 in funzione o arrestata: [https://docs.aws.amazon.com/cli/latest/reference/ec2/disassociate-iam-instance-profile.html](https://docs.aws.amazon.com/cli/latest/reference/ec2/disassociate-iam-instance-profile.html) 

### Gestione dei profili di istanza (AWS API)
<a name="instance-profiles-manage-api"></a>

È possibile chiamare le seguenti operazioni AWS API per utilizzare i profili di istanza in un file Account AWS.
+ Per creare un profilo dell'istanza: [https://docs.aws.amazon.com/IAM/latest/APIReference/API_CreateInstanceProfile.html](https://docs.aws.amazon.com/IAM/latest/APIReference/API_CreateInstanceProfile.html) 
+ Applicare tag a un profilo dell'istanza: [https://docs.aws.amazon.com/IAM/latest/APIReference/API_TagInstanceProfile.html](https://docs.aws.amazon.com/IAM/latest/APIReference/API_TagInstanceProfile.html) 
+ Elencare i tag su un profilo dell'istanza: [https://docs.aws.amazon.com/IAM/latest/APIReference/API_TagInstanceProfile.html](https://docs.aws.amazon.com/IAM/latest/APIReference/API_TagInstanceProfile.html) 
+ Rimuovere i tag da un profilo dell'istanza: [https://docs.aws.amazon.com/IAM/latest/APIReference/API_TagInstanceProfile.html](https://docs.aws.amazon.com/IAM/latest/APIReference/API_TagInstanceProfile.html) 
+ Per aggiungere un ruolo a un profilo dell'istanza: [https://docs.aws.amazon.com/IAM/latest/APIReference/API_AddRoleToInstanceProfile.html](https://docs.aws.amazon.com/IAM/latest/APIReference/API_AddRoleToInstanceProfile.html) 
+ Per elencare i profili delle istanze: [https://docs.aws.amazon.com/IAM/latest/APIReference/API_ListInstanceProfiles.html](https://docs.aws.amazon.com/IAM/latest/APIReference/API_ListInstanceProfiles.html), [https://docs.aws.amazon.com/IAM/latest/APIReference/API_ListInstanceProfilesForRole.html](https://docs.aws.amazon.com/IAM/latest/APIReference/API_ListInstanceProfilesForRole.html) 
+ Per ottenere informazioni su un profilo dell'istanza: [https://docs.aws.amazon.com/IAM/latest/APIReference/API_GetInstanceProfile.html](https://docs.aws.amazon.com/IAM/latest/APIReference/API_GetInstanceProfile.html) 
+ Per rimuovere un ruolo da un profilo dell'istanza: [https://docs.aws.amazon.com/IAM/latest/APIReference/API_RemoveRoleFromInstanceProfile.html](https://docs.aws.amazon.com/IAM/latest/APIReference/API_RemoveRoleFromInstanceProfile.html) 
+ Per eliminare un profilo dell'istanza: [https://docs.aws.amazon.com/IAM/latest/APIReference/API_DeleteInstanceProfile.html](https://docs.aws.amazon.com/IAM/latest/APIReference/API_DeleteInstanceProfile.html) 

È anche possibile collegare un ruolo a un'istanza EC2 già in esecuzione, richiamando le operazioni riportate di seguito. Per ulteriori informazioni, consulta [Ruoli IAM per Amazon EC2](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/iam-roles-for-amazon-ec2.html#attach-iam-role).
+ Collegare un profilo dell'istanza con ruolo a un'istanza EC2 in funzione o arrestata: [https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_AssociateIamInstanceProfile.html](https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_AssociateIamInstanceProfile.html) 
+ Ottenere informazioni su un profilo dell'istanza collegato a un'istanza EC2: [https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_DescribeIamInstanceProfileAssociations.html](https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_DescribeIamInstanceProfileAssociations.html) 
+ Distaccare un profilo dell'istanza con ruolo da un'istanza EC2 in funzione o arrestata: [https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_DisassociateIamInstanceProfile.html](https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_DisassociateIamInstanceProfile.html)