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 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>
```