

La AWS SDK per JavaScript v2 è arrivata. end-of-support [Ti consigliamo di migrare alla AWS SDK per JavaScript v3.](https://docs.aws.amazon.com//sdk-for-javascript/v3/developer-guide/) [Per ulteriori dettagli e informazioni su come effettuare la migrazione, consulta questo annuncio.](https://aws.amazon.com/blogs//developer/announcing-end-of-support-for-aws-sdk-for-javascript-v2/)

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

# Impostazione delle credenziali
<a name="setting-credentials"></a>

AWS utilizza le credenziali per identificare chi sta chiamando i servizi e se è consentito l'accesso alle risorse richieste. 

Sia che venga eseguito in un browser Web o in un server Node.js, il JavaScript codice deve ottenere credenziali valide prima di poter accedere ai servizi tramite l'API. Le credenziali possono essere configurate a livello globale sull'oggetto di configurazione utilizzando `AWS.Config`, oppure per servizio, passando le credenziali direttamente a un oggetto di servizio.

Esistono diversi modi per impostare le credenziali che differiscono tra Node.js e JavaScript nei browser Web. Gli argomenti in questa sezione descrivono come impostare le credenziali in Node.js o nei browser Web. In ogni caso, le opzioni sono riportate in ordine consigliato.

## Best practice per le credenziali
<a name="credentials-best-practices"></a>

L'impostazione corretta delle credenziali garantisce che l'applicazione o lo script di browser possano accedere ai servizi e alle risorse necessari, riducendo al minimo l'esposizione a problemi di sicurezza che possono inficiare le applicazioni mission critical o compromettere i dati sensibili.

Un importante principio da applicare durante l'impostazione delle credenziali è concedere sempre i privilegi minimi necessari per l'attività. È più sicuro fornire le autorizzazioni minime per le risorse e aggiungere ulteriori autorizzazioni in base alle esigenze, invece di fornire autorizzazioni che superano il privilegio minimo e, di conseguenza, dover risolvere i problemi di sicurezza scoperti più tardi. Ad esempio, a meno che non sia necessario leggere e scrivere singole risorse, come oggetti in un bucket Amazon S3 o una tabella DynamoDB, imposta tali autorizzazioni in modalità di sola lettura.

*Per ulteriori informazioni sulla concessione del privilegio minimo, consulta la sezione [Grant Least Privilege dell'argomento Best Practices](https://docs.aws.amazon.com/IAM/latest/UserGuide/best-practices.html#grant-least-privilege) nella IAM User Guide.*

**avvertimento**  
Mentre è possibile farlo, consigliamo di non effettuare l'hard coding delle credenziali all'interno di un'applicazione o di uno script di browser. La codifica rigida delle credenziali comporta il rischio di divulgare informazioni sensibili.

Per ulteriori informazioni su come gestire le chiavi di accesso, consulta [Best practice per la gestione delle chiavi di AWS accesso](https://docs.aws.amazon.com/general/latest/gr/aws-access-keys-best-practices.html) nel. Riferimenti generali di AWS

**Topics**
+ [Best practice per le credenziali](#credentials-best-practices)
+ [Impostazione delle credenziali su Node.js](setting-credentials-node.md)
+ [Impostazione delle credenziali in un browser Web](setting-credentials-browser.md)

# Impostazione delle credenziali su Node.js
<a name="setting-credentials-node"></a>

Vi sono diversi modi su Node.js per fornire le credenziali all'SDK. Alcuni di questi sono più sicuri e altri offrono più comodità durante lo sviluppo di un'applicazione. Quando si ottengono le credenziali su Node.js, fai attenzione a ricorrere a più di una sorgente, ad esempio una variabile di ambiente e un file JSON caricati. È possibile modificare le autorizzazioni sotto cui il codice viene eseguito senza realizzare che la modifica è avvenuta.

Di seguito sono descritti i modi in cui è possibile fornire le proprie credenziali in ordine di raccomandazione:

1. Caricato da ruoli AWS Identity and Access Management (IAM) per Amazon EC2

1. Caricato dal file delle credenziali condiviso (`~/.aws/credentials`)

1. Caricato da variabili di ambiente

1. Caricato da un file JSON su disco

1. Altre classi di fornitori di credenziali fornite dall'SDK JavaScript 

Se l'SDK dispone di più fonti di credenziali, la precedenza di selezione predefinita è la seguente:

1. Credenziali impostate esplicitamente attraverso il costruttore servizio-client

1. Variabili di ambiente

1. File delle credenziali condiviso

1. Credenziali caricate dal provider di credenziali ECS (se applicabile)

1. Credenziali ottenute utilizzando un processo di credenziali specificato nel file di AWS configurazione condiviso o nel file di credenziali condivise. Per ulteriori informazioni, consulta [Caricamento delle credenziali su Node.js utilizzando un processo di credenziali configurato](loading-node-credentials-configured-credential-process.md).

1. Credenziali caricate da AWS IAM utilizzando il provider di credenziali dell' EC2 istanza Amazon (se configurate nei metadati dell'istanza)

Per ulteriori informazioni, consulta [https://docs.aws.amazon.com/AWSJavaScriptSDK/latest/AWS/Credentials.html](https://docs.aws.amazon.com/AWSJavaScriptSDK/latest/AWS/Credentials.html)e [https://docs.aws.amazon.com/AWSJavaScriptSDK/latest/AWS/CredentialProviderChain.html](https://docs.aws.amazon.com/AWSJavaScriptSDK/latest/AWS/CredentialProviderChain.html)nel riferimento all'API.

**avvertimento**  
Sebbene sia possibile farlo, sconsigliamo di codificare le AWS credenziali nell'applicazione. Effettuare l'hard coding delle credenziali pone un rischio di esposizione dell'ID chiave di accesso e della chiave di accesso segreta.

Gli argomenti in questa sezione descrivono come caricare le credenziali su Node.js.

**Topics**
+ [Caricamento delle credenziali in Node.js dai ruoli IAM per Amazon EC2](loading-node-credentials-iam.md)
+ [Caricamento delle credenziali per una funzione Lambda Node.js](loading-node-credentials-lambda.md)
+ [Caricamento delle credenziali su Node.js dal file delle credenziali condiviso](loading-node-credentials-shared.md)
+ [Caricamento delle credenziali su Node.js dalle variabili di ambiente](loading-node-credentials-environment.md)
+ [Caricamento delle credenziali su Node.js da un file JSON](loading-node-credentials-json-file.md)
+ [Caricamento delle credenziali su Node.js utilizzando un processo di credenziali configurato](loading-node-credentials-configured-credential-process.md)

# Caricamento delle credenziali in Node.js dai ruoli IAM per Amazon EC2
<a name="loading-node-credentials-iam"></a>

Se esegui l'applicazione Node.js su un' EC2 istanza Amazon, puoi sfruttare i ruoli IAM per Amazon per EC2 fornire automaticamente le credenziali all'istanza. Se configuri l'istanza per utilizzare i ruoli IAM, l'SDK seleziona automaticamente le credenziali IAM per l'applicazione, eliminando la necessità di fornire manualmente le credenziali.

Per ulteriori informazioni sull'aggiunta di ruoli IAM a un' EC2 istanza Amazon, consulta [Using IAM roles for Amazon EC2 instances](https://docs.aws.amazon.com/sdkref/latest/guide/access-iam-roles-for-ec2.html) nella *AWS SDKs and Tools Reference Guide*.

# Caricamento delle credenziali per una funzione Lambda Node.js
<a name="loading-node-credentials-lambda"></a>

Quando si crea una AWS Lambda funzione, è necessario creare un ruolo IAM speciale con il permesso di eseguire la funzione. Questo ruolo si chiama *ruolo di esecuzione*. Quando configuri una funzione Lambda, devi specificare il ruolo IAM che hai creato come ruolo di esecuzione corrispondente.

Il ruolo di esecuzione fornisce alla funzione Lambda le credenziali necessarie per eseguire e richiamare altri servizi Web. Di conseguenza, non è necessario fornire credenziali per il codice Node.js scritto all'interno di una funzione Lambda.

*Per ulteriori informazioni sulla creazione di un ruolo di esecuzione Lambda, consulta [Manage Permissions: Using an IAM Role (Execution Role)](https://docs.aws.amazon.com/lambda/latest/dg/intro-permission-model.html#lambda-intro-execution-role) nella Developer Guide.AWS Lambda *

# Caricamento delle credenziali su Node.js dal file delle credenziali condiviso
<a name="loading-node-credentials-shared"></a>

Puoi conservare i dati AWS delle tue credenziali in un file condiviso utilizzato da SDKs e nell'interfaccia a riga di comando. Quando l'SDK viene JavaScript caricato, cerca automaticamente nel file delle credenziali condivise, denominato «credenziali». Il percorso di salvataggio del file delle credenziali condiviso varia a seconda del sistema operativo:
+ Su Linux, Unix e macOS il file delle credenziali condiviso è: `~/.aws/credentials`
+ Su Windows il file delle credenziali condiviso è `C:\Users\USER_NAME\.aws\credentials`

Se non disponi già di un file delle credenziali condiviso, consulta [Autenticazione SDK con AWS](getting-your-credentials.md). Dopo aver seguito queste istruzioni, dovresti vedere un testo simile al seguente nel file delle credenziali, dove si *<YOUR\$1ACCESS\$1KEY\$1ID>* trova l'ID della tua chiave di accesso e la tua chiave di accesso *<YOUR\$1SECRET\$1ACCESS\$1KEY>* segreta:

```
[default]
aws_access_key_id = <YOUR_ACCESS_KEY_ID>
aws_secret_access_key = <YOUR_SECRET_ACCESS_KEY>
```

Un esempio di utilizzo di questo file è disponibile in [Nozioni di base su Node.js](getting-started-nodejs.md).

L'intestazione della sezione `[default]` specifica un profilo predefinito e i relativi valori per le credenziali. È possibile creare profili aggiuntivi nello stesso file di configurazione condiviso, ciascuno con le proprie informazioni sulle credenziali. L'esempio seguente mostra un file di configurazione con il profilo predefinito e due profili aggiuntivi:

```
[default] ; default profile
aws_access_key_id = <DEFAULT_ACCESS_KEY_ID>
aws_secret_access_key = <DEFAULT_SECRET_ACCESS_KEY>
    
[personal-account] ; personal account profile
aws_access_key_id = <PERSONAL_ACCESS_KEY_ID>
aws_secret_access_key = <PERSONAL_SECRET_ACCESS_KEY>
    
[work-account] ; work account profile
aws_access_key_id = <WORK_ACCESS_KEY_ID>
aws_secret_access_key = <WORK_SECRET_ACCESS_KEY>
```

Per impostazione predefinita, l'SDK verifica la variabile di ambiente `AWS_PROFILE` per determinare quale profilo utilizzare. Se la variabile `AWS_PROFILE` non è impostata nell'ambiente, l'SDK utilizza le credenziali per il profilo `[default]`. Per usare uno dei profili alternativi, modificare il valore della variabile di ambiente `AWS_PROFILE`. Ad esempio, dato il file di configurazione mostrato sopra, per utilizzare le credenziali dell'account di lavoro impostare la variabile di ambiente `AWS_PROFILE` su `work-account` (in funzione del sistema operativo in uso).

**Nota**  
Nell'impostare le variabili di ambiente, assicurarsi di procedere nel modo corretto (a seconda delle esigenze del sistema operativo) per rendere tali variabili disponibili nell'ambiente di shell o di comando.

Dopo aver impostato la variabile di ambiente (se necessario), puoi eseguire un JavaScript file che utilizza l'SDK, ad esempio un file denominato. `script.js`

```
$ node script.js
```

È anche possibile selezionare esplicitamente il profilo utilizzato dall'SDK, impostando `process.env.AWS_PROFILE` prima di caricare l'SDK oppure selezionando il provider di credenziali come nell'esempio seguente:

```
var credentials = new AWS.SharedIniFileCredentials({profile: 'work-account'});
AWS.config.credentials = credentials;
```

# Caricamento delle credenziali su Node.js dalle variabili di ambiente
<a name="loading-node-credentials-environment"></a>

L'SDK rileva automaticamente AWS le credenziali impostate come variabili nell'ambiente e le utilizza per le richieste SDK, eliminando la necessità di gestire le credenziali nell'applicazione. Le variabili di ambiente impostate per fornire le credenziali sono:
+ `AWS_ACCESS_KEY_ID`
+ `AWS_SECRET_ACCESS_KEY`
+ `AWS_SESSION_TOKEN`

*Per maggiori dettagli sull'impostazione delle variabili di ambiente, consulta [Supporto per le variabili di ambiente nella and Tools](https://docs.aws.amazon.com/sdkref/latest/guide/environment-variables.html) Reference Guide.AWS SDKs *

# Caricamento delle credenziali su Node.js da un file JSON
<a name="loading-node-credentials-json-file"></a>

È possibile caricare la configurazione e le credenziali da un documento in formato JSON su disco utilizzando `AWS.config.loadFromPath`. Il percorso specificato è relativo alla directory di lavoro del processo. Ad esempio, per caricare le credenziali da un file `'config.json'` con il seguente contenuto:

```
{ "accessKeyId": <YOUR_ACCESS_KEY_ID>, "secretAccessKey": <YOUR_SECRET_ACCESS_KEY>, "region": "us-east-1" }
```

Quindi usa il codice seguente:

```
var AWS = require("aws-sdk");
AWS.config.loadFromPath('./config.json');
```

**Nota**  
Il caricamento dei dati di configurazione da un documento JSON reimposta tutti i dati di configurazione esistenti. Aggiungi i dati di configurazione aggiuntivi dopo l'utilizzo di questa tecnica. Il caricamento delle credenziali da un documento in formato JSON non è supportato nello script di browser.

# Caricamento delle credenziali su Node.js utilizzando un processo di credenziali configurato
<a name="loading-node-credentials-configured-credential-process"></a>

Puoi originare credenziali utilizzando un metodo che non è integrato nell'SDK. A tale scopo, specificate un processo di creazione delle credenziali nel file di AWS configurazione condiviso o nel file delle credenziali condivise. Se la variabile di `AWS_SDK_LOAD_CONFIG` ambiente è impostata su un valore qualsiasi, l'SDK preferirà il processo specificato nel file di configurazione rispetto al processo specificato nel file delle credenziali (se presente).

[Per i dettagli sulla specificazione di un processo di credenziali nel file di AWS configurazione condiviso o nel file delle credenziali condivise, consultate il *AWS CLI Command Reference*, in particolare le informazioni sull'approvvigionamento di credenziali da processi esterni.](https://docs.aws.amazon.com/cli/latest/topic/config-vars.html#sourcing-credentials-from-external-processes)

Per ulteriori informazioni sull'utilizzo della variabile di ambiente `AWS_SDK_LOAD_CONFIG`, consulta [Utilizzo di un file di configurazione condiviso](setting-region.md#setting-region-config-file) in questo documento.

# Impostazione delle credenziali in un browser Web
<a name="setting-credentials-browser"></a>

Vi sono diversi modi per fornire le credenziali all'SDK dagli script di browser. Alcuni di questi sono più sicuri e altri offrono più comodità durante lo sviluppo di uno script. Di seguito sono descritti i modi in cui è possibile fornire le proprie credenziali in ordine di raccomandazione:

1. Utilizzo di Amazon Cognito Identity per autenticare gli utenti e fornire credenziali

1. Utilizzo delle identità della federazione delle identità Web

1. Effettuare l'hard coding nello script

**avvertimento**  
Non è consigliabile codificare le AWS credenziali negli script. Effettuare l'hard coding delle credenziali pone un rischio di esposizione dell'ID chiave di accesso e della chiave di accesso segreta.

**Topics**
+ [Utilizzo di Amazon Cognito Identity per autenticare gli utenti](loading-browser-credentials-cognito.md)
+ [Utilizzo delle identità della federazione delle identità sul Web per autenticare gli utenti](loading-browser-credentials-federated-id.md)
+ [Esempio di identità della federazione delle identità Web](config-web-identity-examples.md)

# Utilizzo di Amazon Cognito Identity per autenticare gli utenti
<a name="loading-browser-credentials-cognito"></a>

Il modo consigliato per ottenere AWS le credenziali per gli script del browser consiste nell'utilizzare l'oggetto credenziali di Amazon Cognito Identity,. `AWS.CognitoIdentityCredentials` Amazon Cognito consente l'autenticazione degli utenti tramite provider di identità di terze parti.

Per utilizzare Amazon Cognito Identity, devi prima creare un pool di identità nella console Amazon Cognito. Un pool di identità rappresenta il gruppo di identità che l'applicazione fornisce agli utenti. Le identità fornite agli utenti identificano in modo univoco ogni account utente. Le identità di Amazon Cognito non sono credenziali. Vengono scambiate con credenziali utilizzando il supporto per la federazione delle identità web in (). AWS Security Token Service AWS STS

Amazon Cognito ti aiuta a gestire l'astrazione delle identità tra più provider di identità con l'oggetto. `AWS.CognitoIdentityCredentials` L'identità caricata viene quindi scambiata con le credenziali in AWS STS.

## Configurazione dell'oggetto Amazon Cognito Identity Credentials
<a name="browser-cognito-configuration"></a>

Se non ne hai ancora creato uno, crea un pool di identità da utilizzare con gli script del browser nella console [Amazon Cognito](https://console.aws.amazon.com/cognito) prima della configurazione. `AWS.CognitoIdentityCredentials` Crea e associa ruoli IAM autenticati e non autenticati per il tuo pool di identità.

L'identità degli utenti non autenticati non è verificata. Ciò rende questo ruolo appropriato per utenti guest dell'app o per i casi in cui non importa se l'identità degli utenti è verificata. Gli utenti autenticati accedono all'applicazione tramite un provider di identità di terza parte che verifica la loro identità. Assicurati di creare l'ambito delle autorizzazioni di risorse in modo appropriato per evitare che utenti non autenticati possano accedere a esse.

Dopo aver configurato un pool di identità con i provider di identità associati, puoi utilizzare `AWS.CognitoIdentityCredentials` per autenticare gli utenti. Per configurare le credenziali dell'applicazione per utilizzare `AWS.CognitoIdentityCredentials`, imposta la proprietà `credentials` di `AWS.Config` o di una configurazione per servizio. Nell'esempio seguente viene utilizzato `AWS.Config`:

```
AWS.config.credentials = new AWS.CognitoIdentityCredentials({
  IdentityPoolId: 'us-east-1:1699ebc0-7900-4099-b910-2df94f52a030',
  Logins: { // optional tokens, used for authenticated login
    'graph.facebook.com': 'FBTOKEN',
    'www.amazon.com': 'AMAZONTOKEN',
    'accounts.google.com': 'GOOGLETOKEN'
  }
});
```

La proprietà `Logins` opzionale è una mappa di nomi di provider di identità ai token di identità per tali provider. Il modo in cui ottieni il token dal provider di identità dipende dal provider utilizzato. Ad esempio, se Facebook è uno dei provider di identità, puoi utilizzare la funzione `FB.login` di [SDK di Facebook](https://developers.facebook.com/docs/facebook-login/web) per ottenere un token del provider di identità:

```
FB.login(function (response) {
  if (response.authResponse) { // logged in
    AWS.config.credentials = new AWS.CognitoIdentityCredentials({
      IdentityPoolId: 'us-east-1:1699ebc0-7900-4099-b910-2df94f52a030',
      Logins: {
        'graph.facebook.com': response.authResponse.accessToken
      }
    });

    s3 = new AWS.S3; // we can now create our service object

    console.log('You are now logged in.');
  } else {
    console.log('There was a problem logging you in.');
  }
});
```

## Cambio degli utenti non autenticati in utenti autenticati
<a name="browser-switching-unauthenticated-users"></a>

Amazon Cognito supporta utenti autenticati e non autenticati. Gli utenti non autenticati ottengono l'accesso alle risorse anche se non sono connessi con un provider di identità. Tale livello di accesso è utile per visualizzare i contenuti agli utenti prima che effettuino l'accesso. Ogni utente non autenticato ha un'identità unica in Amazon Cognito anche se non è stato effettuato l'accesso e l'autenticazione individualmente.

### Utente inizialmente non autenticato
<a name="browser-switching-initially-unauthenticated-user"></a>

Gli utenti in genere iniziano con il ruolo non autenticato, per cui è possibile impostare la proprietà delle credenziali dell'oggetto di configurazione senza una proprietà `Logins`. In questo caso, la configurazione predefinita potrebbe essere simile alla seguente:

```
// set the default config object
var creds = new AWS.CognitoIdentityCredentials({
 IdentityPoolId: 'us-east-1:1699ebc0-7900-4099-b910-2df94f52a030'
});
AWS.config.credentials = creds;
```

### Cambio a utente autenticato
<a name="switch-to-authenticated"></a>

Quando un utente non autenticato accede a un provider di identità e dispone di un token, puoi cambiare l'utente da non autenticato ad autenticato chiamando una funzione personalizzata che aggiorna l'oggetto credenziali e aggiunge il token `Logins`:

```
// Called when an identity provider has a token for a logged in user
function userLoggedIn(providerName, token) {
  creds.params.Logins = creds.params.Logins || {};
  creds.params.Logins[providerName] = token;
                    
  // Expire credentials to refresh them on the next request
  creds.expired = true;
}
```

Inoltre puoi creare un oggetto `CognitoIdentityCredentials`. In caso contrario, è necessario reimpostare le proprietà delle credenziali degli oggetti di servizio esistenti creati. Gli oggetti di servizio leggono dalla configurazione globale solo sull'inizializzazione dell'oggetto. 

Per ulteriori informazioni sull'`CognitoIdentityCredentials`oggetto, consulta [https://docs.aws.amazon.com/AWSJavaScriptSDK/latest/AWS/CognitoIdentityCredentials.html](https://docs.aws.amazon.com/AWSJavaScriptSDK/latest/AWS/CognitoIdentityCredentials.html)l'API Reference. AWS SDK per JavaScript 

# Utilizzo delle identità della federazione delle identità sul Web per autenticare gli utenti
<a name="loading-browser-credentials-federated-id"></a>

È possibile configurare direttamente i singoli provider di identità per accedere alle AWS risorse utilizzando la federazione delle identità Web. AWS attualmente supporta l'autenticazione degli utenti tramite la federazione delle identità Web tramite diversi provider di identità:
+ [Login with Amazon](https://login.amazon.com)
+ [Accedi con Facebook](https://www.facebook.com/about/login)
+ [Accedi con Google](https://developers.google.com/identity/)

È necessario prima registrare l'applicazione con i provider supportati dall'applicazione. Successivamente, crea un ruolo IAM e configura le relative autorizzazioni. Il ruolo IAM che crei viene quindi utilizzato per concedere le autorizzazioni che hai configurato per esso tramite il rispettivo provider di identità. Ad esempio, puoi impostare un ruolo che consenta agli utenti che hanno effettuato l'accesso tramite Facebook di avere accesso in lettura a uno specifico bucket Amazon S3 che controlli.

Dopo aver ottenuto sia un ruolo IAM con privilegi configurati sia un'applicazione registrata con i provider di identità scelti, puoi configurare l'SDK per ottenere le credenziali per il ruolo IAM utilizzando il codice di supporto, come segue:

```
AWS.config.credentials = new AWS.WebIdentityCredentials({
   RoleArn: 'arn:aws:iam::<AWS_ACCOUNT_ID>/:role/<WEB_IDENTITY_ROLE_NAME>',
   ProviderId: 'graph.facebook.com|www.amazon.com', // this is null for Google
   WebIdentityToken: ACCESS_TOKEN
});
```

Il valore del parametro `ProviderId` dipende dal provider di identità specificato. Il valore del parametro `WebIdentityToken` è il token di accesso recuperato da un login riuscito con il provider di identità. Per ulteriori informazioni su come configurare e recuperare i token di accesso per ogni provider di identità, consulta la documentazione per il provider di identità.

## Fase 1: Registrazione con il provider di identità
<a name="config-web-identity-register"></a>

Per iniziare, registra un'applicazione con i provider di identità che scegli di supportare. Ti verrà richiesto di fornire informazioni che identificano l'applicazione e il suo autore. In questo modo il provider di identità saprà chi è che riceve le informazioni sull'utente. In ogni caso, il provider di identità emetterà un ID dell'applicazione che è possibile utilizzare per configurare i ruoli utente.

## Fase 2: Creazione di un ruolo IAM per un provider di identità
<a name="config-web-identity-role"></a>

Dopo aver ottenuto l'ID dell'applicazione da un provider di identità, accedi alla console IAM all'indirizzo [https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/)per creare un nuovo ruolo IAM.

**Per creare un ruolo IAM per un provider di identità**

1. Andare sulla sezione **Roles (Ruoli)** della console e scegliere **Create New Role (Crea nuovo ruolo)**.

1. Digitare un nome per il nuovo ruolo che consente di tenere traccia del suo utilizzo, ad esempio **facebookIdentity**, quindi selezionare **Next Step (Fase successiva)**.

1. In **Select Role Type (Seleziona tipo di ruolo)**, scegliere **Role for Identity Provider Access (Ruolo per accesso del provider di identità)**.

1. Per **Grant access to web identity providers (Concedi l'accesso ai provider di identità Web)**, scegliere **Select (Seleziona)**.

1. Dall'elenco degli **Identity Provider**, scegli il provider di identità che desideri utilizzare per questo ruolo IAM.  
![\[Selezione del ruolo per l'accesso al provider di identità\]](http://docs.aws.amazon.com/it_it/sdk-for-javascript/v2/developer-guide/images/iam-provider-select.png)

1. Digitare l'ID dell'applicazione fornito dal provider di identità in **Application ID (ID dell'applicazione)** e quindi scegliere **Next Step (Fase successiva)**.

1. Configurare le autorizzazioni per le risorse che si desidera esporre, consentendo l'accesso a specifiche operazioni su risorse specifiche. Per ulteriori informazioni sulle autorizzazioni IAM, consulta [Panoramica delle autorizzazioni AWS IAM nella Guida](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_permissions.html) per l'*utente IAM*. Verificare e, se necessario, personalizzare la relazione di trust del ruolo e quindi scegliere **Next Step (Fase successiva)**.

1. Collegare altre policy necessarie e quindi scegliere **Next Step (Fase successiva)**. Per ulteriori informazioni sulle policy IAM, consulta [Panoramica delle policy IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies.html) nella *Guida per l'utente di IAM*.

1. Verificare il nuovo ruolo, quindi selezionare **Create Role (Crea ruolo)**.

Puoi fornire altri vincoli al ruolo, ad esempio definirne l'ambito per un utente specifico. IDs Se il ruolo consente di concedere autorizzazioni di scrittura per le risorse, assicurati di definire correttamente l'ambito del ruolo per gli utenti con privilegi corretti, altrimenti qualsiasi utente con identità Amazon, Facebook o Google sarà in grado di modificare le risorse nell'applicazione.

Per ulteriori informazioni sull'utilizzo della federazione delle identità Web in IAM, consulta [About Web Identity Federation](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_providers_oidc.html) nella *IAM* User Guide.

## Fase 3: Ottenere che un provider acceda ai Token dopo il login
<a name="config-web-identity-obtain-token"></a>

Imposta l'azione di login per la tua applicazione utilizzando l'SDK del provider di identità. Puoi scaricare e installare un JavaScript SDK dal provider di identità che abilita l'accesso degli utenti, utilizzando uno dei due OAuth o OpenID. Per informazioni su come scaricare e configurare il codice dell'SDK dell'applicazione, consulta la documentazione sull'SDK per il tuo provider di identità:
+ [Login with Amazon](https://login.amazon.com/website)
+ [Accedi con Facebook](https://developers.facebook.com/docs/javascript)
+ [Accedi con Google](https://developers.google.com/identity/)

## Fase 4: Ottenere credenziali temporanee
<a name="config-web-identity-get-credentials"></a>

Dopo che l'applicazione, i ruoli, le autorizzazioni e le risorse sono stati configurati, aggiungi il codice alla tua applicazione per ottenere le credenziali temporanee. Queste credenziali vengono fornite AWS Security Token Service tramite la federazione delle identità web. Gli utenti accedono al provider di identità, che restituisce un token di accesso. Configura l'`AWS.WebIdentityCredentials`oggetto utilizzando l'ARN per il ruolo IAM che hai creato per questo provider di identità:

```
AWS.config.credentials = new AWS.WebIdentityCredentials({
    RoleArn: 'arn:aws:iam::<AWS_ACCOUNT_ID>:role/<WEB_IDENTITY_ROLE_NAME>',
    ProviderId: 'graph.facebook.com|www.amazon.com', // Omit this for Google
    WebIdentityToken: ACCESS_TOKEN // Access token from identity provider
});
```

Gli oggetti di servizio creati successivamente avranno le credenziali corrette. Gli oggetti creati prima di impostare la proprietà `AWS.config.credentials` non dispongono delle credenziali correnti.

È anche possibile creare `AWS.WebIdentityCredentials` prima di recuperare il token di accesso. Questa operazione consente di creare gli oggetti di servizio che dipendono dalle credenziali prima di caricare il token di accesso. Per eseguire questa operazione, è necessario creare l'oggetto delle credenziali senza il parametro `WebIdentityToken`:

```
AWS.config.credentials = new AWS.WebIdentityCredentials({
  RoleArn: 'arn:aws:iam::<AWS_ACCOUNT_ID>:role/<WEB_IDENTITY_ROLE_NAME>',
  ProviderId: 'graph.facebook.com|www.amazon.com' // Omit this for Google
});

// Create a service object
var s3 = new AWS.S3;
```

Quindi imposta `WebIdentityToken` nel callback dall'SDK del provider di identità che contiene il token di accesso:

```
AWS.config.credentials.params.WebIdentityToken = accessToken;
```

# Esempio di identità della federazione delle identità Web
<a name="config-web-identity-examples"></a>

Di seguito sono riportati alcuni esempi di utilizzo dell'identità federata Web per ottenere credenziali nel browser. JavaScript Questi esempi devono essere eseguiti da uno schema di host http:// o https:// per garantire che il provider di identità sia in grado di reindirizzare sull'applicazione. 

## Esempio di Login with Amazon
<a name="config-web-identity-amazon-login-example"></a>

Il codice seguente mostra come usare Login con Amazon come provider di identità. 

```
<a href="#" id="login">
  <img border="0" alt="Login with Amazon"
    src="https://images-na.ssl-images-amazon.com/images/G/01/lwa/btnLWA_gold_156x32.png"
    width="156" height="32" />
</a>
<div id="amazon-root"></div>
<script type="text/javascript">
  var s3 = null;
  var clientId = 'amzn1.application-oa2-client.1234567890abcdef'; // client ID
  var roleArn = 'arn:aws:iam::<AWS_ACCOUNT_ID>:role/<WEB_IDENTITY_ROLE_NAME>';

  window.onAmazonLoginReady = function() {
    amazon.Login.setClientId(clientId); // set client ID

    document.getElementById('login').onclick = function() {
      amazon.Login.authorize({scope: 'profile'}, function(response) {
        if (!response.error) { // logged in
          AWS.config.credentials = new AWS.WebIdentityCredentials({
            RoleArn: roleArn,
            ProviderId: 'www.amazon.com',
            WebIdentityToken: response.access_token
          });

          s3 = new AWS.S3();

          console.log('You are now logged in.');
        } else {
          console.log('There was a problem logging you in.');
        }
      });
    };
  };

  (function(d) {
    var a = d.createElement('script'); a.type = 'text/javascript';
    a.async = true; a.id = 'amazon-login-sdk';
    a.src = 'https://api-cdn.amazon.com/sdk/login1.js';
    d.getElementById('amazon-root').appendChild(a);
  })(document);
</script>
```

## Esempio di accesso tramite Facebook
<a name="config-web-identity-facebook-login-example"></a>

Il codice seguente mostra come usare l'accesso tramite Facebook come provider di identità:

```
<button id="login">Login</button>
<div id="fb-root"></div>
<script type="text/javascript">
var s3 = null;
var appId = '1234567890'; // Facebook app ID
var roleArn = 'arn:aws:iam::<AWS_ACCOUNT_ID>:role/<WEB_IDENTITY_ROLE_NAME>';

window.fbAsyncInit = function() {
  // init the FB JS SDK
  FB.init({appId: appId});

  document.getElementById('login').onclick = function() {
    FB.login(function (response) {
      if (response.authResponse) { // logged in
        AWS.config.credentials = new AWS.WebIdentityCredentials({
          RoleArn: roleArn,
          ProviderId: 'graph.facebook.com',
          WebIdentityToken: response.authResponse.accessToken
        });

        s3 = new AWS.S3;

        console.log('You are now logged in.');
      } else {
        console.log('There was a problem logging you in.');
      }
    });
  };
};

// Load the FB JS SDK asynchronously
(function(d, s, id){
   var js, fjs = d.getElementsByTagName(s)[0];
   if (d.getElementById(id)) {return;}
   js = d.createElement(s); js.id = id;
   js.src = "//connect.facebook.net/en_US/all.js";
   fjs.parentNode.insertBefore(js, fjs);
 }(document, 'script', 'facebook-jssdk'));
</script>
```

## Esempio di accesso tramite Google\$1
<a name="config-web-identity-google-login-example"></a>

Il codice seguente mostra come usare l'accesso tramite Google\$1 come provider di identità. Il token di accesso utilizzato per la federazione delle identità Web da Google è archiviato in `response.id_token` anziché in `access_token` come qualsiasi altro provider di identità. 

```
<span
  id="login"
  class="g-signin"
  data-height="short"
  data-callback="loginToGoogle"
  data-cookiepolicy="single_host_origin"
  data-requestvisibleactions="http://schemas.google.com/AddActivity"
  data-scope="https://www.googleapis.com/auth/plus.login">
</span>
<script type="text/javascript">
  var s3 = null;
  var clientID = '1234567890.apps.googleusercontent.com'; // Google client ID
  var roleArn = 'arn:aws:iam::<AWS_ACCOUNT_ID>:role/<WEB_IDENTITY_ROLE_NAME>';

  document.getElementById('login').setAttribute('data-clientid', clientID);
  function loginToGoogle(response) {
    if (!response.error) {
      AWS.config.credentials = new AWS.WebIdentityCredentials({
        RoleArn: roleArn, WebIdentityToken: response.id_token
      });

      s3 = new AWS.S3();

      console.log('You are now logged in.');
    } else {
      console.log('There was a problem logging you in.');
    }
  }

  (function() {
    var po = document.createElement('script'); po.type = 'text/javascript'; po.async = true;
    po.src = 'https://apis.google.com/js/client:plusone.js';
    var s = document.getElementsByTagName('script')[0]; s.parentNode.insertBefore(po, s);
  })();
 </script>
```