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

# Incorporamento dell'analisi utilizzando le operazioni API GetDashboardEmbedURL e GetSessionEmbedURL
<a name="embedded-analytics-deprecated"></a>


|  | 
| --- |
|  Si applica a: Enterprise Edition  | 


|  | 
| --- |
|    Destinatari: sviluppatori Amazon Quick  | 

Le seguenti operazioni API per incorporare i dashboard di Amazon Quick Sight e la console Amazon Quick Sight sono state sostituite dalle operazioni GenerateEmbedUrlForAnonymousUser e GenerateEmbedUrlForRegisteredUser API. Puoi ancora usarle per incorporare analisi nella tua applicazione, ma non vengono più gestite e non contengono le più recenti caratteristiche o funzionalità di incorporamento. Per l'esperienza di up-to-date incorporamento più recente, consulta [Incorporare l'analisi di Amazon Quick Sight nelle tue applicazioni](https://docs.aws.amazon.com/quicksight/latest/user/embedding-overview.html)
+ Il funzionamento dell'[GetDashboardEmbedUrl](https://docs.aws.amazon.com/quicksight/latest/APIReference/API_GetDashboardEmbedUrl.html)API incorpora dashboard interattivi.
+ L'operazione [GetSessionEmbedUrl](https://docs.aws.amazon.com/quicksight/latest/APIReference/API_GetSessionEmbedUrl.html)API incorpora la console Amazon Quick Sight.

**Topics**
+ [

# Incorporamento di pannelli di controllo per tutti gli utenti tramite GetDashboardEmbedURL (vecchia API)
](embedded-analytics-dashboards-with-anonymous-users-get.md)
+ [

# Incorporamento di pannelli di controllo per utenti registrati tramite GetDashboardEmbedUrl (vecchia API)
](embedded-analytics-dashboards-for-authenticated-users-get.md)
+ [

# Incorporamento della console Amazon Quick Sight tramite GetSessionEmbedUrl (vecchia API)
](embedded-analytics-full-console-for-authenticated-users-get.md)

# Incorporamento di pannelli di controllo per tutti gli utenti tramite GetDashboardEmbedURL (vecchia API)
<a name="embedded-analytics-dashboards-with-anonymous-users-get"></a>

**Importante**  
Amazon Quick Sight ha delle novità APIs per l'integrazione dell'analisi: `GenerateEmbedUrlForAnonymousUser` e`GenerateEmbedUrlForRegisteredUser`.  
Puoi comunque utilizzare and `GetSessionEmbedUrl` APIs per incorporare dashboard `GetDashboardEmbedUrl` e la console Amazon Quick Sight, ma non contengono le funzionalità di incorporamento più recenti. Per l'esperienza di up-to-date incorporamento più recente, consulta [Incorporare l'analisi di Amazon Quick Sight nelle tue applicazioni](https://docs.aws.amazon.com/quicksight/latest/user/embedding-overview.html).


|  | 
| --- |
|  Si applica a: Enterprise Edition  | 


|  | 
| --- |
|    Destinatari: sviluppatori Amazon Quick  | 

Nelle sezioni seguenti, puoi trovare informazioni dettagliate su come configurare dashboard Amazon Quick Sight integrate per tutti (utenti non autenticati) tramite URL. GetDashboardEmbed

**Topics**
+ [

# Fase 1: Configurazione delle autorizzazioni
](embedded-analytics-dashboards-with-anonymous-users-get-step-1.md)
+ [

# Fase 2: Ottenimento dell'URL con il codice di autenticazione allegato
](embedded-analytics-dashboards-with-anonymous-users-get-step-2.md)
+ [

# Fase 3: Incorporamento dell'URL del pannello di controllo
](embedded-analytics-dashboards-with-anonymous-users-get-step-3.md)

# Fase 1: Configurazione delle autorizzazioni
<a name="embedded-analytics-dashboards-with-anonymous-users-get-step-1"></a>

**Importante**  
Amazon Quick Sight ha delle novità APIs per l'integrazione dell'analisi: `GenerateEmbedUrlForAnonymousUser` e`GenerateEmbedUrlForRegisteredUser`.  
Puoi comunque utilizzare and `GetSessionEmbedUrl` APIs per incorporare dashboard `GetDashboardEmbedUrl` e la console Amazon Quick Sight, ma non contengono le funzionalità di incorporamento più recenti. Per l'esperienza di up-to-date incorporamento più recente, consulta [Incorporare l'analisi di Amazon Quick Sight nelle tue applicazioni](https://docs.aws.amazon.com/quicksight/latest/user/embedding-overview.html).


|  | 
| --- |
|  Si applica a: Enterprise Edition  | 


|  | 
| --- |
|    Destinatari: sviluppatori Amazon Quick  | 

Nella sezione seguente viene descritto come configurare le autorizzazioni per l'applicazione di back-end o il server Web. Questa operazione richiede l'accesso amministrativo a IAM.

Ogni utente che accede a un pannello di controllo assume un ruolo che gli consente l'accesso e le autorizzazioni di accesso ad Amazon Quick Sight. Per rendere possibile tutto ciò, crea un ruolo IAM nel tuo account. AWS Associa una policy IAM al ruolo per fornire le autorizzazioni a qualsiasi utente che lo assume.

La seguente policy di esempio fornisce le autorizzazioni da utilizzare con `IdentityType=ANONYMOUS`. Affinché questo approccio funzioni, hai anche bisogno di un pacchetto di sessioni, o prezzi relativi alla capacità della sessione, sul tuo AWS account. Altrimenti, quando un utente prova ad accedere al pannello di controllo, viene restituito l'errore `UnsupportedPricingPlanException`. 

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

****  

```
{
    "Version":"2012-10-17",		 	 	 
    "Statement": [
        {
            "Effect": "Allow",
            "Action": [
              "quicksight:GetDashboardEmbedUrl",
              "quickSight:GetAnonymousUserEmbedUrl"
            ],
            "Resource": "*"
        }
    ]
}
```

------

È necessario che all'identità IAM dell'applicazione sia associata una policy di attendibilità per consentire l'accesso al ruolo appena creato. Ciò significa che, quando un utente accede all'applicazione, l'applicazione può assumere quel ruolo per conto dell'utente per aprire il pannello di controllo. L'esempio seguente mostra un ruolo chiamato `QuickSightEmbeddingAnonymousPolicy`, che è la policy di esempio elencata in precedenza come risorsa. 

Per ulteriori informazioni sulle policy di attendibilità, consulta [Credenziali di sicurezza provvisorie in IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_temp.html) nella *Guida per l'utente di IAM*.

# Fase 2: Ottenimento dell'URL con il codice di autenticazione allegato
<a name="embedded-analytics-dashboards-with-anonymous-users-get-step-2"></a>

**Importante**  
Amazon Quick Sight ha delle novità APIs per l'integrazione dell'analisi: `GenerateEmbedUrlForAnonymousUser` e`GenerateEmbedUrlForRegisteredUser`.  
Puoi comunque utilizzare and `GetSessionEmbedUrl` APIs per incorporare dashboard `GetDashboardEmbedUrl` e la console Amazon Quick Sight, ma non contengono le funzionalità di incorporamento più recenti. Per l'esperienza di up-to-date incorporamento più recente, consulta [Incorporare l'analisi di Amazon Quick Sight nelle tue applicazioni](https://docs.aws.amazon.com/quicksight/latest/user/embedding-overview.html).


|  | 
| --- |
|  Si applica a: Enterprise Edition  | 


|  | 
| --- |
|    Destinatari: sviluppatori Amazon Quick  | 

Nella sezione seguente, è possibile scoprire come eseguire l'autenticazione per conto del visitatore anonimo e ottenere l'URL del pannello di controllo incorporabile nel server delle applicazioni. 

Quando un utente accede all'applicazione, l'applicazione assume il ruolo IAM per conto dell'utente. Quindi aggiunge l'utente ad Amazon Quick Sight, se quell'utente non esiste già. In seguito, sarà necessario passare un identificatore come l'ID della sessione del ruolo univoco. 

Gli esempi seguenti eseguono l'autenticazione IAM per conto dell'utente. Passa un identificatore come l'ID della sessione del ruolo univoco. Questo codice viene eseguito sul server delle applicazioni.

------
#### [ Java ]

```
import com.amazonaws.auth.AWSCredentials;
import com.amazonaws.auth.BasicAWSCredentials;
import com.amazonaws.auth.AWSCredentialsProvider;
import com.amazonaws.regions.Regions;
import com.amazonaws.services.quicksight.AmazonQuickSight;
import com.amazonaws.services.quicksight.AmazonQuickSightClientBuilder;
import com.amazonaws.services.quicksight.model.GetDashboardEmbedUrlRequest;
import com.amazonaws.services.quicksight.model.GetDashboardEmbedUrlResult;

/**
 * Class to call QuickSight AWS SDK to get url for dashboard embedding.
 */
public class GetQuicksightEmbedUrlNoAuth {

    private static String ANONYMOUS = "ANONYMOUS";

    private final AmazonQuickSight quickSightClient;

    public GetQuicksightEmbedUrlNoAuth() {
        this.quickSightClient = AmazonQuickSightClientBuilder
                .standard()
                .withRegion(Regions.US_EAST_1.getName())
                .withCredentials(new AWSCredentialsProvider() {
                                     @Override
                                     public AWSCredentials getCredentials() {
                                         // provide actual IAM access key and secret key here
                                         return new BasicAWSCredentials("access-key", "secret-key");
                                     }

                                     @Override
                                     public void refresh() {}
                                 }
                )
                .build();
    }

    public String getQuicksightEmbedUrl(
            final String accountId, // YOUR AWS ACCOUNT ID
            final String dashboardId, // YOUR DASHBOARD ID TO EMBED
            final String addtionalDashboardIds, // ADDITIONAL DASHBOARD-1 ADDITIONAL DASHBOARD-2
            final boolean resetDisabled, // OPTIONAL PARAMETER TO ENABLE DISABLE RESET BUTTON IN EMBEDDED DASHBAORD
            final boolean undoRedoDisabled // OPTIONAL PARAMETER TO ENABLE DISABLE UNDO REDO BUTTONS IN EMBEDDED DASHBAORD
    ) throws Exception {
        GetDashboardEmbedUrlRequest getDashboardEmbedUrlRequest = new GetDashboardEmbedUrlRequest()
                .withDashboardId(dashboardId)
                .withAdditionalDashboardIds(addtionalDashboardIds)
                .withAwsAccountId(accountId)
                .withNamespace("default") // Anonymous embedding requires specifying a valid namespace for which you want the embedding url
                .withIdentityType(ANONYMOUS)
                .withResetDisabled(resetDisabled)
                .withUndoRedoDisabled(undoRedoDisabled);

        GetDashboardEmbedUrlResult dashboardEmbedUrl = quickSightClient.getDashboardEmbedUrl(getDashboardEmbedUrlRequest);

        return dashboardEmbedUrl.getEmbedUrl();
    }
}
```

------
#### [ JavaScript ]

```
global.fetch = require('node-fetch');
const AWS = require('aws-sdk');

function getDashboardEmbedURL(
    accountId, // YOUR AWS ACCOUNT ID
    dashboardId, // YOUR DASHBOARD ID TO EMBED
    additionalDashboardIds, // ADDITIONAL DASHBOARD-1 ADDITIONAL DASHBOARD-2
    quicksightNamespace, // VALID NAMESPACE WHERE YOU WANT TO DO NOAUTH EMBEDDING
    resetDisabled, // OPTIONAL PARAMETER TO ENABLE DISABLE RESET BUTTON IN EMBEDDED DASHBAORD
    undoRedoDisabled, // OPTIONAL PARAMETER TO ENABLE DISABLE UNDO REDO BUTTONS IN EMBEDDED DASHBAORD
    getEmbedUrlCallback, // GETEMBEDURL SUCCESS CALLBACK METHOD
    errorCallback // GETEMBEDURL ERROR CALLBACK METHOD
    ) {
    const getDashboardParams = {
        AwsAccountId: accountId,
        DashboardId: dashboardId,
        AdditionalDashboardIds: additionalDashboardIds,
        Namespace: quicksightNamespace,
        IdentityType: 'ANONYMOUS',
        ResetDisabled: resetDisabled,
        SessionLifetimeInMinutes: 600,
        UndoRedoDisabled: undoRedoDisabled
    };

    const quicksightGetDashboard = new AWS.QuickSight({
        region: process.env.AWS_REGION,
    });

    quicksightGetDashboard.getDashboardEmbedUrl(getDashboardParams, function(err, data) {
        if (err) {
            console.log(err, err.stack);
            errorCallback(err);
        } else {
            const result = {
                "statusCode": 200,
                "headers": {
                    "Access-Control-Allow-Origin": "*", // USE YOUR WEBSITE DOMAIN TO SECURE ACCESS TO GETEMBEDURL API
                    "Access-Control-Allow-Headers": "Content-Type"
                },
                "body": JSON.stringify(data),
                "isBase64Encoded": false
            }
            getEmbedUrlCallback(result);
        }
    });
}
```

------
#### [ Python3 ]

```
import json
import boto3
from botocore.exceptions import ClientError
import time

# Create QuickSight and STS clients
qs = boto3.client('quicksight',region_name='us-east-1')
sts = boto3.client('sts')

# Function to generate embedded URL
# accountId: YOUR AWS ACCOUNT ID
# dashboardId: YOUR DASHBOARD ID TO EMBED
# additionalDashboardIds: ADDITIONAL DASHBOARD-1 ADDITIONAL DASHBOARD-2 WITHOUT COMMAS
# quicksightNamespace: VALID NAMESPACE WHERE YOU WANT TO DO NOAUTH EMBEDDING
# resetDisabled: PARAMETER TO ENABLE DISABLE RESET BUTTON IN EMBEDDED DASHBAORD
# undoRedoDisabled: OPTIONAL PARAMETER TO ENABLE DISABLE UNDO REDO BUTTONS IN EMBEDDED DASHBAORD
def getDashboardURL(accountId, dashboardId, quicksightNamespace, resetDisabled, undoRedoDisabled):
    try:
        response = qs.get_dashboard_embed_url(
            AwsAccountId = accountId,
            DashboardId = dashboardId,
            AdditionalDashboardIds = additionalDashboardIds,
            Namespace = quicksightNamespace,
            IdentityType = 'ANONYMOUS',
            SessionLifetimeInMinutes = 600,
            UndoRedoDisabled = undoRedoDisabled,
            ResetDisabled = resetDisabled
        )
            
        return {
            'statusCode': 200,
            'headers': {"Access-Control-Allow-Origin": "*", "Access-Control-Allow-Headers": "Content-Type"},
            'body': json.dumps(response),
            'isBase64Encoded':  bool('false')
        }
    except ClientError as e:
        print(e)
        return "Error generating embeddedURL: " + str(e)
```

------
#### [ Node.js ]

L'esempio seguente mostra JavaScript (Node.js) che puoi usare sul server dell'app per ottenere l'URL della dashboard incorporata. È possibile utilizzare questo URL nel sito web o nell'applicazione per visualizzare il pannello di controllo. 

**Example**  

```
const AWS = require('aws-sdk');
            const https = require('https');
            
            var quicksight = new AWS.Service({
                apiConfig: require('./quicksight-2018-04-01.min.json'),
                region: 'us-east-1',
            });
            
            quicksight.getDashboardEmbedUrl({
                'AwsAccountId': '111122223333',
                'DashboardId': 'dashboard-id',
                'AdditionalDashboardIds': 'added-dashboard-id-1 added-dashboard-id-2 added-dashboard-id-3'
                'Namespace' : 'default',
                'IdentityType': 'ANONYMOUS',
                'SessionLifetimeInMinutes': 100,
                'UndoRedoDisabled': false,
                'ResetDisabled': true
            
            }, function(err, data) {
                console.log('Errors: ');
                console.log(err);
                console.log('Response: ');
                console.log(data);
            });
```

**Example**  

```
//The URL returned is over 900 characters. For this example, we've shortened the string for
            //readability and added ellipsis to indicate that it's incomplete.
                                { Status: 200,
              EmbedUrl: 'https://dashboards.example.com/embed/620bef10822743fab329fb3751187d2d…
              RequestId: '7bee030e-f191-45c4-97fe-d9faf0e03713' }
```

------
#### [ .NET/C\$1 ]

L'esempio seguente mostra il codice .NET/C \$1 che è possibile utilizzare nel server app per ottenere l'URL per il pannello di controllo incorporato. È possibile utilizzare questo URL nel sito web o nell'applicazione per visualizzare il pannello di controllo. 

**Example**  

```
            var client = new AmazonQuickSightClient(
                AccessKey,
                SecretAccessKey,
                sessionToken,
                Amazon.RegionEndpoint.USEast1);
            try
            {
                Console.WriteLine(
                    client.GetDashboardEmbedUrlAsync(new GetDashboardEmbedUrlRequest
                    {
                        AwsAccountId = “111122223333”,
                        DashboardId = "dashboard-id",
                        AdditionalDashboardIds = "added-dashboard-id-1 added-dashboard-id-2 added-dashboard-id-3",
                        Namespace = default,
                        IdentityType = IdentityType.ANONYMOUS,
                        SessionLifetimeInMinutes = 600,
                        UndoRedoDisabled = false,
                        ResetDisabled = true
                    }).Result.EmbedUrl
                );
            } catch (Exception ex) {
                Console.WriteLine(ex.Message);
            }
```

------
#### [ AWS CLI ]

Per assumere il ruolo, scegliete una delle seguenti operazioni API AWS Security Token Service (AWS STS):
+ [AssumeRole](https://docs.aws.amazon.com/STS/latest/APIReference/API_AssumeRole.html)— Utilizzate questa operazione quando utilizzate un'identità IAM per assumere il ruolo.
+ [AssumeRoleWithWebIdentity](https://docs.aws.amazon.com/STS/latest/APIReference/API_AssumeRoleWithWebIdentity.html)— Utilizzate questa operazione quando utilizzate un provider di identità web per autenticare l'utente. 
+ [AssumeRoleWithSaml](https://docs.aws.amazon.com/STS/latest/APIReference/API_AssumeRoleWithSAML.html)— Utilizzate questa operazione quando utilizzate Security Assertion Markup Language (SAML) per autenticare gli utenti.

L'esempio seguente mostra il comando dell'interfaccia a riga di comando per impostare il ruolo IAM. Il ruolo deve avere le autorizzazioni abilitate per `quicksight:GetDashboardEmbedURL`. 

```
aws sts assume-role \
     --role-arn "arn:aws:iam::11112222333:role/QuickSightEmbeddingAnonymousPolicy" \
     --role-session-name anonymous caller
```

L'operazione `assume-role` restituisce tre parametri di output: la chiave di accesso, la chiave segreta e il token della sessione. 

**Nota**  
Se si verifica un errore `ExpiredToken` durante la chiamata all'operazione `AssumeRole`, vuol dire che il `SESSION TOKEN` precedente è ancora presente nelle variabili di ambiente. Cancellala impostando le seguenti variabili:  
*AWS\$1ACCESS\$1KEY\$1ID* 
*AWS\$1SECRET\$1CHIAVE\$1ACCESSO* 
*AWS\$1SESSION\$1GETTONE* 

L'esempio seguente mostra come impostare questi tre parametri nell'interfaccia a riga di comando. Se usi un computer Microsoft Windows, utilizza `set` invece di `export`.

```
export AWS_ACCESS_KEY_ID     = "access_key_from_assume_role"
export AWS_SECRET_ACCESS_KEY = "secret_key_from_assume_role"
export AWS_SESSION_TOKEN     = "session_token_from_assume_role"
```

L'esecuzione di questi comandi imposta l'ID della sessione del ruolo dell'utente che visita la pagina del tuo sito web su`embedding_quicksight_dashboard_role/QuickSightEmbeddingAnonymousPolicy`. L'ID della sessione del ruolo è costituito dal nome del ruolo di `role-arn` e dal valore `role-session-name`. L'utilizzo dell'ID della sessione del ruolo univoco per ciascun utente garantisce che le autorizzazioni appropriate siano impostate per ogni utente visitatore. Inoltre, mantiene ogni sessione separata e distinta. Se utilizzi una serie di server Web, ad esempio per il bilanciamento del carico, e una sessione viene ricollegata a un server diverso, viene avviata una nuova sessione.

Per ottenere un URL firmato per il pannello di controllo, chiama `get-dashboard-embed-url` dal server delle applicazioni. Questo restituisce l'URL del pannello di controllo incorporato. L'esempio seguente mostra come generare l'URL per un pannello di controllo incorporato utilizzando una chiamata lato server per gli utenti che effettuano visite anonime al portale Web o all'applicazione.

```
aws quicksight get-dashboard-embed-url \
     --aws-account-id 111122223333 \
     --dashboard-id dashboard-id \
     --additional-dashboard-ids added-dashboard-id-1 added-dashboard-id-2 added-dashboard-id-3
     --namespace default-or-something-else \
     --identity-type ANONYMOUS \
     --session-lifetime-in-minutes 30 \
     --undo-redo-disabled true \
     --reset-disabled true \
     --user-arn arn:aws:quicksight:us-east-1:111122223333:user/default/QuickSightEmbeddingAnonymousPolicy/embeddingsession
```

Per ulteriori informazioni sull'utilizzo di questa operazione, consulta [https://docs.aws.amazon.com/quicksight/latest/APIReference/API_GetDashboardEmbedUrl.html](https://docs.aws.amazon.com/quicksight/latest/APIReference/API_GetDashboardEmbedUrl.html). Puoi utilizzare questa API e altre operazioni nel tuo codice. 

------

# Fase 3: Incorporamento dell'URL del pannello di controllo
<a name="embedded-analytics-dashboards-with-anonymous-users-get-step-3"></a>

**Importante**  
Amazon Quick Sight ha delle novità APIs per l'integrazione dell'analisi: `GenerateEmbedUrlForAnonymousUser` e`GenerateEmbedUrlForRegisteredUser`.  
Puoi comunque utilizzare and `GetSessionEmbedUrl` APIs per incorporare dashboard `GetDashboardEmbedUrl` e la console Amazon Quick Sight, ma non contengono le funzionalità di incorporamento più recenti. Per l'esperienza di up-to-date incorporamento più recente, consulta [Incorporare l'analisi di Amazon Quick Sight nelle tue applicazioni](https://docs.aws.amazon.com/quicksight/latest/user/embedding-overview.html).


|  | 
| --- |
|  Si applica a: Enterprise Edition  | 


|  | 
| --- |
|    Destinatari: sviluppatori Amazon Quick  | 

Nella sezione seguente, puoi scoprire come utilizzare l'[SDK di incorporamento di Amazon Quick Sight (JavaScript) per incorporare](https://www.npmjs.com/package/amazon-quicksight-embedding-sdk) l'URL della dashboard dal passaggio 2 nella pagina del tuo sito Web o dell'applicazione. Con il kit SDK, puoi procedere come segue: 
+ Posiziona il pannello di controllo in una pagina HTML.
+ Passare i parametri nel pannello di controllo.
+ Gestisci stati di errore con messaggi personalizzati per l'applicazione.

Chiama l'operazione API `GetDashboardEmbedUrl` per ottenere l'URL da incorporare nell'applicazione. Questo URL è valido per 5 minuti, mentre la sessione risultante è valida per 10 ore. L'operazione API fornisce l'URL con un `auth_code` che consente una sessione di single sign-on. 

Di seguito viene mostrata una risposta di esempio da `get-dashboard-embed-url`.

```
//The URL returned is over 900 characters. For this example, we've shortened the string for
//readability and added ellipsis to indicate that it's incomplete.
{
     "Status": "200",
     "EmbedUrl": "https: //dashboards.example.com/embed/620bef10822743fab329fb3751187d2d...",
     "RequestId": "7bee030e-f191-45c4-97fe-d9faf0e03713"
}
```

Incorpora questa dashboard nella tua pagina Web utilizzando l'[SDK Amazon Quick Sight Embedding](https://www.npmjs.com/package/amazon-quicksight-embedding-sdk) o aggiungendo questo URL in un iframe. Se imposti un numero fisso di altezza e larghezza (in pixel), Amazon Quick Sight li utilizza e non modifica la visualizzazione durante il ridimensionamento della finestra. Se imposti un'altezza e una larghezza percentuali relative, Amazon Quick Sight fornisce un layout reattivo che viene modificato al variare delle dimensioni della finestra. Utilizzando Amazon Quick Sight Embedding SDK, puoi anche controllare i parametri all'interno della dashboard e ricevere callback in termini di completamento del caricamento della pagina ed errori. 

Il seguente esempio illustra come utilizzare l'URL generato. Questo codice si trova sul server delle applicazioni.

```
<!DOCTYPE html>
<html>

<head>
    <title>Basic Embed</title>
    <!-- You can download the latest QuickSight embedding SDK version from https://www.npmjs.com/package/amazon-quicksight-embedding-sdk -->
    <!-- Or you can do "npm install amazon-quicksight-embedding-sdk", if you use npm for javascript dependencies -->
    <script src="./quicksight-embedding-js-sdk.min.js"></script>
    <script type="text/javascript">
        var dashboard;

        function embedDashboard() {
            var containerDiv = document.getElementById("embeddingContainer");
            var options = {
                // replace this dummy url with the one generated via embedding API
                url: "https://us-east-1.quicksight.aws.amazon.com/sn/dashboards/dashboardId?isauthcode=true&identityprovider=quicksight&code=authcode",  
                container: containerDiv,
                scrolling: "no",
                height: "700px",
                width: "1000px",
                footerPaddingEnabled: true
            };
            dashboard = QuickSightEmbedding.embedDashboard(options);
        }
    </script>
</head>

<body onload="embedDashboard()">
    <div id="embeddingContainer"></div>
</body>

</html>
```

Affinché questo esempio funzioni, assicurati di utilizzare l'SDK Amazon Quick Sight Embedding per caricare la dashboard incorporata sul tuo sito Web utilizzando. JavaScript Per ottenere la tua copia, procedi in uno dei seguenti modi:
+ Scarica l'[SDK di incorporamento Amazon Quick Sight da.](https://github.com/awslabs/amazon-quicksight-embedding-sdk#step-3-create-the-quicksight-session-object) GitHub Questo repository è gestito da un gruppo di sviluppatori di Amazon Quick Sight.
+ Scarica l'ultima versione dell'SDK QuickSight di incorporamento da. [https://www.npmjs.com/package/amazon-quicksight-embedding-sdk](https://www.npmjs.com/package/amazon-quicksight-embedding-sdk)
+ Se lo utilizzi `npm` per JavaScript le dipendenze, scaricalo e installalo eseguendo il comando seguente.

  ```
  npm install amazon-quicksight-embedding-sdk
  ```

# Incorporamento di pannelli di controllo per utenti registrati tramite GetDashboardEmbedUrl (vecchia API)
<a name="embedded-analytics-dashboards-for-authenticated-users-get"></a>

**Importante**  
Amazon Quick Sight ha delle novità APIs per l'integrazione dell'analisi: `GenerateEmbedUrlForAnonymousUser` e`GenerateEmbedUrlForRegisteredUser`.  
Puoi comunque utilizzare and `GetSessionEmbedUrl` APIs per incorporare dashboard `GetDashboardEmbedUrl` e la console Amazon Quick Sight, ma non contengono le funzionalità di incorporamento più recenti. Per l'esperienza di up-to-date incorporamento più recente, consulta [Incorporare l'analisi di Amazon Quick Sight nelle tue applicazioni](https://docs.aws.amazon.com/quicksight/latest/user/embedding-overview.html).

Nelle sezioni seguenti, puoi trovare informazioni dettagliate su come configurare dashboard Amazon Quick Sight integrate per gli utenti registrati che utilizzano`GetDashboardEmbedUrl`.

**Topics**
+ [

# Fase 1: Configurazione delle autorizzazioni
](embedded-dashboards-for-authenticated-users-get-step-1.md)
+ [

# Fase 2: Ottenimento dell'URL con il codice di autenticazione allegato
](embedded-dashboards-for-authenticated-users-get-step-2.md)
+ [

# Fase 3: Incorporamento dell'URL del pannello di controllo
](embedded-dashboards-for-authenticated-users-get-step-3.md)

# Fase 1: Configurazione delle autorizzazioni
<a name="embedded-dashboards-for-authenticated-users-get-step-1"></a>

**Importante**  
Amazon Quick Sight ha delle novità APIs per l'integrazione dell'analisi: `GenerateEmbedUrlForAnonymousUser` e`GenerateEmbedUrlForRegisteredUser`.  
Puoi comunque utilizzare and `GetSessionEmbedUrl` APIs per incorporare dashboard `GetDashboardEmbedUrl` e la console Amazon Quick Sight, ma non contengono le funzionalità di incorporamento più recenti. Per l'esperienza di up-to-date incorporamento più recente, consulta [Incorporare l'analisi di Amazon Quick Sight nelle tue applicazioni](https://docs.aws.amazon.com/quicksight/latest/user/embedding-overview.html).

Nella sezione seguente viene descritto come configurare le autorizzazioni per l'applicazione di back-end o il server Web. Questa operazione richiede l'accesso amministrativo a IAM.

Ogni utente che accede a una dashboard assume un ruolo che gli consente l'accesso e le autorizzazioni di Amazon Quick Sight alla dashboard. Per rendere possibile tutto ciò, crea un ruolo IAM nel tuo account. AWS Associa una policy IAM al ruolo per fornire le autorizzazioni a qualsiasi utente che lo assume. Il ruolo IAM deve fornire le autorizzazioni per recuperare la dashboard. URLs Per questo, aggiungi `quicksight:GetDashboardEmbedUrl`.

La seguente policy di esempio fornisce le autorizzazioni da utilizzare con `IdentityType=IAM`. 

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

****  

```
{
    "Version":"2012-10-17",		 	 	 
    "Statement": [
        {
            "Effect": "Allow",
            "Action": [
                "quicksight:GetDashboardEmbedUrl"
            ],
            "Resource": "*"
        }
    ]
}
```

------

La seguente policy di esempio fornisce l'autorizzazione a recuperare l'URL di un pannello di controllo. Utilizzi la policy con `quicksight:RegisterUser` se stai creando utenti alle prime armi che devono essere lettori di Amazon Quick Sight. 

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

****  

```
{
  "Version":"2012-10-17",		 	 	 
  "Statement": [
    {
      "Action": "quicksight:RegisterUser",
      "Resource": "*",
      "Effect": "Allow"
    },
    {
      "Action": "quicksight:GetDashboardEmbedUrl",
      "Resource": "*",
      "Effect": "Allow"
    }
  ]
}
```

------

Se utilizzi `QUICKSIGHT` come `identityType` e fornisci il nome della risorsa Amazon (ARN) dell'utente, dovrai consentire anche l'operazione `quicksight:GetAuthCode` nella policy. Tale autorizzazione è fornita dalla seguente policy di esempio.

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

****  

```
{
  "Version":"2012-10-17",		 	 	 
  "Statement": [
    {
      "Effect": "Allow",
      "Action": [
        "quicksight:GetDashboardEmbedUrl",
        "quicksight:GetAuthCode"
      ],
      "Resource": "*"
    }
  ]
}
```

------

È necessario che all'identità IAM dell'applicazione sia associata una policy di attendibilità per consentire l'accesso al ruolo appena creato. Ciò significa che quando un utente accede alla tua applicazione, quest'ultima può assumere il ruolo per conto dell'utente ed eseguire il provisioning dell'utente in Amazon Quick Sight. L'esempio seguente mostra un ruolo chiamato `embedding_quicksight_dashboard_role`, che è la policy di esempio elencata in precedenza come risorsa. 

Per ulteriori informazioni sulle policy di trust per OpenID Connect o l'autenticazione SAML, consulta le sezioni seguenti della *Guida per l'utente di IAM*:
+ [Creazione di un ruolo per la federazione di identità Web oppure OpenID Connect (console)](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_create_for-idp_oidc.html)
+ [Creazione di un ruolo per una federazione SAML 2.0 (console)](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_create_for-idp_saml.html)

# Fase 2: Ottenimento dell'URL con il codice di autenticazione allegato
<a name="embedded-dashboards-for-authenticated-users-get-step-2"></a>

**Importante**  
Amazon Quick Sight ha delle novità APIs per l'integrazione dell'analisi: `GenerateEmbedUrlForAnonymousUser` e`GenerateEmbedUrlForRegisteredUser`.  
Puoi comunque utilizzare and `GetSessionEmbedUrl` APIs per incorporare dashboard `GetDashboardEmbedUrl` e la console Amazon Quick Sight, ma non contengono le funzionalità di incorporamento più recenti. Per l'esperienza di up-to-date incorporamento più recente, consulta [Incorporare l'analisi di Amazon Quick Sight nelle tue applicazioni](https://docs.aws.amazon.com/quicksight/latest/user/embedding-overview.html).

Nella sezione seguente, è possibile scoprire come autenticare l'utente e ottenere l'URL del pannello di controllo incorporato nel server delle applicazioni. 

Quando un utente accede all'applicazione, l'applicazione assume il ruolo IAM per conto dell'utente. Quindi aggiunge l'utente ad Amazon Quick Sight, se quell'utente non esiste già. In seguito, sarà necessario passare un identificatore come l'ID della sessione del ruolo univoco. 

L'esecuzione dei passaggi descritti garantisce che ogni visualizzatore della dashboard sia fornito in modo univoco in Amazon Quick Sight. Applica inoltre le impostazioni per utente, ad esempio la sicurezza a livello di riga e le impostazioni predefinite dinamiche per i parametri.

Gli esempi seguenti eseguono l'autenticazione IAM per conto dell'utente. Questo codice viene eseguito sul server delle applicazioni.

------
#### [ Java ]

```
import com.amazonaws.auth.AWSCredentials;
import com.amazonaws.auth.AWSStaticCredentialsProvider;
import com.amazonaws.auth.BasicSessionCredentials;
import com.amazonaws.auth.BasicAWSCredentials;
import com.amazonaws.auth.AWSCredentialsProvider;
import com.amazonaws.regions.Regions;
import com.amazonaws.services.quicksight.AmazonQuickSight;
import com.amazonaws.services.quicksight.AmazonQuickSightClientBuilder;
import com.amazonaws.services.quicksight.model.GetDashboardEmbedUrlRequest;
import com.amazonaws.services.quicksight.model.GetDashboardEmbedUrlResult;
import com.amazonaws.services.securitytoken.AWSSecurityTokenService;
import com.amazonaws.services.securitytoken.model.AssumeRoleRequest;
import com.amazonaws.services.securitytoken.model.AssumeRoleResult;

/**
 * Class to call QuickSight AWS SDK to get url for dashboard embedding.
 */
public class GetQuicksightEmbedUrlIAMAuth {

    private static String IAM = "IAM";

    private final AmazonQuickSight quickSightClient;

    private final AWSSecurityTokenService awsSecurityTokenService;

    public GetQuicksightEmbedUrlIAMAuth(final AWSSecurityTokenService awsSecurityTokenService) {
        this.quickSightClient = AmazonQuickSightClientBuilder
                .standard()
                .withRegion(Regions.US_EAST_1.getName())
                .withCredentials(new AWSCredentialsProvider() {
                                     @Override
                                     public AWSCredentials getCredentials() {
                                         // provide actual IAM access key and secret key here
                                         return new BasicAWSCredentials("access-key", "secret-key");
                                     }

                                     @Override
                                     public void refresh() {}
                                 }
                )
                .build();
        this.awsSecurityTokenService = awsSecurityTokenService;
    }

    public String getQuicksightEmbedUrl(
            final String accountId, // YOUR AWS ACCOUNT ID
            final String dashboardId, // YOUR DASHBOARD ID TO EMBED
            final String openIdToken, // TOKEN TO ASSUME ROLE WITH ROLEARN
            final String roleArn, // IAM USER ROLE TO USE FOR EMBEDDING
            final String sessionName, // SESSION NAME FOR THE ROLEARN ASSUME ROLE
            final boolean resetDisabled, // OPTIONAL PARAMETER TO ENABLE DISABLE RESET BUTTON IN EMBEDDED DASHBAORD
            final boolean undoRedoDisabled // OPTIONAL PARAMETER TO ENABLE DISABLE UNDO REDO BUTTONS IN EMBEDDED DASHBAORD
    ) throws Exception {
        AssumeRoleRequest request = new AssumeRoleRequest()
                .withRoleArn(roleArn)
                .withRoleSessionName(sessionName)
                .withTokenCode(openIdToken)
                .withDurationSeconds(3600);
        AssumeRoleResult assumeRoleResult = awsSecurityTokenService.assumeRole(request);

        AWSCredentials temporaryCredentials = new BasicSessionCredentials(
                assumeRoleResult.getCredentials().getAccessKeyId(),
                assumeRoleResult.getCredentials().getSecretAccessKey(),
                assumeRoleResult.getCredentials().getSessionToken());
        AWSStaticCredentialsProvider awsStaticCredentialsProvider = new AWSStaticCredentialsProvider(temporaryCredentials);

        GetDashboardEmbedUrlRequest getDashboardEmbedUrlRequest = new GetDashboardEmbedUrlRequest()
                .withDashboardId(dashboardId)
                .withAwsAccountId(accountId)
                .withIdentityType(IAM)
                .withResetDisabled(resetDisabled)
                .withUndoRedoDisabled(undoRedoDisabled)
                .withRequestCredentialsProvider(awsStaticCredentialsProvider);

        GetDashboardEmbedUrlResult dashboardEmbedUrl = quickSightClient.getDashboardEmbedUrl(getDashboardEmbedUrlRequest);

        return dashboardEmbedUrl.getEmbedUrl();
    }
}
```

------
#### [ JavaScript ]

```
global.fetch = require('node-fetch');
const AWS = require('aws-sdk');

function getDashboardEmbedURL(
    accountId, // YOUR AWS ACCOUNT ID
    dashboardId, // YOUR DASHBOARD ID TO EMBED
    openIdToken, // TOKEN TO ASSUME ROLE WITH ROLEARN
    roleArn, // IAM USER ROLE TO USE FOR EMBEDDING
    sessionName, // SESSION NAME FOR THE ROLEARN ASSUME ROLE
    resetDisabled, // OPTIONAL PARAMETER TO ENABLE DISABLE RESET BUTTON IN EMBEDDED DASHBAORD
    undoRedoDisabled, // OPTIONAL PARAMETER TO ENABLE DISABLE UNDO REDO BUTTONS IN EMBEDDED DASHBAORD
    getEmbedUrlCallback, // GETEMBEDURL SUCCESS CALLBACK METHOD
    errorCallback // GETEMBEDURL ERROR CALLBACK METHOD
    ) {
    const stsClient = new AWS.STS();
    let stsParams = {
        RoleSessionName: sessionName,
        WebIdentityToken: openIdToken,
        RoleArn: roleArn
    }

    stsClient.assumeRoleWithWebIdentity(stsParams, function(err, data) {
        if (err) {
            console.log('Error assuming role');
            console.log(err, err.stack);
            errorCallback(err);
        } else {
            const getDashboardParams = {
                AwsAccountId: accountId,
                DashboardId: dashboardId,
                IdentityType: 'IAM',
                ResetDisabled: resetDisabled,
                SessionLifetimeInMinutes: 600,
                UndoRedoDisabled: undoRedoDisabled
            };

            const quicksightGetDashboard = new AWS.QuickSight({
                region: process.env.AWS_REGION,
                credentials: {
                    accessKeyId: data.Credentials.AccessKeyId,
                    secretAccessKey: data.Credentials.SecretAccessKey,
                    sessionToken: data.Credentials.SessionToken,
                    expiration: data.Credentials.Expiration
                }
            });

            quicksightGetDashboard.getDashboardEmbedUrl(getDashboardParams, function(err, data) {
                if (err) {
                    console.log(err, err.stack);
                    errorCallback(err);
                } else {
                    const result = {
                        "statusCode": 200,
                        "headers": {
                            "Access-Control-Allow-Origin": "*", // USE YOUR WEBSITE DOMAIN TO SECURE ACCESS TO GETEMBEDURL API
                            "Access-Control-Allow-Headers": "Content-Type"
                        },
                        "body": JSON.stringify(data),
                        "isBase64Encoded": false
                    }
                    getEmbedUrlCallback(result);
                }
            });
        }
    });
}
```

------
#### [ Python3 ]

```
import json
import boto3
from botocore.exceptions import ClientError

# Create QuickSight and STS clients
qs = boto3.client('quicksight',region_name='us-east-1')
sts = boto3.client('sts')

# Function to generate embedded URL  
# accountId: YOUR AWS ACCOUNT ID
# dashboardId: YOUR DASHBOARD ID TO EMBED
# openIdToken: TOKEN TO ASSUME ROLE WITH ROLEARN
# roleArn: IAM USER ROLE TO USE FOR EMBEDDING
# sessionName: SESSION NAME FOR THE ROLEARN ASSUME ROLE
# resetDisabled: PARAMETER TO ENABLE DISABLE RESET BUTTON IN EMBEDDED DASHBAORD
# undoRedoDisabled: PARAMETER TO ENABLE DISABLE UNDO REDO BUTTONS IN EMBEDDED DASHBAORD
def getDashboardURL(accountId, dashboardId, openIdToken, roleArn, sessionName, resetDisabled, undoRedoDisabled):
    try:
        assumedRole = sts.assume_role(
            RoleArn = roleArn,
            RoleSessionName = sessionName,
            WebIdentityToken = openIdToken
        )
    except ClientError as e:
        return "Error assuming role: " + str(e)
    else: 
        assumedRoleSession = boto3.Session(
            aws_access_key_id = assumedRole['Credentials']['AccessKeyId'],
            aws_secret_access_key = assumedRole['Credentials']['SecretAccessKey'],
            aws_session_token = assumedRole['Credentials']['SessionToken'],
        )
        try:
            quickSight = assumedRoleSession.client('quicksight',region_name='us-east-1')
            
            response = quickSight.get_dashboard_embed_url(
                 AwsAccountId = accountId,
                 DashboardId = dashboardId,
                 IdentityType = 'IAM',
                 SessionLifetimeInMinutes = 600,
                 UndoRedoDisabled = undoRedoDisabled,
                 ResetDisabled = resetDisabled
            )
            
            return {
                'statusCode': 200,
                'headers': {"Access-Control-Allow-Origin": "*", "Access-Control-Allow-Headers": "Content-Type"},
                'body': json.dumps(response),
                'isBase64Encoded':  bool('false')
            }
        except ClientError as e:
            return "Error generating embeddedURL: " + str(e)
```

------
#### [ Node.js ]

L'esempio seguente mostra il file JavaScript (Node.js) che puoi usare sul server dell'app per ottenere l'URL della dashboard incorporata. È possibile utilizzare questo URL nel sito web o nell'applicazione per visualizzare il pannello di controllo. 

**Example**  

```
const AWS = require('aws-sdk');
            const https = require('https');
            
            var quicksight = new AWS.Service({
                apiConfig: require('./quicksight-2018-04-01.min.json'),
                region: 'us-east-1',
            });
            
            quicksight.getDashboardEmbedUrl({
                'AwsAccountId': '111122223333',
                'DashboardId': '1c1fe111-e2d2-3b30-44ef-a0e111111cde',
                'IdentityType': 'IAM',
                'ResetDisabled': true,
                'SessionLifetimeInMinutes': 100,
                'UndoRedoDisabled': false,
                'StatePersistenceEnabled': true
            
            }, function(err, data) {
                console.log('Errors: ');
                console.log(err);
                console.log('Response: ');
                console.log(data);
            });
```

**Example**  

```
//The URL returned is over 900 characters. For this example, we've shortened the string for
            //readability and added ellipsis to indicate that it's incomplete.
                                { Status: 200,
              EmbedUrl: 'https://dashboards.example.com/embed/620bef10822743fab329fb3751187d2d…
              RequestId: '7bee030e-f191-45c4-97fe-d9faf0e03713' }
```

------
#### [ .NET/C\$1 ]

L'esempio seguente mostra il codice .NET/C \$1 che è possibile utilizzare nel server app per ottenere l'URL per il pannello di controllo incorporato. È possibile utilizzare questo URL nel sito web o nell'applicazione per visualizzare il pannello di controllo. 

**Example**  

```
            var client = new AmazonQuickSightClient(
                AccessKey,
                SecretAccessKey,
                sessionToken,
                Amazon.RegionEndpoint.USEast1);
            try
            {
                Console.WriteLine(
                    client.GetDashboardEmbedUrlAsync(new GetDashboardEmbedUrlRequest
                    {
                        AwsAccountId = “111122223333”,
                        DashboardId = "1c1fe111-e2d2-3b30-44ef-a0e111111cde",
                        IdentityType = EmbeddingIdentityType.IAM,
                        ResetDisabled = true,
                        SessionLifetimeInMinutes = 100,
                        UndoRedoDisabled = false,
                        StatePersistenceEnabled = true
                    }).Result.EmbedUrl
                );
            } catch (Exception ex) {
                Console.WriteLine(ex.Message);
            }
```

------
#### [ AWS CLI ]

Per assumere il ruolo, scegliete una delle seguenti operazioni API AWS Security Token Service (AWS STS):
+ [AssumeRole](https://docs.aws.amazon.com/STS/latest/APIReference/API_AssumeRole.html)— Utilizzate questa operazione quando utilizzate un'identità IAM per assumere il ruolo.
+ [AssumeRoleWithWebIdentity](https://docs.aws.amazon.com/STS/latest/APIReference/API_AssumeRoleWithWebIdentity.html)— Utilizzate questa operazione quando utilizzate un provider di identità web per autenticare l'utente. 
+ [AssumeRoleWithSaml](https://docs.aws.amazon.com/STS/latest/APIReference/API_AssumeRoleWithSAML.html)— Utilizza questa operazione quando utilizzi SAML per autenticare i tuoi utenti.

L'esempio seguente mostra il comando dell'interfaccia a riga di comando per impostare il ruolo IAM. Il ruolo deve avere le autorizzazioni abilitate per `quicksight:GetDashboardEmbedURL`. Se stai adottando un just-in-time approccio per aggiungere utenti quando aprono per la prima volta una dashboard, per il ruolo è necessario abilitare anche le autorizzazioni. `quicksight:RegisterUser`

```
aws sts assume-role \
     --role-arn "arn:aws:iam::111122223333:role/embedding_quicksight_dashboard_role" \
     --role-session-name john.doe@example.com
```

L'operazione `assume-role` restituisce tre parametri di output: la chiave di accesso, la chiave segreta e il token della sessione. 

**Nota**  
Se si verifica un errore `ExpiredToken` durante la chiamata all'operazione `AssumeRole`, vuol dire che il `SESSION TOKEN` precedente è ancora presente nelle variabili di ambiente. Cancellala impostando le seguenti variabili:  
*AWS\$1ACCESS\$1KEY\$1ID* 
*AWS\$1SECRET\$1CHIAVE\$1ACCESSO* 
*AWS\$1SESSION\$1GETTONE* 

L'esempio seguente mostra come impostare questi tre parametri nell'interfaccia a riga di comando. Se usi un computer Microsoft Windows, utilizza `set` invece di `export`.

```
export AWS_ACCESS_KEY_ID     = "access_key_from_assume_role"
export AWS_SECRET_ACCESS_KEY = "secret_key_from_assume_role"
export AWS_SESSION_TOKEN     = "session_token_from_assume_role"
```

L'esecuzione di questi comandi imposta l'ID della sessione del ruolo dell'utente che visita la pagina del tuo sito web su`embedding_quicksight_dashboard_role/john.doe@example.com`. L'ID della sessione del ruolo è costituito dal nome del ruolo di `role-arn` e dal valore `role-session-name`. L'utilizzo dell'ID della sessione del ruolo univoco per ciascun utente garantisce che le autorizzazioni appropriate siano impostate per ogni utente. Impedisce inoltre il throttling dell'accesso degli utenti. La *limitazione* è una funzionalità di sicurezza che impedisce allo stesso utente di accedere ad Amazon Quick Sight da più postazioni. 

L'ID della sessione del ruolo diventa anche il nome utente in Amazon Quick Sight. Puoi utilizzare questo modello per effettuare il provisioning dei tuoi utenti in Amazon Quick Sight in anticipo o per effettuare il provisioning la prima volta che accedono alla dashboard. 

L'esempio seguente mostra il comando dell'interfaccia a riga di comando che è possibile utilizzare per effettuare il provisioning di un utente. Per ulteriori informazioni [RegisterUser](https://docs.aws.amazon.com/quicksight/latest/APIReference/API_RegisterUser.html)e altre operazioni dell'API Amazon Quick Sight, consulta il [riferimento all'API Amazon Quick Sight](https://docs.aws.amazon.com/quicksight/latest/APIReference/Welcome.html). [DescribeUser](https://docs.aws.amazon.com/quicksight/latest/APIReference/API_DescribeUser.html)

```
aws quicksight register-user \
     --aws-account-id 111122223333 \
     --namespace default \
     --identity-type IAM \
     --iam-arn "arn:aws:iam::111122223333:role/embedding_quicksight_dashboard_role" \
     --user-role READER \
     --user-name jhnd \
     --session-name "john.doe@example.com" \
     --email john.doe@example.com \
     --region us-east-1 \
     --custom-permissions-name TeamA1
```

Se l'utente viene autenticato tramite Microsoft AD, non è necessario utilizzare `RegisterUser` per configurarlo. Dovrebbero invece essere abbonati automaticamente la prima volta che accedono ad Amazon Quick Sight. Per gli utenti Microsoft AD, puoi utilizzare `DescribeUser` per ottenere l'ARN dell'utente.

La prima volta che un utente accede ad Amazon Quick Sight, puoi anche aggiungere questo utente al gruppo con cui è condivisa la dashboard. L'esempio seguente mostra il comando dell'interfaccia a riga di comando per aggiungere un utente a un gruppo.

```
aws quicksight create-group-membership \
     --aws-account-id=111122223333 \
     --namespace=default \
     --group-name=financeusers \
     --member-name="embedding_quicksight_dashboard_role/john.doe@example.com"
```

Ora hai un utente della tua app che è anche utente di Amazon Quick Sight e che ha accesso alla dashboard. 

Infine, per ottenere un URL provvisto di firma per il pannello di controllo, chiama `get-dashboard-embed-url` dal server delle applicazioni. Questo restituisce l'URL del pannello di controllo incorporato. L'esempio seguente mostra come ottenere l'URL per una dashboard incorporata utilizzando una chiamata lato server per gli utenti autenticati tramite AWS Managed Microsoft AD o IAM Identity Center.

```
aws quicksight get-dashboard-embed-url \
     --aws-account-id 111122223333 \
     --dashboard-id 1a1ac2b2-3fc3-4b44-5e5d-c6db6778df89 \
     --identity-type IAM \
     --session-lifetime-in-minutes 30 \
     --undo-redo-disabled true \
     --reset-disabled true \
     --state-persistence-enabled true \
     --user-arn arn:aws:quicksight:us-east-1:111122223333:user/default/embedding_quicksight_dashboard_role/embeddingsession
```

Per ulteriori informazioni sull'utilizzo di questa operazione, consulta [https://docs.aws.amazon.com/quicksight/latest/APIReference/API_GetDashboardEmbedUrl.html](https://docs.aws.amazon.com/quicksight/latest/APIReference/API_GetDashboardEmbedUrl.html). Puoi utilizzare questa API e altre operazioni nel tuo codice. 

------

# Fase 3: Incorporamento dell'URL del pannello di controllo
<a name="embedded-dashboards-for-authenticated-users-get-step-3"></a>

**Importante**  
Amazon Quick Sight ha delle novità APIs per l'integrazione dell'analisi: `GenerateEmbedUrlForAnonymousUser` e`GenerateEmbedUrlForRegisteredUser`.  
Puoi comunque utilizzare and `GetSessionEmbedUrl` APIs per incorporare dashboard `GetDashboardEmbedUrl` e la console Amazon Quick Sight, ma non contengono le funzionalità di incorporamento più recenti. Per l'esperienza di up-to-date incorporamento più recente, consulta [Incorporare l'analisi di Amazon Quick Sight nelle tue applicazioni](https://docs.aws.amazon.com/quicksight/latest/user/embedding-overview.html).

Nella sezione seguente, puoi scoprire come utilizzare l'[SDK di incorporamento di Amazon Quick Sight (JavaScript) per incorporare](https://www.npmjs.com/package/amazon-quicksight-embedding-sdk) l'URL della dashboard dal passaggio 3 nella pagina del tuo sito Web o dell'applicazione. Con il kit SDK, puoi procedere come segue: 
+ Posiziona il pannello di controllo in una pagina HTML.
+ Passare i parametri nel pannello di controllo.
+ Gestisci stati di errore con messaggi personalizzati per l'applicazione.

Chiama l'operazione API `GetDashboardEmbedUrl` per ottenere l'URL da incorporare nell'applicazione. Questo URL è valido per 5 minuti, mentre la sessione risultante è valida per 10 ore. L'operazione API fornisce l'URL con un `auth_code` che consente una sessione di single sign-on. 

Di seguito viene mostrata una risposta di esempio da `get-dashboard-embed-url`.

```
//The URL returned is over 900 characters. For this example, we've shortened the string for
//readability and added ellipsis to indicate that it's incomplete.
{
     "Status": "200",
     "EmbedUrl": "https: //dashboards.example.com/embed/620bef10822743fab329fb3751187d2d...",
     "RequestId": "7bee030e-f191-45c4-97fe-d9faf0e03713"
}
```

Incorpora questa dashboard nella tua pagina Web utilizzando l'[SDK di incorporamento Amazon Quick Sight](https://www.npmjs.com/package/amazon-quicksight-embedding-sdk) o aggiungendo questo URL in un iframe. Se imposti un numero fisso di altezza e larghezza (in pixel), Amazon Quick Sight li utilizza e non modifica la visualizzazione durante il ridimensionamento della finestra. Se imposti un'altezza e una larghezza percentuali relative, Amazon Quick Sight fornisce un layout reattivo che viene modificato al variare delle dimensioni della finestra. Utilizzando Amazon Quick Sight Embedding SDK, puoi anche controllare i parametri all'interno della dashboard e ricevere callback in termini di completamento del caricamento della pagina ed errori. 

Il seguente esempio illustra come utilizzare l'URL generato. Questo codice viene generato sul server delle applicazioni.

```
<!DOCTYPE html>
<html>

<head>
    <title>Basic Embed</title>

    <script src="./quicksight-embedding-js-sdk.min.js"></script>
    <script type="text/javascript">
        var dashboard;

        function embedDashboard() {
            var containerDiv = document.getElementById("embeddingContainer");
            var options = {
                // replace this dummy url with the one generated via embedding API
                url: "https://us-east-1.quicksight.aws.amazon.com/sn/dashboards/dashboardId?isauthcode=true&identityprovider=quicksight&code=authcode",  
                container: containerDiv,
                scrolling: "no",
                height: "700px",
                width: "1000px",
                footerPaddingEnabled: true
            };
            dashboard = QuickSightEmbedding.embedDashboard(options);
        }
    </script>
</head>

<body onload="embedDashboard()">
    <div id="embeddingContainer"></div>
</body>

</html>
```

Affinché questo esempio funzioni, assicurati di utilizzare l'SDK Amazon Quick Sight Embedding per caricare la dashboard incorporata sul tuo sito Web utilizzando. JavaScript Per ottenere la tua copia, procedi in uno dei seguenti modi:
+ Scarica l'[SDK di incorporamento Amazon Quick Sight da.](https://github.com/awslabs/amazon-quicksight-embedding-sdk#step-3-create-the-quicksight-session-object) GitHub Questo repository è gestito da un gruppo di sviluppatori di Amazon Quick Sight.
+ Scarica l'ultima versione dell'SDK di incorporamento da. [https://www.npmjs.com/package/amazon-quicksight-embedding-sdk](https://www.npmjs.com/package/amazon-quicksight-embedding-sdk)
+ Se lo utilizzi `npm` per JavaScript le dipendenze, scaricalo e installalo eseguendo il comando seguente.

  ```
  npm install amazon-quicksight-embedding-sdk
  ```

# Incorporamento della console Amazon Quick Sight tramite GetSessionEmbedUrl (vecchia API)
<a name="embedded-analytics-full-console-for-authenticated-users-get"></a>

**Importante**  
Amazon Quick Sight ha delle novità APIs per l'integrazione dell'analisi: `GenerateEmbedUrlForAnonymousUser` e`GenerateEmbedUrlForRegisteredUser`.  
Puoi comunque utilizzare and `GetSessionEmbedUrl` APIs per incorporare dashboard `GetDashboardEmbedUrl` e la console Amazon Quick Sight, ma non contengono le funzionalità di incorporamento più recenti. Per l'esperienza di up-to-date incorporamento più recente, consulta [Incorporare l'analisi di Amazon Quick Sight nelle tue applicazioni](https://docs.aws.amazon.com/quicksight/latest/user/embedding-overview.html).


|  | 
| --- |
|  Si applica a: Enterprise Edition  | 


|  | 
| --- |
|    Destinatari: sviluppatori Amazon Quick  | 

Nelle sezioni seguenti, puoi trovare informazioni dettagliate su come fornire l'esperienza della console Amazon Quick Sight in un portale di authoring personalizzato per utenti registrati che utilizzano l'API. `GetSessionEmbedUrl` 

**Topics**
+ [

# Fase 1: Configurazione delle autorizzazioni
](embedded-analytics-full-console-for-authenticated-users-get-step-1.md)
+ [

# Fase 2: Ottenimento dell'URL con il codice di autenticazione allegato
](embedded-analytics-full-console-for-authenticated-users-get-step-2.md)
+ [

# Fase 3: Incorporamento dell'URL della sessione della console
](embedded-analytics-full-console-for-authenticated-users-get-step-3.md)

# Fase 1: Configurazione delle autorizzazioni
<a name="embedded-analytics-full-console-for-authenticated-users-get-step-1"></a>

**Importante**  
Amazon Quick Sight ha delle novità APIs per l'integrazione dell'analisi: `GenerateEmbedUrlForAnonymousUser` e`GenerateEmbedUrlForRegisteredUser`.  
Puoi comunque utilizzare and `GetSessionEmbedUrl` APIs per incorporare dashboard `GetDashboardEmbedUrl` e la console Amazon Quick Sight, ma non contengono le funzionalità di incorporamento più recenti. Per l'esperienza di up-to-date incorporamento più recente, consulta [Incorporare l'analisi di Amazon Quick Sight nelle tue applicazioni](https://docs.aws.amazon.com/quicksight/latest/user/embedding-overview.html).

Nella sezione seguente viene descritto come configurare le autorizzazioni per l'applicazione di back-end o il server Web. Questa operazione richiede l'accesso amministrativo a IAM.

Ogni utente che accede ad Amazon Quick Sight assume un ruolo che gli conferisce l'accesso e le autorizzazioni di Amazon Quick Sight alla sessione della console. Per rendere possibile tutto ciò, crea un ruolo IAM nel tuo account. AWS Associa una policy IAM al ruolo per fornire le autorizzazioni a qualsiasi utente che lo assume. Aggiungi `quicksight:RegisterUser` le autorizzazioni per garantire che il lettore possa accedere ad Amazon Quick Sight in modalità di sola lettura e non abbia accesso ad altri dati o funzionalità di creazione. Il ruolo IAM deve inoltre fornire le autorizzazioni per recuperare la sessione della console. URLs Per questo, aggiungi `quicksight:GetSessionEmbedUrl`.

La seguente policy di esempio fornisce le autorizzazioni da utilizzare con `IdentityType=IAM`. 

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

****  

```
{
  "Version":"2012-10-17",		 	 	 
  "Statement": [
    {
      "Action": "quicksight:RegisterUser",
      "Resource": "*",
      "Effect": "Allow"
    },
    {
      "Action": "quicksight:GetSessionEmbedUrl",
      "Resource": "*",
      "Effect": "Allow"
    }
  ]
}
```

------

La seguente policy di esempio fornisce l'autorizzazione per recuperare l'URL di una sessione della console. Se si stanno creando utenti prima che accedano a una sessione incorporata, la policy viene utilizzata senza `quicksight:RegisterUser`.

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

****  

```
{
    "Version":"2012-10-17",		 	 	 
    "Statement": [
        {
            "Effect": "Allow",
            "Action": [
                "quicksight:GetSessionEmbedUrl"
            ],
            "Resource": "*"
        }
    ]
}
```

------

Se utilizzi `QUICKSIGHT` come `identityType` e fornisci il nome della risorsa Amazon (ARN) dell'utente, dovrai consentire anche l'operazione `quicksight:GetAuthCode` nella policy. Tale autorizzazione è fornita dalla seguente policy di esempio.

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

****  

```
{
  "Version":"2012-10-17",		 	 	 
  "Statement": [
    {
      "Effect": "Allow",
      "Action": [
        "quicksight:GetSessionEmbedUrl",
        "quicksight:GetAuthCode"
      ],
      "Resource": "*"
    }
  ]
}
```

------

È necessario che all'identità IAM dell'applicazione sia associata una policy di attendibilità per consentire l'accesso al ruolo appena creato. Ciò significa che quando un utente accede alla tua applicazione, quest'ultima può assumere il ruolo per conto dell'utente ed eseguire il provisioning dell'utente in Amazon Quick Sight. L'esempio seguente mostra un ruolo chiamato `embedding_quicksight_console_session_role`, che è la policy di esempio elencata in precedenza come risorsa. 

Per ulteriori informazioni sulle policy di trust per OpenID Connect o l'autenticazione SAML, consulta le sezioni seguenti della *Guida per l'utente di IAM*:
+ [Creazione di un ruolo per la federazione di identità Web oppure OpenID Connect (console)](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_create_for-idp_oidc.html)
+ [Creazione di un ruolo per una federazione SAML 2.0 (console)](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_create_for-idp_saml.html)

# Fase 2: Ottenimento dell'URL con il codice di autenticazione allegato
<a name="embedded-analytics-full-console-for-authenticated-users-get-step-2"></a>

**Importante**  
Amazon Quick Sight ha delle novità APIs per l'integrazione dell'analisi: `GenerateEmbedUrlForAnonymousUser` e`GenerateEmbedUrlForRegisteredUser`.  
Puoi comunque utilizzare and `GetSessionEmbedUrl` APIs per incorporare dashboard `GetDashboardEmbedUrl` e la console Amazon Quick Sight, ma non contengono le funzionalità di incorporamento più recenti. Per l'esperienza di up-to-date incorporamento più recente, consulta [Incorporare l'analisi di Amazon Quick Sight nelle tue applicazioni](https://docs.aws.amazon.com/quicksight/latest/user/embedding-overview.html).

Nella sezione seguente, è possibile scoprire come autenticare l'utente e ottenere l'URL della sessione della console incorporabile nel server delle applicazioni. 

Quando un utente accede all'applicazione, l'applicazione assume il ruolo IAM per conto dell'utente. Quindi aggiunge l'utente ad Amazon Quick Sight, se quell'utente non esiste già. In seguito, sarà necessario passare un identificatore come l'ID della sessione del ruolo univoco. 

L'esecuzione dei passaggi descritti garantisce che ogni visualizzatore della sessione della console sia fornito in modo univoco in Amazon Quick Sight. Applica inoltre le impostazioni per utente, ad esempio la sicurezza a livello di riga e le impostazioni predefinite dinamiche per i parametri.

Gli esempi seguenti eseguono l'autenticazione IAM per conto dell'utente. Questo codice viene eseguito sul server delle applicazioni.

------
#### [ Java ]

```
import com.amazonaws.auth.AWSCredentials;
import com.amazonaws.auth.BasicAWSCredentials;
import com.amazonaws.auth.AWSCredentialsProvider;
import com.amazonaws.regions.Regions;
import com.amazonaws.services.quicksight.AmazonQuickSight;
import com.amazonaws.services.quicksight.AmazonQuickSightClientBuilder;
import com.amazonaws.services.quicksight.model.GetSessionEmbedUrlRequest;
import com.amazonaws.services.quicksight.model.GetSessionEmbedUrlResult;

/**
 * Class to call QuickSight AWS SDK to get url for session embedding.
 */
public class GetSessionEmbedUrlQSAuth {

    private final AmazonQuickSight quickSightClient;

    public GetSessionEmbedUrlQSAuth() {
        this.quickSightClient = AmazonQuickSightClientBuilder
                .standard()
                .withRegion(Regions.US_EAST_1.getName())
                .withCredentials(new AWSCredentialsProvider() {
                                     @Override
                                     public AWSCredentials getCredentials() {
                                         // provide actual IAM access key and secret key here
                                         return new BasicAWSCredentials("access-key", "secret-key");
                                     }

                                     @Override
                                     public void refresh() {}
                                 }
                )
                .build();
    }

    public String getQuicksightEmbedUrl(
            final String accountId, // YOUR AWS ACCOUNT ID
            final String userArn // REGISTERED USER ARN TO USE FOR EMBEDDING. REFER TO GETEMBEDURL SECTION IN DEV PORTAL TO FIND OUT HOW TO GET USER ARN FOR A QUICKSIGHT USER
    ) throws Exception {
        GetSessionEmbedUrlRequest getSessionEmbedUrlRequest = new GetSessionEmbedUrlRequest()
                .withAwsAccountId(accountId)
                .withEntryPoint("/start")
                .withUserArn(userArn);

        GetSessionEmbedUrlResult sessionEmbedUrl = quickSightClient.getSessionEmbedUrl(getSessionEmbedUrlRequest);

        return sessionEmbedUrl.getEmbedUrl();
    }
}
```

------
#### [ JavaScript ]

```
global.fetch = require('node-fetch');
const AWS = require('aws-sdk');

function getSessionEmbedURL(
    accountId, // YOUR AWS ACCOUNT ID
    userArn, // REGISTERED USER ARN TO USE FOR EMBEDDING. REFER TO GETEMBEDURL SECTION IN DEV PORTAL TO FIND OUT HOW TO GET USER ARN FOR A QUICKSIGHT USER
    getEmbedUrlCallback, // GETEMBEDURL SUCCESS CALLBACK METHOD
    errorCallback // GETEMBEDURL ERROR CALLBACK METHOD
    ) {
    const getSessionParams = {
        AwsAccountId: accountId,
        EntryPoint: "/start",
        UserArn: userArn,
        SessionLifetimeInMinutes: 600,
    };

    const quicksightGetSession = new AWS.QuickSight({
        region: process.env.AWS_REGION,
    });

    quicksightGetSession.getSessionEmbedUrl(getSessionParams, function(err, data) {
        if (err) {
            console.log(err, err.stack);
            errorCallback(err);
        } else {
            const result = {
                "statusCode": 200,
                "headers": {
                    "Access-Control-Allow-Origin": "*", // USE YOUR WEBSITE DOMAIN TO SECURE ACCESS TO GETEMBEDURL API
                    "Access-Control-Allow-Headers": "Content-Type"
                },
                "body": JSON.stringify(data),
                "isBase64Encoded": false
            }
            getEmbedUrlCallback(result);
        }
    });
}
```

------
#### [ Python3 ]

```
import json
import boto3
from botocore.exceptions import ClientError
import time

# Create QuickSight and STS clients
qs = boto3.client('quicksight',region_name='us-east-1')
sts = boto3.client('sts')

# Function to generate embedded URL
# accountId: YOUR AWS ACCOUNT ID
# userArn: REGISTERED USER ARN TO USE FOR EMBEDDING. REFER TO GETEMBEDURL SECTION IN DEV PORTAL TO FIND OUT HOW TO GET USER ARN FOR A QUICKSIGHT USER
def getSessionEmbedURL(accountId, userArn):
    try:
        response = qs.get_session_embed_url(
            AwsAccountId = accountId,
            EntryPoint = "/start",
            UserArn = userArn,
            SessionLifetimeInMinutes = 600
        )
            
        return {
            'statusCode': 200,
            'headers': {"Access-Control-Allow-Origin": "*", "Access-Control-Allow-Headers": "Content-Type"},
            'body': json.dumps(response),
            'isBase64Encoded':  bool('false')
        }
    except ClientError as e:
        print(e)
        return "Error generating embeddedURL: " + str(e)
```

------
#### [ Node.js ]

L'esempio seguente mostra il file JavaScript (Node.js) che puoi usare sull'app server per ottenere l'URL per la sessione della console incorporata. È possibile utilizzare questo URL nel sito web o nell'applicazione per visualizzare la sessione della console. 

**Example**  

```
const AWS = require('aws-sdk');
            const https = require('https');
            
            var quicksight = new AWS.Service({
                apiConfig: require('./quicksight-2018-04-01.min.json'),
                region: 'us-east-1',
            });
            
            quicksight.GetSessionEmbedUrl({
                'AwsAccountId': '111122223333',
                'EntryPoint': 'https://url-for-console-page-to-open',
                'SessionLifetimeInMinutes': 600,
                'UserArn': 'USER_ARN'
            
            }, function(err, data) {
                console.log('Errors: ');
                console.log(err);
                console.log('Response: ');
                console.log(data);
            });
```

**Example**  

```
//The URL returned is over 900 characters. For this example, we've shortened the string for
            //readability and added ellipsis to indicate that it's incomplete.
                                { Status: 200,
              EmbedUrl: 'https://dashboards.example.com/embed/620bef10822743fab329fb3751187d2d…
              RequestId: '7bee030e-f191-45c4-97fe-d9faf0e03713' }
```

------
#### [ .NET/C\$1 ]

L'esempio seguente mostra il codice .NET/C\$1 che è possibile utilizzare nel server delle applicazioni per ottenere l'URL per la sessione della console incorporata. È possibile utilizzare questo URL nel sito web o nell'applicazione per visualizzare la console. 

**Example**  

```
            var client = new AmazonQuickSightClient(
                AccessKey,
                SecretAccessKey,
                sessionToken,
                Amazon.RegionEndpoint.USEast1);
            try
            {
                Console.WriteLine(
                    client.GetSessionEmbedUrlAsync(new GetSessionEmbedUrlRequest
                    {
                'AwsAccountId': '111122223333',
                'EntryPoint': 'https://url-for-console-page-to-open',
                'SessionLifetimeInMinutes': 600,
                'UserArn': 'USER_ARN'
                        AwsAccountId = 111122223333,
                        EntryPoint = https://url-for-console-page-to-open,
                        SessionLifetimeInMinutes = 600,
                        UserArn = 'USER_ARN'
                    }).Result.EmbedUrl
                );
            } catch (Exception ex) {
                Console.WriteLine(ex.Message);
            }
```

------
#### [ AWS CLI ]

Per assumere il ruolo, scegliete una delle seguenti operazioni API AWS Security Token Service (AWS STS):
+ [AssumeRole](https://docs.aws.amazon.com/STS/latest/APIReference/API_AssumeRole.html)— Utilizzate questa operazione quando utilizzate un'identità IAM per assumere il ruolo.
+ [AssumeRoleWithWebIdentity](https://docs.aws.amazon.com/STS/latest/APIReference/API_AssumeRoleWithWebIdentity.html)— Utilizzate questa operazione quando utilizzate un provider di identità web per autenticare l'utente. 
+ [AssumeRoleWithSaml](https://docs.aws.amazon.com/STS/latest/APIReference/API_AssumeRoleWithSAML.html)— Utilizza questa operazione quando utilizzi SAML per autenticare i tuoi utenti.

L'esempio seguente mostra il comando dell'interfaccia a riga di comando per impostare il ruolo IAM. Il ruolo deve avere le autorizzazioni abilitate per `quicksight:GetSessionEmbedUrl`. Se stai adottando un just-in-time approccio per aggiungere utenti quando aprono Amazon Quick Sight per la prima volta, per `quicksight:RegisterUser` il ruolo è necessario abilitare anche le autorizzazioni.

```
aws sts assume-role \
     --role-arn "arn:aws:iam::111122223333:role/embedding_quicksight_dashboard_role" \
     --role-session-name john.doe@example.com
```

L'operazione `assume-role` restituisce tre parametri di output: la chiave di accesso, la chiave segreta e il token della sessione. 

**Nota**  
Se si verifica un errore `ExpiredToken` durante la chiamata all'operazione `AssumeRole`, vuol dire che il `SESSION TOKEN` precedente è ancora presente nelle variabili di ambiente. Cancellala impostando le seguenti variabili:  
*AWS\$1ACCESS\$1ID\$1CHIAVE* 
*AWS\$1SECRET\$1CHIAVE\$1ACCESSO* 
*AWS\$1SESSION\$1GETTONE* 

L'esempio seguente mostra come impostare questi tre parametri nell'interfaccia a riga di comando. Se usi un computer Microsoft Windows, utilizza `set` invece di `export`.

```
export AWS_ACCESS_KEY_ID     = "access_key_from_assume_role"
export AWS_SECRET_ACCESS_KEY = "secret_key_from_assume_role"
export AWS_SESSION_TOKEN     = "session_token_from_assume_role"
```

L'esecuzione di questi comandi imposta l'ID della sessione del ruolo dell'utente che visita la pagina del tuo sito web su`embedding_quicksight_console_session_role/john.doe@example.com`. L'ID della sessione del ruolo è costituito dal nome del ruolo di `role-arn` e dal valore `role-session-name`. L'utilizzo dell'ID della sessione del ruolo univoco per ciascun utente garantisce che le autorizzazioni appropriate siano impostate per ogni utente. Impedisce inoltre il throttling dell'accesso degli utenti. La limitazione è una funzionalità di sicurezza che impedisce allo stesso utente di accedere ad Amazon Quick Sight da più postazioni. 

L'ID della sessione del ruolo diventa anche il nome utente in Amazon Quick Sight. Puoi utilizzare questo modello per effettuare il provisioning dei tuoi utenti in Amazon Quick Sight in anticipo o per effettuare il provisioning la prima volta che accedono a una sessione della console. 

L'esempio seguente mostra il comando dell'interfaccia a riga di comando che è possibile utilizzare per effettuare il provisioning di un utente. Per ulteriori informazioni [RegisterUser](https://docs.aws.amazon.com/quicksight/latest/APIReference/API_RegisterUser.html)e altre operazioni relative all'API Amazon Quick Sight, consulta il [riferimento all'API Amazon Quick Sight](https://docs.aws.amazon.com/quicksight/latest/APIReference/Welcome.html). [DescribeUser](https://docs.aws.amazon.com/quicksight/latest/APIReference/API_DescribeUser.html)

```
aws quicksight register-user \
     --aws-account-id 111122223333 \
     --namespace default \
     --identity-type IAM \
     --iam-arn "arn:aws:iam::111122223333:role/embedding_quicksight_dashboard_role" \
     --user-role READER \
     --user-name jhnd \
     --session-name "john.doe@example.com" \
     --email john.doe@example.com \
     --region us-east-1 \
     --custom-permissions-name TeamA1
```

Se l'utente viene autenticato tramite Microsoft AD, non è necessario utilizzare `RegisterUser` per configurarlo. Dovrebbero invece essere abbonati automaticamente la prima volta che accedono ad Amazon Quick Sight. Per gli utenti Microsoft AD, puoi utilizzare `DescribeUser` per ottenere l'ARN dell'utente.

La prima volta che un utente accede ad Amazon Quick Sight, puoi anche aggiungerlo al gruppo appropriato. L'esempio seguente mostra il comando dell'interfaccia a riga di comando per aggiungere un utente a un gruppo.

```
aws quicksight create-group-membership \
     --aws-account-id=111122223333 \
     --namespace=default \
     --group-name=financeusers \
     --member-name="embedding_quicksight_dashboard_role/john.doe@example.com"
```

Ora hai un utente della tua app che è anche un utente di Amazon Quick Sight e che ha accesso alla sessione della console Amazon Quick Sight. 

Infine, per ottenere un URL firmato per la sessione della console, chiama `get-session-embed-url` dal server delle applicazioni. Ciò restituisce l'URL della sessione della console incorporabile. L'esempio seguente mostra come ottenere l'URL per una sessione di console incorporata utilizzando una chiamata lato server per utenti autenticati tramite AWS Managed Microsoft AD o Single Sign-on (IAM Identity Center).

```
aws quicksight get-dashboard-embed-url \
     --aws-account-id 111122223333 \
     --entry-point the-url-for--the-console-session \
     --session-lifetime-in-minutes 600 \
     --user-arn arn:aws:quicksight:us-east-1:111122223333:user/default/embedding_quicksight_dashboard_role/embeddingsession
```

Per ulteriori informazioni sull'utilizzo di questa operazione, consulta [https://docs.aws.amazon.com/quicksight/latest/APIReference/API_GetSessionEmbedUrl.html](https://docs.aws.amazon.com/quicksight/latest/APIReference/API_GetSessionEmbedUrl.html). Puoi utilizzare questa API e altre operazioni nel tuo codice. 

------

# Fase 3: Incorporamento dell'URL della sessione della console
<a name="embedded-analytics-full-console-for-authenticated-users-get-step-3"></a>

**Importante**  
Amazon Quick Sight ha delle novità APIs per l'integrazione dell'analisi: `GenerateEmbedUrlForAnonymousUser` e`GenerateEmbedUrlForRegisteredUser`.  
Puoi comunque utilizzare and `GetSessionEmbedUrl` APIs per incorporare dashboard `GetDashboardEmbedUrl` e la console Amazon Quick Sight, ma non contengono le funzionalità di incorporamento più recenti. Per l'esperienza di up-to-date incorporamento più recente, consulta [Incorporare l'analisi di Amazon Quick Sight nelle tue applicazioni](https://docs.aws.amazon.com/quicksight/latest/user/embedding-overview.html).

Nella sezione seguente, puoi scoprire come utilizzare l'[SDK di incorporamento di Amazon Quick Sight (JavaScript) per incorporare](https://www.npmjs.com/package/amazon-quicksight-embedding-sdk) l'URL della sessione della console dal passaggio 3 nella pagina del tuo sito Web o dell'applicazione. Con il kit SDK, puoi procedere come segue: 
+ Posiziona la sessione della console su una pagina HTML.
+ Invia i parametri nella sessione della console.
+ Gestisci stati di errore con messaggi personalizzati per l'applicazione.

Chiama l'operazione API `GetSessionEmbedUrl` per ottenere l'URL da incorporare nell'applicazione. Questo URL è valido per 5 minuti, mentre la sessione risultante è valida per 10 ore. L'operazione API fornisce l'URL con un `auth_code` che consente una sessione di single sign-on. 

Di seguito viene mostrata una risposta di esempio da `get-dashboard-embed-url`.

```
//The URL returned is over 900 characters. For this example, we've shortened the string for
//readability and added ellipsis to indicate that it's incomplete.
{
     "Status": "200",
     "EmbedUrl": "https: //dashboards.example.com/embed/620bef10822743fab329fb3751187d2d...",
     "RequestId": "7bee030e-f191-45c4-97fe-d9faf0e03713"
}
```

Incorpora questa sessione della console nella tua pagina Web utilizzando l'[SDK Amazon Quick Sight Embedding](https://www.npmjs.com/package/amazon-quicksight-embedding-sdk) o aggiungendo questo URL in un iframe. Se imposti un numero fisso di altezza e larghezza (in pixel), Amazon Quick Sight li utilizza e non modifica la visualizzazione durante il ridimensionamento della finestra. Se imposti un'altezza e una larghezza percentuali relative, Amazon Quick Sight fornisce un layout reattivo che viene modificato al variare delle dimensioni della finestra. Utilizzando Amazon Quick Sight Embedding SDK, puoi anche controllare i parametri all'interno della sessione della console e ricevere callback in termini di completamento del caricamento della pagina ed errori. 

Il seguente esempio illustra come utilizzare l'URL generato. Questo codice viene generato sul server delle applicazioni.

```
<!DOCTYPE html>
<html>

<head>
    <title>Basic Embed</title>

    <script src="./quicksight-embedding-js-sdk.min.js"></script>
    <script type="text/javascript">
        var dashboard;

        function embedDashboard() {
            var containerDiv = document.getElementById("embeddingContainer");
            var options = {
                // replace this dummy url with the one generated via embedding API
                url: "https://us-east-1.quicksight.aws.amazon.com/sn/dashboards/dashboardId?isauthcode=true&identityprovider=quicksight&code=authcode",  
                container: containerDiv,
                scrolling: "no",
                height: "700px",
                width: "1000px",
                footerPaddingEnabled: true
            };
            dashboard = QuickSightEmbedding.embedDashboard(options);
        }
    </script>
</head>

<body onload="embedDashboard()">
    <div id="embeddingContainer"></div>
</body>

</html>
```

Affinché questo esempio funzioni, assicurati di utilizzare Amazon Quick Sight Embedding SDK per caricare la sessione della console incorporata sul tuo sito Web utilizzando. JavaScript Per ottenere la tua copia, procedi in uno dei seguenti modi:
+ Scarica l'[SDK di incorporamento Amazon Quick Sight da.](https://github.com/awslabs/amazon-quicksight-embedding-sdk#step-3-create-the-quicksight-session-object) GitHub Questo repository è gestito da un gruppo di sviluppatori di Amazon Quick Sight.
+ Scarica l'ultima versione dell'SDK di incorporamento da. [https://www.npmjs.com/package/amazon-quicksight-embedding-sdk](https://www.npmjs.com/package/amazon-quicksight-embedding-sdk)
+ Se lo utilizzi `npm` per JavaScript le dipendenze, scaricalo e installalo eseguendo il comando seguente.

  ```
  npm install amazon-quicksight-embedding-sdk
  ```