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

# Integrazione con Amazon Quick Sight APIs
<a name="embedded-analytics-api"></a>


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


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

L'effettivo processo di integrazione delle analisi con Amazon Quick Sight APIs prevede solo pochi passaggi. 

Prima di iniziare, assicurati di disporre dei seguenti elementi:
+ Configura le autorizzazioni IAM richieste per l'identità del chiamante utilizzata dalla tua applicazione che utilizzerà l' AWS SDK per effettuare chiamate API. Ad esempio, concedi l'autorizzazione per consentire l'operazione `quicksight:GenerateEmbedUrlForAnonymousUser` o `quicksight:GenerateEmbedUrlForRegisteredUser`.
+ Per l'incorporamento per gli utenti registrati, condividi prima le risorse Amazon Quick Sight con loro. Per i nuovi utenti che effettuano l'autenticazione, scopri come concedere l'accesso alle risorse. Un modo per farlo è aggiungere tutte le risorse a una cartella Amazon Quick Sight. Se preferisci utilizzare l'API Amazon Quick Sight, utilizza le operazioni `DescribeDashboardPermissions` e `UpdateDashboardPermissions` API. Per ulteriori informazioni, consulta [DescribeDashboardPermissions](https://docs.aws.amazon.com/quicksight/latest/APIReference/API_DescribeDashboardPermissions.html)o [UpdateDashboardPermissions](https://docs.aws.amazon.com/quicksight/latest/APIReference/API_UpdateDashboardPermissions.html)consulta *Amazon Quick API Reference*. Se desideri condividere il pannello di controllo con tutti gli utenti in uno spazio dei nomi o in un gruppo, puoi condividere il pannello di controllo con `namespace` o `group`.
+ Se stai incorporando i pannelli di controllo, assicurati di disporre dell'ID dei pannelli di controllo desiderati. L'ID del pannello di controllo è il codice nell'URL del pannello. Puoi ottenerlo anche dall'URL del pannello di controllo.
+ Un amministratore di Amazon Quick Sight deve abilitare esplicitamente i domini in cui intendi incorporare le analisi di Amazon Quick Sight. Puoi farlo utilizzando **Manage Amazon Quick Sight**, **Domains and Embedding** dal menu del profilo oppure puoi utilizzare il `AllowedDomains` parametro di una chiamata `GenerateEmbedUrlForAnonymousUser` o `GenerateEmbedUrlForRegisteredUser` API.

  Questa opzione è visibile solo agli amministratori di Amazon Quick Sight. Puoi anche aggiungere sottodomini come parte di un dominio. Per ulteriori informazioni, consulta [Consenti la pubblicazione di domini in fase di esecuzione con l'API Amazon Quick](manage-domains.md#embedding-run-time).

  Tutti i domini nell'elenco di consentiti statico in uso (ad esempio sviluppo, gestione temporanea e produzione) devono essere consentiti esplicitamente e devono utilizzare il protocollo HTTPS. È possibile aggiungere fino a 100 domini all'elenco dei consentiti. Puoi aggiungere domini in fase di esecuzione con le operazioni dell'API Amazon Quick Sight.

Una volta completati tutti i prerequisiti, l'incorporamento di Amazon Quick Sight prevede i seguenti passaggi, che verranno spiegati più dettagliatamente in seguito: 

1. Per l'autenticazione, utilizza il server delle applicazioni per autenticare l'utente. Dopo l'autenticazione nel server, genera l'URL della dashboard incorporata utilizzando l' AWS SDK di cui hai bisogno.

1. Nel tuo portale web o nella tua applicazione, incorpora Amazon Quick Sight utilizzando l'URL generato. Per semplificare questo processo, puoi utilizzare l'SDK Amazon Quick Sight Embedding, disponibile su [NPMJS](https://www.npmjs.com/package/amazon-quicksight-embedding-sdk) e. [GitHub](https://github.com/awslabs/amazon-quicksight-embedding-sdk) Questo JavaScript SDK personalizzato è progettato per aiutarti a integrare in modo efficiente Amazon Quick Sight nelle pagine delle tue applicazioni, impostare impostazioni predefinite, connettere i controlli, ricevere callback e gestire gli errori. 

Puoi utilizzare i log AWS CloudTrail di controllo per ottenere informazioni sul numero di dashboard integrate, sugli utenti di un'esperienza integrata e sulle percentuali di accesso.

**Topics**
+ [

# Incorporamento di dashboard Amazon Quick Sight con l'API Amazon Quick Sight
](embedding-dashboards.md)
+ [

# Integrazione di elementi visivi di Amazon Quick Sight con Amazon Quick Sight APIs
](embedding-visuals.md)
+ [

# Incorpora tutte le funzionalità della console Amazon Quick Sight per utenti registrati
](embedded-analytics-full-console-for-authenticated-users.md)
+ [

# Integrazione di Amazon Q nell'esperienza di domande e risposte generative di Amazon Quick Sight
](embedding-gen-bi.md)
+ [

# Incorporamento della barra di ricerca Amazon Quick Sight Q (Classic)
](embedding-quicksight-q.md)
+ [

# Incorporamento dell'analisi utilizzando le operazioni API GetDashboardEmbedURL e GetSessionEmbedURL
](embedded-analytics-deprecated.md)

# Incorporamento di dashboard Amazon Quick Sight con l'API Amazon Quick Sight
<a name="embedding-dashboards"></a>

Utilizza i seguenti argomenti per scoprire come incorporare dashboard con l'API Amazon Quick Sight.

**Topics**
+ [

# Incorporazione di dashboard Amazon Quick Sight per utenti registrati
](embedded-analytics-dashboards-for-authenticated-users.md)
+ [

# Integrazione di dashboard Amazon Quick Sight per utenti anonimi (non registrati)
](embedded-analytics-dashboards-for-everyone.md)
+ [

# Abilitazione dei riepiloghi esecutivi nei pannelli di controllo integrati
](embedded-analytics-genbi-executive-summaries-dashboard.md)

# Incorporazione di dashboard Amazon Quick Sight per utenti registrati
<a name="embedded-analytics-dashboards-for-authenticated-users"></a>

**Importante**  
Amazon Quick Sight dispone di nuove operazioni API per l'integrazione di analisi: `GenerateEmbedUrlForAnonymousUser` e`GenerateEmbedUrlForRegisteredUser`.  
Puoi comunque utilizzare le operazioni `GetDashboardEmbedUrl` e `GetSessionEmbedUrl` API per incorporare dashboard e la console Amazon Quick Sight, ma non contengono le funzionalità di incorporamento più recenti. Per ulteriori informazioni sull'incorporamento utilizzando le vecchie operazioni API, consulta [Incorporare analisi utilizzando](https://docs.aws.amazon.com/quicksight/latest/user/embedded-analytics-deprecated.html) e operazioni API. GetDashboardEmbedURL GetSessionEmbedURL


|  | 
| --- |
|  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 gli utenti registrati di Amazon Quick Sight.

**Topics**
+ [

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

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

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

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

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 l'incorporamento URLs per un pool di utenti specifico. Con l'aiuto del carattere jolly *\$1*, puoi concedere le autorizzazioni per generare un URL per tutti gli utenti in uno spazio dei nomi specifico o per un sottoinsieme di utenti in spazi dei nomi specifici. Per questo, aggiungi `quicksight:GenerateEmbedUrlForRegisteredUser`.

Puoi creare una condizione nella tua policy IAM che limiti i domini che gli sviluppatori possono elencare nel parametro `AllowedDomains` di un'operazione API `GenerateEmbedUrlForRegisteredUser`. Il parametro `AllowedDomains` è un parametro facoltativo. In qualità di sviluppatore, ti offre la possibilità di sovrascrivere i domini statici configurati nel menu Manage **Amazon Quick** Sight. Puoi invece elencare fino a tre domini o sottodomini che possono accedere all'URL generato. Questo URL viene quindi incorporato nel sito web che crei. Solo i domini elencati nel parametro possono accedere all'elemento visivo incorporato. Senza questa condizione, nel parametro `AllowedDomains` puoi elencare qualsiasi dominio su Internet. 

Per limitare i domini che gli sviluppatori possono utilizzare con questo parametro, aggiungi una condizione `AllowedEmbeddingDomains` alla tua policy IAM. Per ulteriori informazioni sul `AllowedDomains` parametro, consulta [GenerateEmbedUrlForRegisteredUser](https://docs.aws.amazon.com//quicksight/latest/APIReference/API_GenerateEmbedUrlForRegisteredUser.html)*Amazon Quick Sight API Reference*.

**Best practice di sicurezza per gli operatori di condizioni IAM**  
Gli operatori di condizioni IAM configurati in modo errato possono consentire l'accesso non autorizzato alle risorse Quick incorporate tramite variazioni di URL. Quando utilizzi la chiave `quicksight:AllowedEmbeddingDomains` condition nelle tue policy IAM, utilizza operatori di condizione che consentano domini specifici o neghino tutti i domini che non sono specificamente consentiti. Per ulteriori informazioni sugli operatori di condizioni IAM, consulta [IAM JSON Policy elements: Condition operators](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_elements_condition_operators.html) nella IAM User Guide.  
Molte varianti di URL diverse possono puntare alla stessa risorsa. Ad esempio, i seguenti elementi si risolvono URLs tutti allo stesso contenuto:  
`https://example.com`
`https://example.com/`
`https://Example.com`
Se la tua politica utilizza operatori che non tengono conto di queste variazioni di URL, un utente malintenzionato può aggirare le tue restrizioni fornendo varianti URL equivalenti.  
Devi verificare che la tua policy IAM utilizzi operatori di condizioni appropriati per evitare di aggirare le vulnerabilità e garantire che solo i domini previsti possano accedere alle tue risorse incorporate.

Queste autorizzazioni sono fornite dalla seguente policy di esempio.

Inoltre, se stai creando utenti alle prime armi che saranno lettori di Amazon Quick Sight, assicurati di aggiungere l'`quicksight:RegisterUser`autorizzazione nella policy.

La seguente politica di esempio fornisce l'autorizzazione a recuperare un URL di incorporamento per gli utenti alle prime armi che devono essere lettori di Amazon Quick Sight.

Infine, è 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. Di seguito è mostrata una policy di attendibilità di esempio. 

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

****  

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

------

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 o 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: Generazione dell'URL con il codice di autenticazione allegato
<a name="embedded-dashboards-for-authenticated-users-step-2"></a>

Nella sezione seguente, è possibile scoprire come autenticare l'utente e ottenere l'URL del pannello di controllo incorporato nel server delle applicazioni. Se prevedi di incorporare dashboard per tipi di identità IAM o Amazon Quick Sight, condividi la dashboard con gli utenti.

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 di questi passaggi 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
<a name="embedded-dashboards-for-authenticated-users-java"></a>

```
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.GenerateEmbedUrlForRegisteredUserRequest;
    import com.amazonaws.services.quicksight.model.GenerateEmbedUrlForRegisteredUserResult;
    import com.amazonaws.services.quicksight.model.RegisteredUserEmbeddingExperienceConfiguration;
    import com.amazonaws.services.quicksight.model.RegisteredUserDashboardEmbeddingConfiguration;

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

        private final AmazonQuickSight quickSightClient;

        public GetQuicksightEmbedUrlRegisteredUserDashboardEmbedding() {
            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, // AWS Account ID
                final String dashboardId, // Dashboard ID to embed
                final List<String> allowedDomains, // Runtime allowed domain for embedding
                final String userArn // Registered user arn to use for embedding. Refer to Get Embed Url section in developer portal to find out how to get user arn for a QuickSight user.
        ) throws Exception {
            final RegisteredUserEmbeddingExperienceConfiguration experienceConfiguration = new RegisteredUserEmbeddingExperienceConfiguration()
                    .withDashboard(new RegisteredUserDashboardEmbeddingConfiguration().withInitialDashboardId(dashboardId));
            final GenerateEmbedUrlForRegisteredUserRequest generateEmbedUrlForRegisteredUserRequest = new GenerateEmbedUrlForRegisteredUserRequest();
            generateEmbedUrlForRegisteredUserRequest.setAwsAccountId(accountId);
            generateEmbedUrlForRegisteredUserRequest.setUserArn(userArn);
            generateEmbedUrlForRegisteredUserRequest.setAllowedDomains(allowedDomains);
            generateEmbedUrlForRegisteredUserRequest.setExperienceConfiguration(experienceConfiguration);

            final GenerateEmbedUrlForRegisteredUserResult generateEmbedUrlForRegisteredUserResult = quickSightClient.generateEmbedUrlForRegisteredUser(generateEmbedUrlForRegisteredUserRequest);

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

### JavaScript
<a name="embedded-dashboards-for-authenticated-users-js"></a>

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

    function generateEmbedUrlForRegisteredUser(
        accountId,
        dashboardId,
        openIdToken, // Cognito-based token
        userArn, // registered user arn
        roleArn, // IAM user role to use for embedding
        sessionName, // Session name for the roleArn assume role
        allowedDomains, // Runtime allowed domain for embedding
        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,
                    "ExperienceConfiguration": {
                        "Dashboard": {
                            "InitialDashboardId": dashboardId
                        }
                    },
                    "UserArn": userArn,
                    "AllowedDomains": allowedDomains,
                    "SessionLifetimeInMinutes": 600
                };

                const quicksightClient = 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
                    }
                });

                quicksightClient.generateEmbedUrlForRegisteredUser(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
<a name="embedded-dashboards-for-authenticated-users-py"></a>

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

sts = boto3.client('sts')

# Function to generate embedded URL  
# accountId: AWS account ID
# dashboardId: Dashboard ID to embed
# userArn: arn of registered user
# allowedDomains: Runtime allowed domain for embedding
# roleArn: IAM user role to use for embedding
# sessionName: session name for the roleArn assume role
def getEmbeddingURL(accountId, dashboardId, userArn, allowedDomains, roleArn, sessionName):
    try:
        assumedRole = sts.assume_role(
            RoleArn = roleArn,
            RoleSessionName = sessionName,
        )
    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:
            quicksightClient = assumedRoleSession.client('quicksight', region_name='us-west-2')
            response = quicksightClient.generate_embed_url_for_registered_user(
                AwsAccountId=accountId,
                ExperienceConfiguration = {
                    "Dashboard": {
                        "InitialDashboardId": dashboardId
                    }
                },
                UserArn = userArn,
                AllowedDomains = allowedDomains,
                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:
            return "Error generating embedding url: " + str(e)
```

### Node.js
<a name="embedded-dashboards-for-authenticated-users-node"></a>

L'esempio seguente mostra JavaScript (Node.js) che puoi usare sul server dell'app per generare l'URL per la 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 quicksightClient = new AWS.Service({
        apiConfig: require('./quicksight-2018-04-01.min.json'),
        region: 'us-east-1',
    });

    quicksightClient.generateEmbedUrlForRegisteredUser({
        'AwsAccountId': '111122223333',
        'ExperienceConfiguration': { 
            'Dashboard': {
                'InitialDashboardId': '1c1fe111-e2d2-3b30-44ef-a0e111111cde'
            }
        },
        'UserArn': 'REGISTERED_USER_ARN',
        'AllowedDomains': allowedDomains,
        'SessionLifetimeInMinutes': 100
    }, 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://quicksightdomain/embed/12345/dashboards/67890...'
            RequestId: '7bee030e-f191-45c4-97fe-d9faf0e03713' 
        }
```

### .NET/C\$1
<a name="embedded-dashboards-for-authenticated-users-cs"></a>

L'esempio seguente mostra il codice .NET/C\$1 che è possibile utilizzare nel server delle applicazioni 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**  

```
using System;
    using Amazon.QuickSight;
    using Amazon.QuickSight.Model;

    namespace GenerateDashboardEmbedUrlForRegisteredUser
    {
        class Program
        {
            static void Main(string[] args)
            {
                var quicksightClient = new AmazonQuickSightClient(
                    AccessKey,
                    SecretAccessKey,
                    SessionToken,
                    Amazon.RegionEndpoint.USEast1);
                try
                {
                    RegisteredUserDashboardEmbeddingConfiguration registeredUserDashboardEmbeddingConfiguration
                        = new RegisteredUserDashboardEmbeddingConfiguration
                        {
                            InitialDashboardId = "dashboardId"
                        };
                    RegisteredUserEmbeddingExperienceConfiguration registeredUserEmbeddingExperienceConfiguration
                        = new RegisteredUserEmbeddingExperienceConfiguration
                        {
                            Dashboard = registeredUserDashboardEmbeddingConfiguration
                        };
                        
                    Console.WriteLine(
                        quicksightClient.GenerateEmbedUrlForRegisteredUserAsync(new GenerateEmbedUrlForRegisteredUserRequest
                        {
                            AwsAccountId = "111122223333",
                            ExperienceConfiguration = registeredUserEmbeddingExperienceConfiguration,
                            UserArn = "REGISTERED_USER_ARN",
                            AllowedDomains = allowedDomains,
                            SessionLifetimeInMinutes = 100
                        }).Result.EmbedUrl
                    );
                } catch (Exception ex) {
                    Console.WriteLine(ex.Message);
                }
            }
        }
    }
```

### AWS CLI
<a name="embedded-dashboards-for-authenticated-users-cli"></a>

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)— Utilizza questa operazione quando utilizzi un provider di identità web per autenticare il tuo 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:GenerateEmbedUrlForRegisteredUser`. 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 relative all'API Amazon Quick Sight, consulta l'[Amazon Quick Sight API Reference](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 `generate-embed-url-for-registered-user` dal server delle applicazioni. Questo restituisce l'URL del pannello di controllo incorporato. L'esempio seguente mostra come generare l'URL per una dashboard incorporata utilizzando una chiamata lato server per utenti autenticati tramite AWS Managed Microsoft AD o Single Sign-On (IAM Identity Center).

```
aws quicksight generate-embed-url-for-registered-user \
        --aws-account-id 111122223333 \
        --session-lifetime-in-minutes 600 \
        --user-arn arn:aws:quicksight:us-east-1:111122223333:user/default/embedding_quicksight_visual_role/embeddingsession \
        --allowed-domains '["domain1","domain2"]' \
        --experience-configuration Dashboard={InitialDashboardId=1a1ac2b2-3fc3-4b44-5e5d-c6db6778df89}
```

Per ulteriori informazioni sull'utilizzo di questa operazione, consulta [https://docs.aws.amazon.com/quicksight/latest/APIReference/API_GenerateEmbedUrlForRegisteredUser.html](https://docs.aws.amazon.com/quicksight/latest/APIReference/API_GenerateEmbedUrlForRegisteredUser.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-step-3"></a>

Nella sezione seguente, puoi scoprire come utilizzare [Amazon Quick Sight Embedding SDK (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 `GenerateEmbedUrlForRegisteredUser` per generare l'URL da incorporare nella tua app. 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 `generate-embed-url-for-registered-user`.

```
//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://quicksightdomain/embed/12345/dashboards/67890..",
        "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 dominio che ospiterà i pannelli di controllo integrati deve essere presente nell'*allowlist*, l'elenco dei domini approvati per la tua sottoscrizione Quick . Questo requisito protegge i tuoi dati impedendo ai domini non approvati di ospitare pannelli di controllo incorporati. Per ulteriori informazioni sull'aggiunta di domini per le dashboard integrate, consulta [Consentire la pubblicazione di domini in fase di esecuzione con l'API Amazon Quick](https://docs.aws.amazon.com/quicksight/latest/user/embedding-run-time.html) Sight.

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

### SDK 2.0
<a name="embedded-dashboards-for-authenticated-users-sdkv2"></a>

```
<!DOCTYPE html>
<html>

    <head>
        <title>Dashboard Embedding Example</title>
        <script src="https://unpkg.com/amazon-quicksight-embedding-sdk@2.0.0/dist/quicksight-embedding-js-sdk.min.js"></script>
        <script type="text/javascript">
            const embedDashboard = async() => {
                const {
                    createEmbeddingContext,
                } = QuickSightEmbedding;

                const embeddingContext = await createEmbeddingContext({
                    onChange: (changeEvent, metadata) => {
                        console.log('Context received a change', changeEvent, metadata);
                    },
                });

                const frameOptions = {
                    url: '<YOUR_EMBED_URL>',
                    container: '#experience-container',
                    height: "700px",
                    width: "1000px",
                    onChange: (changeEvent, metadata) => {
                        switch (changeEvent.eventName) {
                            case 'FRAME_MOUNTED': {
                                console.log("Do something when the experience frame is mounted.");
                                break;
                            }
                            case 'FRAME_LOADED': {
                                console.log("Do something when the experience frame is loaded.");
                                break;
                            }
                        }
                    },
                };

                const contentOptions = {
                    parameters: [
                        {
                            Name: 'country',
                            Values: [
                                'United States'
                            ],
                        },
                        {
                            Name: 'states',
                            Values: [
                                'California',
                                'Washington'
                            ]
                        }
                    ],
                    locale: "en-US",
                    sheetOptions: {
                        initialSheetId: '<YOUR_SHEETID>',
                        singleSheet: false,                        
                        emitSizeChangedEventOnSheetChange: false,
                    },
                    toolbarOptions: {
                        export: false,
                        undoRedo: false,
                        reset: false
                    },
                    attributionOptions: {
                        overlayContent: false,
                    },
                    onMessage: async (messageEvent, experienceMetadata) => {
                        switch (messageEvent.eventName) {
                            case 'CONTENT_LOADED': {
                                console.log("All visuals are loaded. The title of the document:", messageEvent.message.title);
                                break;
                            }
                            case 'ERROR_OCCURRED': {
                                console.log("Error occurred while rendering the experience. Error code:", messageEvent.message.errorCode);
                                break;
                            }
                            case 'PARAMETERS_CHANGED': {
                                console.log("Parameters changed. Changed parameters:", messageEvent.message.changedParameters);
                                break;
                            }
                            case 'SELECTED_SHEET_CHANGED': {
                                console.log("Selected sheet changed. Selected sheet:", messageEvent.message.selectedSheet);
                                break;
                            }
                            case 'SIZE_CHANGED': {
                                console.log("Size changed. New dimensions:", messageEvent.message);
                                break;
                            }
                            case 'MODAL_OPENED': {
                                window.scrollTo({
                                    top: 0 // iframe top position
                                });
                                break;
                            }
                        }
                    },
                };
                const embeddedDashboardExperience = await embeddingContext.embedDashboard(frameOptions, contentOptions);

                const selectCountryElement = document.getElementById('country');
                selectCountryElement.addEventListener('change', (event) => {
                    embeddedDashboardExperience.setParameters([
                        {
                            Name: 'country',
                            Values: event.target.value
                        }
                    ]);
                });
            };
        </script>
    </head>

    <body onload="embedDashboard()">
        <span>
            <label for="country">Country</label>
            <select id="country" name="country">
                <option value="United States">United States</option>
                <option value="Mexico">Mexico</option>
                <option value="Canada">Canada</option>
            </select>
        </span>
        <div id="experience-container"></div>
    </body>

</html>
```

### SDK 1.0
<a name="embedded-dashboards-for-authenticated-users-sdkv1"></a>

```
<!DOCTYPE html>
<html>

    <head>
        <title>Basic Embed</title>
        <script src="https://unpkg.com/amazon-quicksight-embedding-sdk@1.0.15/dist/quicksight-embedding-js-sdk.min.js"></script>
        <script type="text/javascript">
            var dashboard
            function onDashboardLoad(payload) {
                console.log("Do something when the dashboard is fully loaded.");
            }

            function onError(payload) {
                console.log("Do something when the dashboard fails loading");
            }

            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,
                    parameters: {
                        country: "United States"
                    },
                    scrolling: "no",
                    height: "700px",
                    width: "1000px",
                    locale: "en-US",
                    footerPaddingEnabled: true
                };
                dashboard = QuickSightEmbedding.embedDashboard(options);
                dashboard.on("error", onError);
                dashboard.on("load", onDashboardLoad);
            }

            function onCountryChange(obj) {
                dashboard.setParameters({country: obj.value});
            }
        </script>
    </head>

    <body onload="embedDashboard()">
        <span>
            <label for="country">Country</label>
            <select id="country" name="country" onchange="onCountryChange(this)">
                <option value="United States">United States</option>
                <option value="Mexico">Mexico</option>
                <option value="Canada">Canada</option>
            </select>
        </span>
        <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'[Amazon Quick Sight Embedding SDK](https://github.com/awslabs/amazon-quicksight-embedding-sdk#step-3-create-the-quicksight-session-object) da. 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
  ```

# Integrazione di dashboard Amazon Quick Sight per utenti anonimi (non registrati)
<a name="embedded-analytics-dashboards-for-everyone"></a>

**Importante**  
Amazon Quick Sight dispone di nuove operazioni API per incorporare analisi: `GenerateEmbedUrlForAnonymousUser` e`GenerateEmbedUrlForRegisteredUser`.  
Puoi comunque utilizzare le operazioni `GetDashboardEmbedUrl` e `GetSessionEmbedUrl` API per incorporare dashboard e la console Amazon Quick Sight, ma non contengono le funzionalità di incorporamento più recenti. Per ulteriori informazioni sull'incorporamento utilizzando le vecchie operazioni API, consulta [Incorporare analisi utilizzando](https://docs.aws.amazon.com/quicksight/latest/user/embedded-analytics-deprecated.html) e operazioni API. GetDashboardEmbedURL GetSessionEmbedURL


|  | 
| --- |
|  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 utenti anonimi (non registrati).

**Topics**
+ [

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

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

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

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


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

Puoi creare una condizione nella tua policy IAM che limiti i domini che gli sviluppatori possono elencare nel parametro `AllowedDomains` di un'operazione API `GenerateEmbedUrlForAnonymousUser`. Il parametro `AllowedDomains` è un parametro facoltativo. In qualità di sviluppatore, ti offre la possibilità di sovrascrivere i domini statici configurati nel menu Manage **Amazon Quick** Sight. Puoi invece elencare fino a tre domini o sottodomini che possono accedere a un URL generato. Questo URL viene quindi incorporato nel sito web che crei. Solo i domini elencati nel parametro possono accedere al pannello di controllo incorporato. Senza questa condizione, nel parametro `AllowedDomains` puoi elencare qualsiasi dominio su Internet. 

Per limitare i domini che gli sviluppatori possono utilizzare con questo parametro, aggiungi una condizione `AllowedEmbeddingDomains` alla tua policy IAM. Per ulteriori informazioni sul `AllowedDomains` parametro, consulta [GenerateEmbedUrlForAnonymousUser](https://docs.aws.amazon.com//quicksight/latest/APIReference/API_GenerateEmbedUrlForAnonymousUser.html)*Amazon Quick Sight API Reference*.

**Best practice di sicurezza per gli operatori di condizioni IAM**  
Gli operatori di condizioni IAM configurati in modo errato possono consentire l'accesso non autorizzato alle risorse Quick incorporate tramite variazioni di URL. Quando utilizzi la chiave `quicksight:AllowedEmbeddingDomains` condition nelle tue policy IAM, utilizza operatori di condizione che consentano domini specifici o neghino tutti i domini che non sono specificamente consentiti. Per ulteriori informazioni sugli operatori di condizioni IAM, consulta [IAM JSON Policy elements: Condition operators](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_elements_condition_operators.html) nella IAM User Guide.  
Molte varianti di URL diverse possono puntare alla stessa risorsa. Ad esempio, i seguenti elementi si risolvono URLs tutti allo stesso contenuto:  
`https://example.com`
`https://example.com/`
`https://Example.com`
Se la tua politica utilizza operatori che non tengono conto di queste variazioni di URL, un utente malintenzionato può aggirare le tue restrizioni fornendo varianti URL equivalenti.  
Devi verificare che la tua policy IAM utilizzi operatori di condizioni appropriati per evitare di aggirare le vulnerabilità e garantire che solo i domini previsti possano accedere alle tue risorse incorporate.

La seguente policy di esempio fornisce le autorizzazioni da utilizzare con `GenerateEmbedUrlForAnonymousUser`. Affinché questo approccio funzioni, hai anche bisogno di un session pack, o tariffazione della capacità della sessione, per il tuo Account AWS. Altrimenti, quando un utente prova ad accedere al pannello di controllo, viene restituito l'errore `UnsupportedPricingPlanException`. 

È 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. Di seguito è mostrata una policy di attendibilità di esempio.

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

****  

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

------

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: Generazione dell'URL con il codice di autenticazione allegato
<a name="embedded-analytics-dashboards-with-anonymous-users-step-2"></a>


|  | 
| --- |
|  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
<a name="embedded-analytics-dashboards-with-anonymous-users-java"></a>

```
import java.util.List;
    import com.amazonaws.auth.AWSCredentials;
    import com.amazonaws.auth.AWSCredentialsProvider;
    import com.amazonaws.auth.BasicAWSCredentials;
    import com.amazonaws.regions.Regions;
    import com.amazonaws.services.quicksight.AmazonQuickSight;
    import com.amazonaws.services.quicksight.AmazonQuickSightClientBuilder;
    import com.amazonaws.services.quicksight.model.RegisteredUserDashboardEmbeddingConfiguration;
    import com.amazonaws.services.quicksight.model.AnonymousUserEmbeddingExperienceConfiguration;
    import com.amazonaws.services.quicksight.model.GenerateEmbedUrlForAnonymousUserRequest;
    import com.amazonaws.services.quicksight.model.GenerateEmbedUrlForAnonymousUserResult;
    import com.amazonaws.services.quicksight.model.SessionTag;


    /**
    * Class to call QuickSight AWS SDK to generate embed url for anonymous user.
    */
    public class GenerateEmbedUrlForAnonymousUserExample {

        private final AmazonQuickSight quickSightClient;

        public GenerateEmbedUrlForAnonymousUserExample() {
            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 GenerateEmbedUrlForAnonymousUser(
            final String accountId, // YOUR AWS ACCOUNT ID
            final String initialDashboardId, // DASHBOARD ID TO WHICH THE CONSTRUCTED URL POINTS.
            final String namespace, // ANONYMOUS EMBEDDING REQUIRES SPECIFYING A VALID NAMESPACE FOR WHICH YOU WANT THE EMBEDDING URL
            final List<String> authorizedResourceArns, // DASHBOARD ARN LIST TO EMBED
            final List<String> allowedDomains, // RUNTIME ALLOWED DOMAINS FOR EMBEDDING
            final List<SessionTag> sessionTags // SESSION TAGS USED FOR ROW-LEVEL SECURITY
        ) throws Exception {
            AnonymousUserEmbeddingExperienceConfiguration experienceConfiguration = new AnonymousUserEmbeddingExperienceConfiguration();
            AnonymousUserDashboardEmbeddingConfiguration dashboardConfiguration = new AnonymousUserDashboardEmbeddingConfiguration();
            dashboardConfiguration.setInitialDashboardId(initialDashboardId);
            experienceConfiguration.setDashboard(dashboardConfiguration);

            GenerateEmbedUrlForAnonymousUserRequest generateEmbedUrlForAnonymousUserRequest = new GenerateEmbedUrlForAnonymousUserRequest()
                .withAwsAccountId(accountId)
                .withNamespace(namespace)
                .withAuthorizedResourceArns(authorizedResourceArns)
                .withExperienceConfiguration(experienceConfiguration)
                .withSessionTags(sessionTags)
                .withSessionLifetimeInMinutes(600L); // OPTIONAL: VALUE CAN BE [15-600]. DEFAULT: 600
                .withAllowedDomains(allowedDomains);

            GenerateEmbedUrlForAnonymousUserResult dashboardEmbedUrl = quickSightClient.generateEmbedUrlForAnonymousUser(generateEmbedUrlForAnonymousUserRequest);

            return dashboardEmbedUrl.getEmbedUrl();
        }

    }
```

### JavaScript
<a name="embedded-analytics-dashboards-with-anonymous-users-js"></a>

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

function generateEmbedUrlForAnonymousUser(
accountId, // YOUR AWS ACCOUNT ID
initialDashboardId, // DASHBOARD ID TO WHICH THE CONSTRUCTED URL POINTS
quicksightNamespace, // VALID NAMESPACE WHERE YOU WANT TO DO NOAUTH EMBEDDING
authorizedResourceArns, // DASHBOARD ARN LIST TO EMBED
allowedDomains, // RUNTIME ALLOWED DOMAINS FOR EMBEDDING
sessionTags, // SESSION TAGS USED FOR ROW-LEVEL SECURITY
generateEmbedUrlForAnonymousUserCallback, // GENERATEEMBEDURLFORANONYMOUSUSER SUCCESS CALLBACK METHOD
errorCallback // GENERATEEMBEDURLFORANONYMOUSUSER ERROR CALLBACK METHOD
) {
const experienceConfiguration = {
    "DashboardVisual": {
        "InitialDashboardVisualId": {
            "DashboardId": "dashboard_id",
            "SheetId": "sheet_id",
            "VisualId": "visual_id"
        }
    }
};

const generateEmbedUrlForAnonymousUserParams = {
    "AwsAccountId": accountId,
    "Namespace": quicksightNamespace,
    "AuthorizedResourceArns": authorizedResourceArns,
    "AllowedDomains": allowedDomains,
    "ExperienceConfiguration": experienceConfiguration,
    "SessionTags": sessionTags,
    "SessionLifetimeInMinutes": 600
};

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

quicksightClient.generateEmbedUrlForAnonymousUser(generateEmbedUrlForAnonymousUserParams, 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 THIS API
                "Access-Control-Allow-Headers": "Content-Type"
            },
            "body": JSON.stringify(data),
            "isBase64Encoded": false
        }
        generateEmbedUrlForAnonymousUserCallback(result);
    }
});
}
```

### Python3
<a name="embedded-analytics-dashboards-with-anonymous-users-py"></a>

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

# Create QuickSight and STS clients
quicksightClient = boto3.client('quicksight',region_name='us-west-2')
sts = boto3.client('sts')

# Function to generate embedded URL for anonymous user
# accountId: YOUR AWS ACCOUNT ID
# quicksightNamespace: VALID NAMESPACE WHERE YOU WANT TO DO NOAUTH EMBEDDING
# authorizedResourceArns: DASHBOARD ARN LIST TO EMBED
# allowedDomains: RUNTIME ALLOWED DOMAINS FOR EMBEDDING
# dashboardId: DASHBOARD ID TO WHICH THE CONSTRUCTED URL POINTS
# sessionTags: SESSION TAGS USED FOR ROW-LEVEL SECURITY
def generateEmbedUrlForAnonymousUser(accountId, quicksightNamespace, authorizedResourceArns, allowedDomains, dashboardId, sessionTags):
try:
    response = quicksightClient.generate_embed_url_for_anonymous_user(
        AwsAccountId = accountId,
        Namespace = quicksightNamespace,
        AuthorizedResourceArns = authorizedResourceArns,
        AllowedDomains = allowedDomains,
            ExperienceConfiguration = {
                "Dashboard": {
                    "InitialDashboardId": dashboardId
                }
            },
        SessionTags = sessionTags,
        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
<a name="embedded-analytics-dashboards-with-anonymous-users-node"></a>

L'esempio seguente mostra JavaScript (Node.js) che puoi usare sul server dell'app per generare l'URL per la 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 quicksightClient = new AWS.Service({
        apiConfig: require('./quicksight-2018-04-01.min.json'),
        region: 'us-east-1',
    });

    quicksightClient.generateEmbedUrlForAnonymousUser({
        'AwsAccountId': '111122223333',
        'Namespace' : 'default',
        'AuthorizedResourceArns': authorizedResourceArns,
        'AllowedDomains': allowedDomains,
        'ExperienceConfiguration': experienceConfiguration,
        'SessionTags': sessionTags,
        'SessionLifetimeInMinutes': 600

    }, 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://quicksightdomain/embed/12345/dashboards/67890..',
            RequestId: '7bee030e-f191-45c4-97fe-d9faf0e03713' 
        }
```

### .NET/C\$1
<a name="embedded-analytics-dashboards-with-anonymous-users-cs"></a>

L'esempio seguente mostra il codice .NET/C\$1 che è possibile utilizzare nel server delle applicazioni 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**  

```
using System;
    using Amazon.QuickSight;
    using Amazon.QuickSight.Model;

    var quicksightClient = new AmazonQuickSightClient(
        AccessKey,
        SecretAccessKey,
        sessionToken,
        Amazon.RegionEndpoint.USEast1);
        
    try
    {
        Console.WriteLine(
            quicksightClient.GenerateEmbedUrlForAnonymousUserAsync(new GenerateEmbedUrlForAnonymousUserRequest
            {
                AwsAccountId = "111122223333",
                Namespace = default,
                AuthorizedResourceArns = authorizedResourceArns,
                AllowedDomains = allowedDomains,
                ExperienceConfiguration = experienceConfiguration,
                SessionTags = sessionTags,
                SessionLifetimeInMinutes = 600,
            }).Result.EmbedUrl
        );
    } catch (Exception ex) {
        Console.WriteLine(ex.Message);
    }
```

### AWS CLI
<a name="embedded-analytics-dashboards-with-anonymous-users-cli"></a>

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)— Utilizza questa operazione quando utilizzi 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 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:GenerateEmbedUrlForAnonymousUser`. 

```
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 `generate-embed-url-for-anynymous-user` 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 generate-embed-url-for-anonymous-user \
--aws-account-id 111122223333 \
--namespace default-or-something-else \
--session-lifetime-in-minutes 15 \
--authorized-resource-arns '["dashboard-arn-1","dashboard-arn-2"]' \
--allowed-domains '["domain1","domain2"]' \
--session-tags '["Key": tag-key-1,"Value": tag-value-1,{"Key": tag-key-1,"Value": tag-value-1}]' \
--experience-configuration 'DashboardVisual={InitialDashboardVisualId={DashboardId=dashboard_id,SheetId=sheet_id,VisualId=visual_id}}'
```

Per ulteriori informazioni sull'utilizzo di questa operazione, consulta [https://docs.aws.amazon.com/quicksight/latest/APIReference/API_GenerateEmbedUrlForAnonymousUser.html](https://docs.aws.amazon.com/quicksight/latest/APIReference/API_GenerateEmbedUrlForAnonymousUser.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-step-3"></a>


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


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

Nella sezione seguente, puoi scoprire come utilizzare [Amazon Quick Sight Embedding SDK (JavaScript) per incorporare](https://www.npmjs.com/package/amazon-quicksight-embedding-sdk) l'URL della dashboard del 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 `GenerateEmbedUrlForAnynymousUser` per generare l'URL da incorporare nella tua app. 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 `generate-embed-url-for-anynymous-user`.

```
//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://quicksightdomain/embed/12345/dashboards/67890..",
            "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 dominio che ospiterà i pannelli di controllo integrati deve essere presente nell'*allowlist*, l'elenco dei domini approvati per la tua sottoscrizione Quick . Questo requisito protegge i tuoi dati impedendo ai domini non approvati di ospitare pannelli di controllo incorporati. Per ulteriori informazioni sull'aggiunta di domini per le dashboard integrate, consulta [Consentire la pubblicazione di domini in fase di esecuzione con l'API Amazon Quick](https://docs.aws.amazon.com/quicksight/latest/user/embedding-run-time.html) Sight.

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

### SDK 2.0
<a name="embedded-analytics-dashboards-with-anonymous-users-sdkv2"></a>

```
<!DOCTYPE html>
<html>

<head>
    <title>Dashboard Embedding Example</title>
    <script src="https://unpkg.com/amazon-quicksight-embedding-sdk@2.0.0/dist/quicksight-embedding-js-sdk.min.js"></script>
    <script type="text/javascript">
        const embedDashboard = async() => {
            const {
                createEmbeddingContext,
            } = QuickSightEmbedding;

            const embeddingContext = await createEmbeddingContext({
                onChange: (changeEvent, metadata) => {
                    console.log('Context received a change', changeEvent, metadata);
                },
            });

            const frameOptions = {
                url: '<YOUR_EMBED_URL>',
                container: '#experience-container',
                height: "700px",
                width: "1000px",
                onChange: (changeEvent, metadata) => {
                    switch (changeEvent.eventName) {
                        case 'FRAME_MOUNTED': {
                            console.log("Do something when the experience frame is mounted.");
                            break;
                        }
                        case 'FRAME_LOADED': {
                            console.log("Do something when the experience frame is loaded.");
                            break;
                        }
                    }
                },
            };

            const contentOptions = {
                parameters: [
                    {
                        Name: 'country',
                        Values: [
                            'United States'
                        ],
                    },
                    {
                        Name: 'states',
                        Values: [
                            'California',
                            'Washington'
                        ]
                    }
                ],
                locale: "en-US",
                sheetOptions: {
                    initialSheetId: '<YOUR_SHEETID>',
                    singleSheet: false,                        
                    emitSizeChangedEventOnSheetChange: false,
                },
                toolbarOptions: {
                    export: false,
                    undoRedo: false,
                    reset: false
                },
                attributionOptions: {
                    overlayContent: false,
                },
                onMessage: async (messageEvent, experienceMetadata) => {
                    switch (messageEvent.eventName) {
                        case 'CONTENT_LOADED': {
                            console.log("All visuals are loaded. The title of the document:", messageEvent.message.title);
                            break;
                        }
                        case 'ERROR_OCCURRED': {
                            console.log("Error occurred while rendering the experience. Error code:", messageEvent.message.errorCode);
                            break;
                        }
                        case 'PARAMETERS_CHANGED': {
                            console.log("Parameters changed. Changed parameters:", messageEvent.message.changedParameters);
                            break;
                        }
                        case 'SELECTED_SHEET_CHANGED': {
                            console.log("Selected sheet changed. Selected sheet:", messageEvent.message.selectedSheet);
                            break;
                        }
                        case 'SIZE_CHANGED': {
                            console.log("Size changed. New dimensions:", messageEvent.message);
                            break;
                        }
                        case 'MODAL_OPENED': {
                            window.scrollTo({
                                top: 0 // iframe top position
                            });
                            break;
                        }
                    }
                },
            };
            const embeddedDashboardExperience = await embeddingContext.embedDashboard(frameOptions, contentOptions);

            const selectCountryElement = document.getElementById('country');
            selectCountryElement.addEventListener('change', (event) => {
                embeddedDashboardExperience.setParameters([
                    {
                        Name: 'country',
                        Values: event.target.value
                    }
                ]);
            });
        };
    </script>
</head>

<body onload="embedDashboard()">
    <span>
        <label for="country">Country</label>
        <select id="country" name="country">
            <option value="United States">United States</option>
            <option value="Mexico">Mexico</option>
            <option value="Canada">Canada</option>
        </select>
    </span>
    <div id="experience-container"></div>
</body>

</html>
```

### SDK 1.0
<a name="embedded-analytics-dashboards-with-anonymous-users-sdkv1"></a>

```
<!DOCTYPE html>
<html>

<head>
    <title>Basic Embed</title>
    <script src="https://unpkg.com/amazon-quicksight-embedding-sdk@1.0.15/dist/quicksight-embedding-js-sdk.min.js"></script>
    <script type="text/javascript">
        var dashboard
        function onDashboardLoad(payload) {
            console.log("Do something when the dashboard is fully loaded.");
        }

        function onError(payload) {
            console.log("Do something when the dashboard fails loading");
        }

        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,
                parameters: {
                    country: "United States"
                },
                scrolling: "no",
                height: "700px",
                width: "1000px",
                locale: "en-US",
                footerPaddingEnabled: true
            };
            dashboard = QuickSightEmbedding.embedDashboard(options);
            dashboard.on("error", onError);
            dashboard.on("load", onDashboardLoad);
        }

        function onCountryChange(obj) {
            dashboard.setParameters({country: obj.value});
        }
    </script>
</head>

<body onload="embedDashboard()">
    <span>
        <label for="country">Country</label>
        <select id="country" name="country" onchange="onCountryChange(this)">
            <option value="United States">United States</option>
            <option value="Mexico">Mexico</option>
            <option value="Canada">Canada</option>
        </select>
    </span>
    <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'[Amazon Quick Sight Embedding SDK](https://github.com/awslabs/amazon-quicksight-embedding-sdk#step-3-create-the-quicksight-session-object) da. GitHub Questo repository è gestito da un gruppo di sviluppatori Amazon Quick Sight.
+ Scarica la versione più recente di Amazon Quick Sight Embedding SDK 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
  ```

# Abilitazione dei riepiloghi esecutivi nei pannelli di controllo integrati
<a name="embedded-analytics-genbi-executive-summaries-dashboard"></a>


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


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

Puoi abilitare i riepiloghi esecutivi nei pannelli di controllo incorporati. Se abilitata, gli utenti registrati possono generare riepiloghi esecutivi che forniscono un riepilogo di tutte le informazioni che Amazon Quick Sight ha generato per la dashboard. I riepiloghi esecutivi consentono ai lettori di trovare più facilmente approfondimenti e informazioni chiave su un pannello di controllo. Per ulteriori informazioni su come gli utenti generano un riepilogo esecutivo di un pannello di controllo, consulta [Generare un riepilogo esecutivo di un pannello di controllo Amazon Quick Sight](https://docs.aws.amazon.com/quicksight/latest/user/use-executive-summaries.html).

**Nota**  
I riepiloghi esecutivi sono disponibili solo nei pannelli di controllo incorporati per gli utenti registrati e non possono essere abilitati nei pannelli di controllo incorporati per utenti anonimi o non registrati.

**Per abilitare i riepiloghi esecutivi nei pannelli di controllo incorporati per gli utenti registrati**
+ Segui la procedura descritta in [Incorporare dashboard Amazon Quick Sight per utenti registrati per](https://docs.aws.amazon.com/quicksight/latest/user/embedded-analytics-dashboards-for-authenticated-users.html) incorporare un pannello di controllo con le seguenti modifiche:

  1. Quando generi l'URL nella fase 2, imposta `Enabled: true` il `ExecutiveSummary` parametro nel [GenerateEmbedUrlForRegisteredUser](https://docs.aws.amazon.com/quicksight/latest/APIReference/API_GenerateEmbedUrlForRegisteredUser.html)o [GenerateEmbedUrlForRegisteredUserWithIdentity](https://docs.aws.amazon.com/quicksight/latest/APIReference/API_GenerateEmbedUrlForRegisteredUserWithIdentity.html)come mostrato nell'esempio seguente:

     ```
     ExperienceConfiguration: {
             Dashboard: {
                 InitialDashboardId: dashboard_id,
                 FeatureConfigurations: {
                     AmazonQInQuickSight: {
                         ExecutiveSummary: {
                             Enabled: true
                         }
                     }
                 }
             }
         }
     }
     ```

  1. Quando incorpori l'URL della dashboard con Amazon Quick Sight Embedding SDK nella fase 3, imposta `executiveSummary: true` come mostrato nell'esempio seguente: `contentOptions`

     ```
     const contentOptions = {
         toolbarOptions: {
             executiveSummary: true
         }
     };
     ```

# Integrazione di elementi visivi di Amazon Quick Sight con Amazon Quick Sight APIs
<a name="embedding-visuals"></a>

Puoi incorporare immagini individuali che fanno parte di un pannello di controllo pubblicato nella tua applicazione con l'API Amazon Quick Sight.

**Topics**
+ [

# Incorporamento di immagini di Amazon Quick Sight per gli utenti registrati
](embedded-analytics-visuals-for-authenticated-users.md)
+ [

# Incorporamento di elementi visivi di Amazon Quick Sight per utenti anonimi (non registrati)
](embedded-analytics-visuals-for-everyone.md)

# Incorporamento di immagini di Amazon Quick Sight per gli utenti registrati
<a name="embedded-analytics-visuals-for-authenticated-users"></a>


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


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

Nelle sezioni seguenti, puoi trovare informazioni dettagliate su come configurare gli elementi visivi incorporati di Amazon Quick Sight per gli utenti registrati di Amazon Quick Sight.

**Topics**
+ [

## Fase 1: Configurazione delle autorizzazioni
](#embedded-visuals-for-authenticated-users-step-1)
+ [

## Fase 2: Generazione dell'URL con il codice di autenticazione allegato
](#embedded-visuals-for-authenticated-users-step-2)
+ [

## Fase 3: Incorporamento dell'URL di un elemento visivo
](#embedded-visuals-for-authenticated-users-step-3)

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

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 oggetto visivo 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. Il ruolo IAM deve fornire le autorizzazioni per recuperare l'incorporamento URLs per un pool di utenti specifico. Con l'aiuto del carattere jolly *\$1*, puoi concedere le autorizzazioni per generare un URL per tutti gli utenti in uno spazio dei nomi specifico o per un sottoinsieme di utenti in spazi dei nomi specifici. Per questo, aggiungi `quicksight:GenerateEmbedUrlForRegisteredUser`.

Puoi creare una condizione nella tua policy IAM che limiti i domini che gli sviluppatori possono elencare nel parametro `AllowedDomains` di un'operazione API `GenerateEmbedUrlForAnonymousUser`. Il parametro `AllowedDomains` è un parametro facoltativo. In qualità di sviluppatore, ti offre la possibilità di sovrascrivere i domini statici configurati nel menu Manage **Amazon Quick** Sight. Puoi invece elencare fino a tre domini o sottodomini che possono accedere a un URL generato. Questo URL viene quindi incorporato nel sito web che crei. Solo i domini elencati nel parametro possono accedere al pannello di controllo incorporato. Senza questa condizione, nel parametro `AllowedDomains` puoi elencare qualsiasi dominio su Internet. 

Per limitare i domini che gli sviluppatori possono utilizzare con questo parametro, aggiungi una condizione `AllowedEmbeddingDomains` alla tua policy IAM. Per ulteriori informazioni sul `AllowedDomains` parametro, consulta [GenerateEmbedUrlForRegisteredUser](https://docs.aws.amazon.com//quicksight/latest/APIReference/API_GenerateEmbedUrlForRegisteredUser.html)*Amazon Quick Sight API Reference*.

**Best practice di sicurezza per gli operatori di condizioni IAM**  
Gli operatori di condizioni IAM configurati in modo errato possono consentire l'accesso non autorizzato alle risorse Quick incorporate tramite variazioni di URL. Quando utilizzi la chiave `quicksight:AllowedEmbeddingDomains` condition nelle tue policy IAM, utilizza operatori di condizione che consentano domini specifici o neghino tutti i domini che non sono specificamente consentiti. Per ulteriori informazioni sugli operatori di condizioni IAM, consulta [IAM JSON Policy elements: Condition operators](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_elements_condition_operators.html) nella IAM User Guide.  
Molte varianti di URL diverse possono puntare alla stessa risorsa. Ad esempio, i seguenti elementi si risolvono URLs tutti allo stesso contenuto:  
`https://example.com`
`https://example.com/`
`https://Example.com`
Se la tua politica utilizza operatori che non tengono conto di queste variazioni di URL, un utente malintenzionato può aggirare le tue restrizioni fornendo varianti URL equivalenti.  
Devi verificare che la tua policy IAM utilizzi operatori di condizioni appropriati per evitare di aggirare le vulnerabilità e garantire che solo i domini previsti possano accedere alle tue risorse incorporate.

Queste autorizzazioni sono fornite dalla seguente policy di esempio.

Inoltre, se stai creando utenti alle prime armi che saranno lettori di Amazon Quick Sight, assicurati di aggiungere l'`quicksight:RegisterUser`autorizzazione nella policy.

La seguente politica di esempio fornisce l'autorizzazione a recuperare un URL di incorporamento per gli utenti alle prime armi che devono essere lettori di Amazon Quick Sight.

Infine, è 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. Di seguito è mostrata una policy di attendibilità di esempio.

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

****  

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

------

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 o 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: Generazione dell'URL con il codice di autenticazione allegato
<a name="embedded-visuals-for-authenticated-users-step-2"></a>

Nella sezione seguente, puoi scoprire come autenticare il tuo utente Amazon Quick Sight e ottenere l'URL visivo incorporabile sul tuo server delle applicazioni. Se prevedi di incorporare immagini per tipi di identità IAM o Amazon Quick Sight, condividi le immagini con gli utenti di Amazon Quick Sight.

Quando un utente Amazon Quick Sight accede alla tua app, l'app assume il ruolo IAM per conto dell'utente Amazon Quick Sight. Quindi aggiunge l'utente ad Amazon Quick Sight, se quell'utente Amazon Quick Sight 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 dell'immagine 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.

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

### Java
<a name="embedded-visuals-for-authenticated-users-java"></a>

```
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.DashboardVisualId;
import com.amazonaws.services.quicksight.model.GenerateEmbedUrlForRegisteredUserRequest;
import com.amazonaws.services.quicksight.model.GenerateEmbedUrlForRegisteredUserResult;
import com.amazonaws.services.quicksight.model.RegisteredUserDashboardVisualEmbeddingConfiguration;
import com.amazonaws.services.quicksight.model.RegisteredUserEmbeddingExperienceConfiguration;

import java.util.List;

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

    private final AmazonQuickSight quickSightClient;

    public GenerateEmbedUrlForRegisteredUserTest() {
        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 getEmbedUrl(
            final String accountId, // AWS Account ID
            final String dashboardId, // Dashboard ID of the dashboard to embed
            final String sheetId, // Sheet ID of the sheet to embed
            final String visualId, // Visual ID of the visual to embed
            final List<String> allowedDomains, // Runtime allowed domains for embedding
            final String userArn // Registered user arn of the user that you want to provide embedded visual. Refer to Get Embed Url section in developer portal to find out how to get user arn for a QuickSight user.
    ) throws Exception {
        final DashboardVisualId dashboardVisual = new DashboardVisualId()
            .withDashboardId(dashboardId)
            .withSheetId(sheetId)
            .withVisualId(visualId);
        final RegisteredUserDashboardVisualEmbeddingConfiguration registeredUserDashboardVisualEmbeddingConfiguration
            = new RegisteredUserDashboardVisualEmbeddingConfiguration()
                .withInitialDashboardVisualId(dashboardVisual);
        final RegisteredUserEmbeddingExperienceConfiguration registeredUserEmbeddingExperienceConfiguration
            = new RegisteredUserEmbeddingExperienceConfiguration()
                .withDashboardVisual(registeredUserDashboardVisualEmbeddingConfiguration);
        final GenerateEmbedUrlForRegisteredUserRequest generateEmbedUrlForRegisteredUserRequest
            = new GenerateEmbedUrlForRegisteredUserRequest()
                .withAwsAccountId(accountId)
                .withUserArn(userArn)
                .withExperienceConfiguration(registeredUserEmbeddingExperienceConfiguration)
                .withAllowedDomains(allowedDomains);

        final GenerateEmbedUrlForRegisteredUserResult generateEmbedUrlForRegisteredUserResult = quickSightClient.generateEmbedUrlForRegisteredUser(generateEmbedUrlForRegisteredUserRequest);

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

### JavaScript
<a name="embedded-visuals-for-authenticated-users-js"></a>

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

function generateEmbedUrlForRegisteredUser(
    accountId, // Your AWS account ID
    dashboardId, // Dashboard ID to which the constructed URL points
    sheetId, // Sheet ID to which the constructed URL points
    visualId, // Visual ID to which the constructed URL points
    openIdToken, // Cognito-based token
    userArn, // registered user arn
    roleArn, // IAM user role to use for embedding
    sessionName, // Session name for the roleArn assume role
    allowedDomains, // Runtime allowed domain for embedding
    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,
                "ExperienceConfiguration": {
                    "DashboardVisual": {
                        "InitialDashboardVisualId": {
                            "DashboardId": dashboardId,
                            "SheetId": sheetId,
                            "VisualId": visualId
                        }
                    }
                },
                "UserArn": userArn,
                "AllowedDomains": allowedDomains,
                "SessionLifetimeInMinutes": 600
            };

            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.generateEmbedUrlForRegisteredUser(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
<a name="embedded-visuals-for-authenticated-users-py"></a>

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

sts = boto3.client('sts')

# Function to generate embedded URL  
# accountId: AWS account ID
# dashboardId: Dashboard ID to embed
# sheetId: SHEET ID to embed from the dashboard 
# visualId: Id for the Visual you want to embedded from the dashboard sheet. 
# userArn: arn of registered user
# allowedDomains: Runtime allowed domain for embedding
# roleArn: IAM user role to use for embedding
# sessionName: session name for the roleArn assume role
def getEmbeddingURL(accountId, dashboardId, sheetId, visualId, userArn, allowedDomains, roleArn, sessionName):
    try:
        assumedRole = sts.assume_role(
            RoleArn = roleArn,
            RoleSessionName = sessionName,
        )
    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:
            quicksightClient = assumedRoleSession.client('quicksight', region_name='us-west-2')
            response = quicksightClient.generate_embed_url_for_registered_user(
                AwsAccountId=accountId,
                ExperienceConfiguration = {
                    'DashboardVisual': {
                        'InitialDashboardVisualId': {
                            'DashboardId': dashboardId,
                            'SheetId': sheetId,
                            'VisualId': visualId
                        }
                    },
                },
                UserArn = userArn,
                AllowedDomains = allowedDomains,
                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:
            return "Error generating embedding url: " + str(e)
```

### Node.js
<a name="embedded-visuals-for-authenticated-users-node"></a>

L'esempio seguente mostra JavaScript (Node.js) che puoi usare sul server dell'app per generare l'URL per la 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 quicksightClient = new AWS.Service({
    apiConfig: require('./quicksight-2018-04-01.min.json'),
    region: 'us-east-1',
});

quicksightClient.generateEmbedUrlForRegisteredUser({
    'AwsAccountId': '111122223333',
    'ExperienceConfiguration': { 
        'DashboardVisual': {
            'InitialDashboardVisualId': {
                'DashboardId': 'dashboard_id',
                'SheetId': 'sheet_id',
                'VisualId': 'visual_id'
            }
        }
    },
    'UserArn': 'REGISTERED_USER_ARN',
    'AllowedDomains': allowedDomains,
    'SessionLifetimeInMinutes': 100
}, 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://quicksightdomain/embed/12345/dashboards/67890/sheets/12345/visuals/67890...",
        "RequestId": "7bee030e-f191-45c4-97fe-d9faf0e03713"
    }
```

### .NET/C\$1
<a name="embedded-visuals-for-authenticated-users-cs"></a>

L'esempio seguente mostra il codice .NET/C\$1 che è possibile utilizzare nel server delle applicazioni 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**  

```
using System;
using Amazon.QuickSight;
using Amazon.QuickSight.Model;

namespace GenerateDashboardEmbedUrlForRegisteredUser
{
    class Program
    {
        static void Main(string[] args)
        {
            var quicksightClient = new AmazonQuickSightClient(
                AccessKey,
                SecretAccessKey,
                SessionToken,
                Amazon.RegionEndpoint.USEast1);
            try
            {
                DashboardVisualId dashboardVisual = new DashboardVisualId
                {
                    DashboardId = "dashboard_id",
                    SheetId = "sheet_id",
                    VisualId = "visual_id"
                };

                RegisteredUserDashboardVisualEmbeddingConfiguration registeredUserDashboardVisualEmbeddingConfiguration
                    = new RegisteredUserDashboardVisualEmbeddingConfiguration
                    {
                        InitialDashboardVisualId = dashboardVisual                        
                    };               
                    
                RegisteredUserEmbeddingExperienceConfiguration registeredUserEmbeddingExperienceConfiguration
                    = new RegisteredUserEmbeddingExperienceConfiguration
                    {
                        DashboardVisual = registeredUserDashboardVisualEmbeddingConfiguration
                    };
                    
                Console.WriteLine(
                    quicksightClient.GenerateEmbedUrlForRegisteredUserAsync(new GenerateEmbedUrlForRegisteredUserRequest
                    {
                        AwsAccountId = "111122223333",
                        ExperienceConfiguration = registeredUserEmbeddingExperienceConfiguration,
                        UserArn = "REGISTERED_USER_ARN",
                        AllowedDomains = allowedDomains,
                        SessionLifetimeInMinutes = 100
                    }).Result.EmbedUrl
                );
            } catch (Exception ex) {
                Console.WriteLine(ex.Message);
            }
        }
    }
}
```

### AWS CLI
<a name="embedded-visuals-for-authenticated-users-cli"></a>

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)— Utilizza questa operazione quando utilizzi un provider di identità web per autenticare il tuo 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:GenerateEmbedUrlForRegisteredUser`. 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_visual_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_visual_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 relative all'API Amazon Quick Sight, consulta l'[Amazon Quick Sight API Reference](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_visual_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 l'immagine. 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_visual_role/john.doe@example.com"
```

Ora hai un utente della tua app che è anche utente di Amazon Quick Sight e che ha accesso all'immagine. 

Infine, per ottenere un URL provvisto di firma per l'elemento visivo, chiama `generate-embed-url-for-registered-user` dal server delle applicazioni. Questo restituisce l'URL dell'elemento visivo incorporabile. L'esempio seguente mostra come generare l'URL per un elemento visivo incorporato utilizzando una chiamata lato server per utenti autenticati tramite AWS Managed Microsoft AD o Single Sign-On (IAM Identity Center).

```
aws quicksight generate-embed-url-for-registered-user \
    --aws-account-id 111122223333 \
    --session-lifetime-in-minutes 600 \
    --user-arn arn:aws:quicksight:us-east-1:111122223333:user/default/embedding_quicksight_visual_role/embeddingsession \
    --allowed-domains '["domain1","domain2"]' \
    --experience-configuration 'DashboardVisual={InitialDashboardVisualId={DashboardId=dashboard_id,SheetId=sheet_id,VisualId=visual_id}}'
```

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

## Fase 3: Incorporamento dell'URL di un elemento visivo
<a name="embedded-visuals-for-authenticated-users-step-3"></a>

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

Chiama l'operazione API `GenerateEmbedUrlForRegisteredUser` per generare l'URL da incorporare nella tua app. 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 `generate-embed-url-for-registered-user`. `quicksightdomain`In questo esempio è l'URL che usi per accedere al tuo account Amazon Quick Sight.

```
//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://quicksightdomain/embed/12345/dashboards/67890/sheets/12345/visuals/67890...",
        "RequestId": "7bee030e-f191-45c4-97fe-d9faf0e03713"
    }
```

Incorpora questa immagine 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 dell'immagine e ricevere callback in termini di completamento del caricamento della pagina ed errori. 

Il dominio che ospiterà gli elementi visivi e i pannelli di controllo incorporati deve essere incluso nell'elenco dei domini *consentiti, l'elenco dei* domini approvati per l'abbonamento. Quick Questo requisito protegge i tuoi dati impedendo ai domini non approvati di ospitare elementi visivi e pannelli di controllo incorporati. Per ulteriori informazioni sull'aggiunta di domini per immagini e dashboard incorporati, consulta [Consentire la pubblicazione di domini in fase di esecuzione con l'API Amazon](https://docs.aws.amazon.com/quicksight/latest/user/embedding-run-time.html) Quick Sight.

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

### SDK 2.0
<a name="embedded-visuals-for-authenticated-users-sdkv2"></a>

```
<!DOCTYPE html>
<html>

    <head>
        <title>Visual Embedding Example</title>
        <script src="https://unpkg.com/amazon-quicksight-embedding-sdk@2.0.0/dist/quicksight-embedding-js-sdk.min.js"></script>
        <script type="text/javascript">
            const embedVisual = async() => {    
                const {
                    createEmbeddingContext,
                } = QuickSightEmbedding;

                const embeddingContext = await createEmbeddingContext({
                    onChange: (changeEvent, metadata) => {
                        console.log('Context received a change', changeEvent, metadata);
                    },
                });

                const frameOptions = {
                    url: "<YOUR_EMBED_URL>", // replace this value with the url generated via embedding API
                    container: '#experience-container',
                    height: "700px",
                    width: "1000px",
                    onChange: (changeEvent, metadata) => {
                        switch (changeEvent.eventName) {
                            case 'FRAME_MOUNTED': {
                                console.log("Do something when the experience frame is mounted.");
                                break;
                            }
                            case 'FRAME_LOADED': {
                                console.log("Do something when the experience frame is loaded.");
                                break;
                            }
                        }
                    },
                };

                const contentOptions = {
                    parameters: [
                        {
                            Name: 'country',
                            Values: ['United States'],
                        },
                        {
                            Name: 'states',
                            Values: [
                                'California',
                                'Washington'
                            ]
                        }
                    ],
                    locale: "en-US",
                    onMessage: async (messageEvent, experienceMetadata) => {
                        switch (messageEvent.eventName) {
                            case 'CONTENT_LOADED': {
                                console.log("All visuals are loaded. The title of the document:", messageEvent.message.title);
                                break;
                            }
                            case 'ERROR_OCCURRED': {
                                console.log("Error occurred while rendering the experience. Error code:", messageEvent.message.errorCode);
                                break;
                            }
                            case 'PARAMETERS_CHANGED': {
                                console.log("Parameters changed. Changed parameters:", messageEvent.message.changedParameters);
                                break;
                            }
                            case 'SIZE_CHANGED': {
                                console.log("Size changed. New dimensions:", messageEvent.message);
                                break;
                            }
                        }
                    },
                };
                const embeddedVisualExperience = await embeddingContext.embedVisual(frameOptions, contentOptions);

                const selectCountryElement = document.getElementById('country');
                selectCountryElement.addEventListener('change', (event) => {
                    embeddedVisualExperience.setParameters([
                        {
                            Name: 'country',
                            Values: event.target.value
                        }
                    ]);
                });
            };
        </script>
    </head>

    <body onload="embedVisual()">
        <span>
            <label for="country">Country</label>
            <select id="country" name="country">
                <option value="United States">United States</option>
                <option value="Mexico">Mexico</option>
                <option value="Canada">Canada</option>
            </select>
        </span>
        <div id="experience-container"></div>
    </body>

</html>
```

### SDK 1.0
<a name="embedded-visuals-for-authenticated-users-sdkv1"></a>

```
<!DOCTYPE html>
<html>

    <head>
        <title>Visual Embedding Example</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">
            let embeddedVisualExperience;
            function onVisualLoad(payload) {
                console.log("Do something when the visual is fully loaded.");
            }

            function onError(payload) {
                console.log("Do something when the visual fails loading");
            }

            function embedVisual() {
                const containerDiv = document.getElementById("embeddingContainer");
                const options = {
                    url: "<YOUR_EMBED_URL>", // replace this value with the url generated via embedding API
                    container: containerDiv,
                    parameters: {
                        country: "United States"
                    },
                    height: "700px",
                    width: "1000px",
                    locale: "en-US"
                };
                embeddedVisualExperience = QuickSightEmbedding.embedVisual(options);
                embeddedVisualExperience.on("error", onError);
                embeddedVisualExperience.on("load", onVisualLoad);
            }

            function onCountryChange(obj) {
                embeddedVisualExperience.setParameters({country: obj.value});
            }
        </script>
    </head>

    <body onload="embedVisual()">
        <span>
            <label for="country">Country</label>
            <select id="country" name="country" onchange="onCountryChange(this)">
                <option value="United States">United States</option>
                <option value="Mexico">Mexico</option>
                <option value="Canada">Canada</option>
            </select>
        </span>
        <div id="embeddingContainer"></div>
    </body>

</html>
```

Affinché questo esempio funzioni, assicurati di utilizzare l'SDK Amazon Quick Sight Embedding per caricare la grafica incorporata sul tuo sito Web utilizzando. JavaScript Per ottenere la tua copia, procedi in uno dei seguenti modi:
+ Scarica l'[Amazon Quick Sight Embedding SDK](https://github.com/awslabs/amazon-quicksight-embedding-sdk#step-3-create-the-quicksight-session-object) da. 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 di elementi visivi di Amazon Quick Sight per utenti anonimi (non registrati)
<a name="embedded-analytics-visuals-for-everyone"></a>


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


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

Nelle sezioni seguenti, puoi trovare informazioni dettagliate su come configurare elementi visivi Amazon Quick Sight incorporati per utenti anonimi (non registrati).

**Topics**
+ [

## Fase 1: Configurazione delle autorizzazioni
](#embedded-analytics-visuals-with-anonymous-users-step-1)
+ [

## Fase 2: Generazione dell'URL con il codice di autenticazione allegato
](#embedded-analytics-visuals-with-anonymous-users-step-2)
+ [

## Fase 3: Incorporamento dell'URL di un elemento visivo
](#embedded-analytics-visuals-with-anonymous-users-step-3)

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


|  | 
| --- |
|  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 oggetto visivo 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.

Puoi creare una condizione nella tua policy IAM che limiti i domini che gli sviluppatori possono elencare nel parametro `AllowedDomains` di un'operazione API `GenerateEmbedUrlForAnonymousUser`. Il parametro `AllowedDomains` è un parametro facoltativo. In qualità di sviluppatore, ti offre la possibilità di sovrascrivere i domini statici configurati nel menu Manage **Amazon Quick** Sight. Puoi invece elencare fino a tre domini o sottodomini che possono accedere a un URL generato. Questo URL viene quindi incorporato nel sito web che crei. Solo i domini elencati nel parametro possono accedere al pannello di controllo incorporato. Senza questa condizione, nel parametro `AllowedDomains` puoi elencare qualsiasi dominio su Internet. 

Per limitare i domini che gli sviluppatori possono utilizzare con questo parametro, aggiungi una condizione `AllowedEmbeddingDomains` alla tua policy IAM. Per ulteriori informazioni sul `AllowedDomains` parametro, consulta [GenerateEmbedUrlForAnonymousUser](https://docs.aws.amazon.com//quicksight/latest/APIReference/API_GenerateEmbedUrlForAnonymousUser.html)*Amazon Quick Sight API Reference*.

**Best practice di sicurezza per gli operatori di condizioni IAM**  
Gli operatori di condizioni IAM configurati in modo errato possono consentire l'accesso non autorizzato alle risorse Quick incorporate tramite variazioni di URL. Quando utilizzi la chiave `quicksight:AllowedEmbeddingDomains` condition nelle tue policy IAM, utilizza operatori di condizione che consentano domini specifici o neghino tutti i domini che non sono specificamente consentiti. Per ulteriori informazioni sugli operatori di condizioni IAM, consulta [IAM JSON Policy elements: Condition operators](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_elements_condition_operators.html) nella IAM User Guide.  
Molte varianti di URL diverse possono puntare alla stessa risorsa. Ad esempio, i seguenti elementi si risolvono URLs tutti allo stesso contenuto:  
`https://example.com`
`https://example.com/`
`https://Example.com`
Se la tua politica utilizza operatori che non tengono conto di queste variazioni di URL, un utente malintenzionato può aggirare le tue restrizioni fornendo varianti URL equivalenti.  
Devi verificare che la tua policy IAM utilizzi operatori di condizioni appropriati per evitare di aggirare le vulnerabilità e garantire che solo i domini previsti possano accedere alle tue risorse incorporate.

È 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 l'elemento visivo. Di seguito è mostrata una policy di attendibilità di esempio.

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

****  

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

------

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: Generazione dell'URL con il codice di autenticazione allegato
<a name="embedded-analytics-visuals-with-anonymous-users-step-2"></a>


|  | 
| --- |
|  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 dell'elemento visivo 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
<a name="embedded-analytics-visuals-with-anonymous-users-java"></a>

```
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.AnonymousUserDashboardVisualEmbeddingConfiguration;
import com.amazonaws.services.quicksight.model.AnonymousUserEmbeddingExperienceConfiguration;
import com.amazonaws.services.quicksight.model.DashboardVisualId;
import com.amazonaws.services.quicksight.model.GenerateEmbedUrlForAnonymousUserRequest;
import com.amazonaws.services.quicksight.model.GenerateEmbedUrlForAnonymousUserResult;
import com.amazonaws.services.quicksight.model.SessionTag;

import java.util.List;

/**
 * Class to call QuickSight AWS SDK to get url for Visual embedding.
 */
public class GenerateEmbedUrlForAnonymousUserTest {
    private final AmazonQuickSight quickSightClient;

    public GenerateEmbedUrlForAnonymousUserTest() {
        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 getEmbedUrl(
            final String accountId, // AWS Account ID
            final String namespace, // Anonymous embedding required specifying a valid namespace for which you want the enbedding URL
            final List<String> authorizedResourceArns, // Dashboard arn list of dashboard visuals to embed
            final String dashboardId, // Dashboard ID of the dashboard to embed
            final String sheetId, // Sheet ID of the sheet to embed
            final String visualId, // Visual ID of the visual to embed
            final List<String> allowedDomains, // Runtime allowed domains for embedding
            final List<SessionTag> sessionTags // Session tags used for row-level security
    ) throws Exception {
        final DashboardVisualId dashboardVisual = new DashboardVisualId()
            .withDashboardId(dashboardId)
            .withSheetId(sheetId)
            .withVisualId(visualId);
        final AnonymousUserDashboardVisualEmbeddingConfiguration anonymousUserDashboardVisualEmbeddingConfiguration
            = new AnonymousUserDashboardVisualEmbeddingConfiguration()
                .withInitialDashboardVisualId(dashboardVisual);
        final AnonymousUserEmbeddingExperienceConfiguration anonymousUserEmbeddingExperienceConfiguration
            = new AnonymousUserEmbeddingExperienceConfiguration()
                .withDashboardVisual(anonymousUserDashboardVisualEmbeddingConfiguration);
        final GenerateEmbedUrlForAnonymousUserRequest generateEmbedUrlForAnonymousUserRequest
            = new GenerateEmbedUrlForAnonymousUserRequest()
                .withAwsAccountId(accountId)
                .withNamespace(namespace)
                // authorizedResourceArns should contain ARN of dashboard used below in ExperienceConfiguration
                .withAuthorizedResourceArns(authorizedResourceArns)
                .withExperienceConfiguration(anonymousUserEmbeddingExperienceConfiguration)
                .withAllowedDomains(allowedDomains)
                .withSessionTags(sessionTags)
                .withSessionLifetimeInMinutes(600L);

        final GenerateEmbedUrlForAnonymousUserResult generateEmbedUrlForAnonymousUserResult
            = quickSightClient.generateEmbedUrlForAnonymousUser(generateEmbedUrlForAnonymousUserRequest);

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

### JavaScript
<a name="embedded-analytics-visuals-with-anonymous-users-js"></a>

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

function generateEmbedUrlForAnonymousUser(
    accountId, // Your AWS account ID
    dashboardId, // Dashboard ID to which the constructed url points
    sheetId, // Sheet ID to which the constructed url points
    visualId, // Visual ID to which the constructed url points
    quicksightNamespace, // valid namespace where you want to do embedding
    authorizedResourceArns, // dashboard arn list of dashboard visuals to embed
    allowedDomains, // runtime allowed domains for embedding
    sessionTags, // session tags used for row-level security
    generateEmbedUrlForAnonymousUserCallback, // success callback method
    errorCallback // error callback method
    ) {
    const experienceConfiguration = {
        "DashboardVisual": {
            "InitialDashboardVisualId": {
                "DashboardId": dashboardId,
                "SheetId": sheetId,
                "VisualId": visualId
            }
        }
    };
    
    const generateEmbedUrlForAnonymousUserParams = {
        "AwsAccountId": accountId,
        "Namespace": quicksightNamespace,
        // authorizedResourceArns should contain ARN of dashboard used below in ExperienceConfiguration
        "AuthorizedResourceArns": authorizedResourceArns,
        "AllowedDomains": allowedDomains,
        "ExperienceConfiguration": experienceConfiguration,
        "SessionTags": sessionTags,
        "SessionLifetimeInMinutes": 600
    };

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

    quicksightClient.generateEmbedUrlForAnonymousUser(generateEmbedUrlForAnonymousUserParams, 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 THIS API
                    "Access-Control-Allow-Headers": "Content-Type"
                },
                "body": JSON.stringify(data),
                "isBase64Encoded": false
            }
            generateEmbedUrlForAnonymousUserCallback(result);
        }
    });
}
```

### Python3
<a name="embedded-analytics-visuals-with-anonymous-users-py"></a>

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

# Create QuickSight and STS clients
quicksightClient = boto3.client('quicksight',region_name='us-west-2')
sts = boto3.client('sts')

# Function to generate embedded URL for anonymous user
# accountId: YOUR AWS ACCOUNT ID
# quicksightNamespace: VALID NAMESPACE WHERE YOU WANT TO DO NOAUTH EMBEDDING
# authorizedResourceArns: DASHBOARD ARN LIST TO EMBED
# allowedDomains: RUNTIME ALLOWED DOMAINS FOR EMBEDDING
# experienceConfiguration: DASHBOARD ID, SHEET ID and VISUAL ID TO WHICH THE CONSTRUCTED URL POINTS
# Example experienceConfig -> 'DashboardVisual': {
#     'InitialDashboardVisualId': {
#         'DashboardId': 'dashboardId',
#         'SheetId': 'sheetId',
#         'VisualId': 'visualId'
#     }
# },
# sessionTags: SESSION TAGS USED FOR ROW-LEVEL SECURITY
def generateEmbedUrlForAnonymousUser(accountId, quicksightNamespace, authorizedResourceArns, allowedDomains, experienceConfiguration, sessionTags):
    try:
        response = quicksightClient.generate_embed_url_for_anonymous_user(
            AwsAccountId = accountId,
            Namespace = quicksightNamespace,
            AuthorizedResourceArns = authorizedResourceArns,
            AllowedDomains = allowedDomains,
            ExperienceConfiguration = experienceConfiguration,
            SessionTags = sessionTags,
            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
<a name="embedded-analytics-visuals-with-anonymous-users-node"></a>

L'esempio seguente mostra JavaScript (Node.js) che puoi usare sul server dell'app per generare l'URL per la 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 quicksightClient = new AWS.Service({
    apiConfig: require('./quicksight-2018-04-01.min.json'),
    region: 'us-east-1',
});

quicksightClient.generateEmbedUrlForAnonymousUser({
    'AwsAccountId': '111122223333',
    'Namespace' : 'default',
    // authorizedResourceArns should contain ARN of dashboard used below in ExperienceConfiguration
    'AuthorizedResourceArns': authorizedResourceArns,
    'ExperienceConfiguration': { 
        'DashboardVisual': {
            'InitialDashboardVisualId': {
                'DashboardId': 'dashboard_id',
                'SheetId': 'sheet_id',
                'VisualId': 'visual_id'
            }
        }
    },
    'AllowedDomains': allowedDomains,    
    'SessionTags': sessionTags,
    'SessionLifetimeInMinutes': 600

}, 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://quicksightdomain/embed/12345/dashboards/67890/sheets/12345/visuals/67890...",
        "RequestId": "7bee030e-f191-45c4-97fe-d9faf0e03713"
    }
```

### .NET/C\$1
<a name="embedded-analytics-visuals-with-anonymous-users-cs"></a>

L'esempio seguente mostra il codice .NET/C\$1 che è possibile utilizzare nel server delle applicazioni 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**  

```
using System;
using Amazon.QuickSight;
using Amazon.QuickSight.Model;

namespace GenerateDashboardEmbedUrlForAnonymousUser
{
    class Program
    {
        static void Main(string[] args)
        {
            var quicksightClient = new AmazonQuickSightClient(
                AccessKey,
                SecretAccessKey,
                SessionToken,
                Amazon.RegionEndpoint.USEast1);
            try
            {
                DashboardVisualId dashboardVisual = new DashboardVisualId
                {
                    DashboardId = "dashboard_id",
                    SheetId = "sheet_id",
                    VisualId = "visual_id"
                };

                AnonymousUserDashboardVisualEmbeddingConfiguration anonymousUserDashboardVisualEmbeddingConfiguration
                    = new AnonymousUserDashboardVisualEmbeddingConfiguration
                    {
                        InitialDashboardVisualId = dashboardVisual                        
                    };               
                    
                AnonymousUserEmbeddingExperienceConfiguration anonymousUserEmbeddingExperienceConfiguration
                    = new AnonymousUserEmbeddingExperienceConfiguration
                    {
                        DashboardVisual = anonymousUserDashboardVisualEmbeddingConfiguration
                    }; 
                    
                Console.WriteLine(
                    quicksightClient.GenerateEmbedUrlForAnonymousUserAsync(new GenerateEmbedUrlForAnonymousUserRequest
                    {
                        AwsAccountId = "111222333444",
                        Namespace = default,
                        // authorizedResourceArns should contain ARN of dashboard used below in ExperienceConfiguration
                        AuthorizedResourceArns = { "dashboard_id" },
                        ExperienceConfiguration = anonymousUserEmbeddingExperienceConfiguration,
                        SessionTags = sessionTags,
                        SessionLifetimeInMinutes = 600,
                    }).Result.EmbedUrl
                );
            } catch (Exception ex) {
                Console.WriteLine(ex.Message);
            }
        }
    }
}
```

### AWS CLI
<a name="embedded-analytics-visuals-with-anonymous-users-cli"></a>

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)— Utilizza questa operazione quando utilizzi un provider di identità web per autenticare il tuo utente. 
+ [AssumeRoleWithSaml](https://docs.aws.amazon.com/STS/latest/APIReference/API_AssumeRoleWithSAML.html)— Utilizza questa operazione quando utilizzi 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:GenerateEmbedUrlForAnonymousUser`. 

```
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_visual_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 provvisto di firma per l'elemento visivo, chiama `generate-embed-url-for-anynymous-user` dal server delle applicazioni. Questo restituisce l'URL dell'elemento visivo incorporabile. L'esempio seguente mostra come generare l'URL per un elemento visivo incorporato utilizzando una chiamata lato server per gli utenti che effettuano visite anonime al portale Web o all'applicazione.

```
aws quicksight generate-embed-url-for-anonymous-user \
    --aws-account-id 111122223333 \
    --namespace default-or-something-else \
    --session-lifetime-in-minutes 15 \
    --authorized-resource-arns '["dashboard-arn-1","dashboard-arn-2"]' \
    --allowed-domains '["domain1","domain2"]' \
    --session-tags '["Key": tag-key-1,"Value": tag-value-1,{"Key": tag-key-1,"Value": tag-value-1}]' \
    --experience-configuration 'DashboardVisual={InitialDashboardVisualId={DashboardId=dashboard_id,SheetId=sheet_id,VisualId=visual_id}}'
```

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

## Fase 3: Incorporamento dell'URL di un elemento visivo
<a name="embedded-analytics-visuals-with-anonymous-users-step-3"></a>


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


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

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

Chiama l'operazione API `GenerateEmbedUrlForAnonymousUser` per generare l'URL da incorporare nella tua app. Questo URL è valido per 5 minuti, mentre la sessione risultante è valida per 10 ore. L'operazione API fornisce l'URL con un codice di autorizzazione (auth) che abilita una sessione Single Sign-On. 

Di seguito viene mostrata una risposta di esempio da `generate-embed-url-for-anonymous-user`. `quicksightdomain`In questo esempio è l'URL che usi per accedere al tuo account Amazon Quick Sight.

```
//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://quicksightdomain/embed/12345/dashboards/67890/sheets/12345/visuals/67890...",
        "RequestId": "7bee030e-f191-45c4-97fe-d9faf0e03713"
    }
```

Incorpora questa immagine nella tua pagina Web utilizzando Amazon Quick Sight [Embedding SDK](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 dell'immagine e ricevere callback in termini di completamento del caricamento visivo ed errori. 

Il dominio che ospiterà i pannelli di controllo integrati deve essere presente nell'*allowlist*, l'elenco dei domini approvati per la tua sottoscrizione Quick . Questo requisito protegge i tuoi dati impedendo ai domini non approvati di ospitare elementi visivi e pannelli di controllo incorporati. Per ulteriori informazioni sull'aggiunta di domini per immagini e dashboard incorporati, consulta [Consentire la pubblicazione di domini in fase di esecuzione con l'API Amazon](https://docs.aws.amazon.com/quicksight/latest/user/embedding-run-time.html) Quick Sight.

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

### SDK 2.0
<a name="embedded-analytics-visuals-with-anonymous-users-sdkv2"></a>

```
<!DOCTYPE html>
<html>

    <head>
        <title>Visual Embedding Example</title>
        <script src="https://unpkg.com/amazon-quicksight-embedding-sdk@2.0.0/dist/quicksight-embedding-js-sdk.min.js"></script>
        <script type="text/javascript">
            const embedVisual = async() => {    
                const {
                    createEmbeddingContext,
                } = QuickSightEmbedding;

                const embeddingContext = await createEmbeddingContext({
                    onChange: (changeEvent, metadata) => {
                        console.log('Context received a change', changeEvent, metadata);
                    },
                });

                const frameOptions = {
                    url: "<YOUR_EMBED_URL>", // replace this value with the url generated via embedding API
                    container: '#experience-container',
                    height: "700px",
                    width: "1000px",
                    onChange: (changeEvent, metadata) => {
                        switch (changeEvent.eventName) {
                            case 'FRAME_MOUNTED': {
                                console.log("Do something when the experience frame is mounted.");
                                break;
                            }
                            case 'FRAME_LOADED': {
                                console.log("Do something when the experience frame is loaded.");
                                break;
                            }
                        }
                    },
                };

                const contentOptions = {
                    parameters: [
                        {
                            Name: 'country',
                            Values: ['United States'],
                        },
                        {
                            Name: 'states',
                            Values: [
                                'California',
                                'Washington'
                            ]
                        }
                    ],
                    locale: "en-US",
                    onMessage: async (messageEvent, experienceMetadata) => {
                        switch (messageEvent.eventName) {
                            case 'CONTENT_LOADED': {
                                console.log("All visuals are loaded. The title of the document:", messageEvent.message.title);
                                break;
                            }
                            case 'ERROR_OCCURRED': {
                                console.log("Error occurred while rendering the experience. Error code:", messageEvent.message.errorCode);
                                break;
                            }
                            case 'PARAMETERS_CHANGED': {
                                console.log("Parameters changed. Changed parameters:", messageEvent.message.changedParameters);
                                break;
                            }
                            case 'SIZE_CHANGED': {
                                console.log("Size changed. New dimensions:", messageEvent.message);
                                break;
                            }
                        }
                    },
                };
                const embeddedVisualExperience = await embeddingContext.embedVisual(frameOptions, contentOptions);

                const selectCountryElement = document.getElementById('country');
                selectCountryElement.addEventListener('change', (event) => {
                    embeddedVisualExperience.setParameters([
                        {
                            Name: 'country',
                            Values: event.target.value
                        }
                    ]);
                });
            };
        </script>
    </head>

    <body onload="embedVisual()">
        <span>
            <label for="country">Country</label>
            <select id="country" name="country">
                <option value="United States">United States</option>
                <option value="Mexico">Mexico</option>
                <option value="Canada">Canada</option>
            </select>
        </span>
        <div id="experience-container"></div>
    </body>

</html>
```

### SDK 1.0
<a name="embedded-analytics-visuals-with-anonymous-users-sdkv1"></a>

```
<!DOCTYPE html>
<html>

    <head>
        <title>Visual Embedding Example</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">
            let embeddedVisualExperience;
            function onVisualLoad(payload) {
                console.log("Do something when the visual is fully loaded.");
            }

            function onError(payload) {
                console.log("Do something when the visual fails loading");
            }

            function embedVisual() {
                const containerDiv = document.getElementById("embeddingContainer");
                const options = {
                    url: "<YOUR_EMBED_URL>", // replace this value with the url generated via embedding API
                    container: containerDiv,
                    parameters: {
                        country: "United States"
                    },
                    height: "700px",
                    width: "1000px",
                    locale: "en-US"
                };
                embeddedVisualExperience = QuickSightEmbedding.embedVisual(options);
                embeddedVisualExperience.on("error", onError);
                embeddedVisualExperience.on("load", onVisualLoad);
            }

            function onCountryChange(obj) {
                embeddedVisualExperience.setParameters({country: obj.value});
            }
        </script>
    </head>

    <body onload="embedVisual()">
        <span>
            <label for="country">Country</label>
            <select id="country" name="country" onchange="onCountryChange(this)">
                <option value="United States">United States</option>
                <option value="Mexico">Mexico</option>
                <option value="Canada">Canada</option>
            </select>
        </span>
        <div id="embeddingContainer"></div>
    </body>

</html>
```

Affinché questo esempio funzioni, assicurati di utilizzare l'SDK Amazon Quick Sight Embedding per caricare la grafica incorporata sul tuo sito Web utilizzando. JavaScript Per ottenere la tua copia, procedi in uno dei seguenti modi:
+ Scarica l'[Amazon Quick Sight Embedding SDK](https://github.com/awslabs/amazon-quicksight-embedding-sdk#step-3-create-the-quicksight-session-object) da. 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
  ```

# Incorpora tutte le funzionalità della console Amazon Quick Sight per utenti registrati
<a name="embedded-analytics-full-console-for-authenticated-users"></a>

**Importante**  
Amazon Quick Sight dispone di nuove operazioni API per incorporare analisi: `GenerateEmbedUrlForAnonymousUser` e`GenerateEmbedUrlForRegisteredUser`.  
Puoi comunque utilizzare le operazioni `GetDashboardEmbedUrl` e `GetSessionEmbedUrl` API per incorporare dashboard e la console Amazon Quick Sight, ma non contengono le funzionalità di incorporamento più recenti. Per ulteriori informazioni sull'incorporamento utilizzando le vecchie operazioni API, consulta [Incorporare analisi utilizzando](https://docs.aws.amazon.com/quicksight/latest/user/embedded-analytics-deprecated.html) e operazioni API. GetDashboardEmbedURL GetSessionEmbedURL


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


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

Con l'edizione Enterprise, oltre a fornire dashboard di sola lettura, puoi anche fornire l'esperienza della console Amazon Quick Sight in un portale di authoring personalizzato. Utilizzando questo approccio, consenti ai tuoi utenti di creare origini dati, set di dati e analisi. Nella stessa interfaccia, possono creare, pubblicare e visualizzare i pannelli di controllo. Se desideri limitare alcune di queste autorizzazioni, puoi farlo anche in questo modo.

Gli utenti che accedono ad Amazon Quick Sight tramite una console integrata devono appartenere alla coorte di sicurezza degli autori o degli amministratori. I lettori non dispongono di accesso sufficiente per utilizzare la console Amazon Quick Sight per la creazione, indipendentemente dal fatto che sia integrata o parte Console di gestione AWS di. Tuttavia, gli autori e gli amministratori possono comunque accedere ai pannelli di controllo incorporati. Se desideri limitare le autorizzazioni ad alcune funzionalità di creazione, puoi aggiungere un profilo di autorizzazioni personalizzato all'utente con l'operazione API. [UpdateUser](https://docs.aws.amazon.com/quicksight/latest/APIReference/API_UpdateUser.html) Utilizza l'operazione [RegisterUser](https://docs.aws.amazon.com/quicksight/latest/APIReference/API_RegisterUser.html)API per aggiungere un nuovo utente con un profilo di autorizzazione personalizzato allegato. Per ulteriori informazioni, consulta le sezioni seguenti:
+ Per informazioni sulla creazione di ruoli personalizzati mediante la definizione di autorizzazioni personalizzate per la console, consulta [Personalizzazione dell'accesso alla console Amazon Quick Sight](https://docs.aws.amazon.com/quicksight/latest/user/customizing-permissions-to-the-quicksight-console.html).
+ [Per informazioni sull'uso dei namespace per isolare utenti, gruppi e asset Amazon Quick Sight multitenancy, consulta Amazon Quick Sight Namespaces.](https://docs.aws.amazon.com/quicksight/latest/APIReference/controlling-access.html#namespaces.html)
+ Per informazioni sull'aggiunta del tuo marchio a una console Amazon Quick Sight integrata, consulta [Using Themes in Amazon Quick Sight](https://docs.aws.amazon.com/quicksight/latest/user/themes-in-quicksight.html) e [QuickSight Theme API Operations](https://docs.aws.amazon.com/quicksight/latest/APIReference/qs-assets.html#themes). 

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

**Topics**
+ [

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

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

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

# Abilitazione delle funzionalità di BI generativa nelle console incorporate per gli utenti registrati
](embedding-consoles-genbi.md)

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

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:GenerateEmbedUrlForRegisteredUser`.

Puoi creare una condizione nella tua policy IAM che limiti i domini che gli sviluppatori possono elencare nel parametro `AllowedDomains` di un'operazione API `GenerateEmbedUrlForAnonymousUser`. Il parametro `AllowedDomains` è un parametro facoltativo. In qualità di sviluppatore, ti offre la possibilità di sovrascrivere i domini statici configurati nel menu Manage **Amazon Quick** Sight. Puoi invece elencare fino a tre domini o sottodomini che possono accedere a un URL generato. Questo URL viene quindi incorporato nel sito web che crei. Solo i domini elencati nel parametro possono accedere al pannello di controllo incorporato. Senza questa condizione, nel parametro `AllowedDomains` puoi elencare qualsiasi dominio su Internet. 

**Best practice di sicurezza per gli operatori delle condizioni IAM**  
Gli operatori di condizioni IAM configurati in modo errato possono consentire l'accesso non autorizzato alle risorse Quick incorporate tramite variazioni di URL. Quando utilizzi la chiave `quicksight:AllowedEmbeddingDomains` condition nelle tue policy IAM, utilizza operatori di condizione che consentano domini specifici o neghino tutti i domini che non sono specificamente consentiti. Per ulteriori informazioni sugli operatori di condizioni IAM, consulta [IAM JSON Policy elements: Condition operators](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_elements_condition_operators.html) nella IAM User Guide.  
Molte varianti di URL diverse possono puntare alla stessa risorsa. Ad esempio, i seguenti elementi si risolvono URLs tutti allo stesso contenuto:  
`https://example.com`
`https://example.com/`
`https://Example.com`
Se la tua politica utilizza operatori che non tengono conto di queste variazioni di URL, un utente malintenzionato può aggirare le tue restrizioni fornendo varianti URL equivalenti.  
Devi verificare che la tua policy IAM utilizzi operatori di condizioni appropriati per evitare di aggirare le vulnerabilità e garantire che solo i domini previsti possano accedere alle tue risorse incorporate.

Queste autorizzazioni sono fornite dalla seguente policy di esempio. 

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

Infine, è 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. Di seguito è mostrata una policy di attendibilità di esempio. 

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

****  

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

------

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 o 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: Generazione dell'URL con il codice di autenticazione allegato
<a name="embedded-analytics-full-console-for-authenticated-users-step-2"></a>

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
<a name="embedded-analytics-full-console-for-authenticated-users-java"></a>

```
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.GenerateEmbedUrlForRegisteredUserRequest;
import com.amazonaws.services.quicksight.model.GenerateEmbedUrlForRegisteredUserResult;
import com.amazonaws.services.quicksight.model.RegisteredUserEmbeddingExperienceConfiguration;
import com.amazonaws.services.quicksight.model.RegisteredUserQuickSightConsoleEmbeddingConfiguration;

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

    private final AmazonQuickSight quickSightClient;

    public GetQuicksightEmbedUrlRegisteredUserQSConsoleEmbedding() {
        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,
            final String userArn, // Registered user arn to use for embedding. Refer to Get Embed Url section in developer portal to find out how to get user arn for a QuickSight user.
            final List<String> allowedDomains, // Runtime allowed domain for embedding
            final String initialPath
    ) throws Exception {
        final RegisteredUserEmbeddingExperienceConfiguration experienceConfiguration = new RegisteredUserEmbeddingExperienceConfiguration()
                .withQuickSightConsole(new RegisteredUserQuickSightConsoleEmbeddingConfiguration().withInitialPath(initialPath));
        final GenerateEmbedUrlForRegisteredUserRequest generateEmbedUrlForRegisteredUserRequest = new GenerateEmbedUrlForRegisteredUserRequest();
        generateEmbedUrlForRegisteredUserRequest.setAwsAccountId(accountId);
        generateEmbedUrlForRegisteredUserRequest.setUserArn(userArn);
        generateEmbedUrlForRegisteredUserRequest.setAllowedDomains(allowedDomains);
        generateEmbedUrlForRegisteredUserRequest.setExperienceConfiguration(experienceConfiguration);

        final GenerateEmbedUrlForRegisteredUserResult generateEmbedUrlForRegisteredUserResult = quickSightClient.generateEmbedUrlForRegisteredUser(generateEmbedUrlForRegisteredUserRequest);

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

### JavaScript
<a name="embedded-analytics-full-console-for-authenticated-users-js"></a>

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

function generateEmbedUrlForRegisteredUser(
    accountId,
    dashboardId,
    openIdToken, // Cognito-based token
    userArn, // registered user arn
    roleArn, // IAM user role to use for embedding
    sessionName, // Session name for the roleArn assume role
    allowedDomains, // Runtime allowed domain for embedding
    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,
                "ExperienceConfiguration": {
                    "QuickSightConsole": {
                        "InitialPath": '/start'
                    }
                },
                "UserArn": userArn,
                "AllowedDomains": allowedDomains,
                "SessionLifetimeInMinutes": 600
            };

            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.generateEmbedUrlForRegisteredUser(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
<a name="embedded-analytics-full-console-for-authenticated-users-py"></a>

```
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: AWS account ID
# userArn: arn of registered user
# allowedDomains: Runtime allowed domain for embedding
# roleArn: IAM user role to use for embedding
# sessionName: session name for the roleArn assume role
def generateEmbeddingURL(accountId, userArn, allowedDomains, roleArn, sessionName):
    try:
        assumedRole = sts.assume_role(
            RoleArn = roleArn,
            RoleSessionName = sessionName,
        )
    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:
            quickSightClient = assumedRoleSession.client('quicksight', region_name='us-east-1')
            
            experienceConfiguration = {
                "QuickSightConsole": {
                    "InitialPath": "/start"
                }
            }
            response = quickSightClient.generate_embed_url_for_registered_user(
                 AwsAccountId = accountId,
                 ExperienceConfiguration = experienceConfiguration,
                 UserArn = userArn,
                 AllowedDomains = allowedDomains,
                 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:
            return "Error generating embedding url: " + str(e)
```

### Node.js
<a name="embedded-analytics-full-console-for-authenticated-users-node"></a>

L'esempio seguente mostra il file JavaScript (Node.js) che puoi usare sull'app server per generare 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 quicksightClient = new AWS.Service({
    apiConfig: require('./quicksight-2018-04-01.min.json'),
    region: 'us-east-1',
});

quicksightClient.generateEmbedUrlForRegisteredUser({
    'AwsAccountId': '111122223333',
    'ExperienceConfiguration': {
        'QuickSightConsole': {
            'InitialPath': '/start'
        }
    },
    'UserArn': 'REGISTERED_USER_ARN',
    'AllowedDomains': allowedDomains,
    'SessionLifetimeInMinutes': 100
}, 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://quicksightdomain/embed/12345/dashboards/67890..,
        RequestId: '7bee030e-f191-45c4-97fe-d9faf0e03713'
    }
```

### .NET/C\$1
<a name="embedded-analytics-full-console-for-authenticated-users-cs"></a>

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

**Example**  

```
using System;
using Amazon.QuickSight;
using Amazon.QuickSight.Model;

namespace GenerateDashboardEmbedUrlForRegisteredUser
{
    class Program
    {
        static void Main(string[] args)
        {
            var quicksightClient = new AmazonQuickSightClient(
                AccessKey,
                SecretAccessKey,
                SessionToken,
                Amazon.RegionEndpoint.USEast1);
            try
            {
                RegisteredUserQuickSightConsoleEmbeddingConfiguration registeredUserQuickSightConsoleEmbeddingConfiguration
                    = new RegisteredUserQuickSightConsoleEmbeddingConfiguration
                    {
                        InitialPath = "/start"
                    };
                RegisteredUserEmbeddingExperienceConfiguration registeredUserEmbeddingExperienceConfiguration
                    = new RegisteredUserEmbeddingExperienceConfiguration
                    {
                        QuickSightConsole = registeredUserQuickSightConsoleEmbeddingConfiguration
                    };
                
                Console.WriteLine(
                    quicksightClient.GenerateEmbedUrlForRegisteredUserAsync(new GenerateEmbedUrlForRegisteredUserRequest
                    {
                        AwsAccountId = "111122223333",
                        ExperienceConfiguration = registeredUserEmbeddingExperienceConfiguration,
                        UserArn = "REGISTERED_USER_ARN",
                        AllowedDomains = allowedDomains,
                        SessionLifetimeInMinutes = 100
                    }).Result.EmbedUrl
                );
            } catch (Exception ex) {
                Console.WriteLine(ex.Message);
            }
        }
    }
}
```

### AWS CLI
<a name="embedded-analytics-full-console-for-authenticated-users-cli"></a>

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)— Utilizza questa operazione quando utilizzi 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:GenerateEmbedUrlForRegisteredUser`. 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 l'[Amazon Quick Sight API Reference](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 `generate-embed-url-for-registered-user` dal server delle applicazioni. Ciò restituisce l'URL della sessione della console incorporabile. L'esempio seguente mostra come generare 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 generate-embed-url-for-registered-user \
    --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
	--allowed-domains '["domain1","domain2"]' \
    --experience-configuration QuickSightConsole={InitialPath="/start"}
```

Per ulteriori informazioni sull'utilizzo di questa operazione, consulta [https://docs.aws.amazon.com/quicksight/latest/APIReference/API_GenerateEmbedUrlForRegisteredUser.html](https://docs.aws.amazon.com/quicksight/latest/APIReference/API_GenerateEmbedUrlForRegisteredUser.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-step-3"></a>

Nella sezione seguente, puoi scoprire come utilizzare [Amazon Quick Sight Embedding SDK (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 `GenerateEmbedUrlForRegisteredUser` per generare l'URL da incorporare nella tua app. 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 `generate-embed-url-for-registered-user`.

```
//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://quicksightdomain/embedding/12345/start...",
     "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 dominio che ospiterà le dashboard integrate deve essere incluso nell'elenco dei domini *consentiti, l'elenco dei* domini approvati per l'abbonamento. Quick Questo requisito protegge i tuoi dati impedendo ai domini non approvati di ospitare pannelli di controllo incorporati. Per ulteriori informazioni sull'aggiunta di domini per una console integrata, consulta [Consentire la pubblicazione di domini in fase di esecuzione con l'API Amazon Quick Sight](https://docs.aws.amazon.com/quicksight/latest/user/embedding-run-time.html).

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

### SDK 2.0
<a name="embedded-analytics-full-console-for-authenticated-users-sdkv2"></a>

```
<!DOCTYPE html>
<html>

    <head>
        <title>Console Embedding Example</title>
        <script src="https://unpkg.com/amazon-quicksight-embedding-sdk@2.0.0/dist/quicksight-embedding-js-sdk.min.js"></script>
        <script type="text/javascript">
            const embedSession = async() => {    
                const {
                    createEmbeddingContext,
                } = QuickSightEmbedding;

                const embeddingContext = await createEmbeddingContext({
                    onChange: (changeEvent, metadata) => {
                        console.log('Context received a change', changeEvent, metadata);
                    },
                });

                const frameOptions = {
                    url: "<YOUR_EMBED_URL>", // replace this value with the url generated via embedding API
                    container: '#experience-container',
                    height: "700px",
                    width: "1000px",
                    onChange: (changeEvent, metadata) => {
                        switch (changeEvent.eventName) {
                            case 'FRAME_MOUNTED': {
                                console.log("Do something when the experience frame is mounted.");
                                break;
                            }
                            case 'FRAME_LOADED': {
                                console.log("Do something when the experience frame is loaded.");
                                break;
                            }
                        }
                    },
                };

                const contentOptions = {
                    onMessage: async (messageEvent, experienceMetadata) => {
                        switch (messageEvent.eventName) {
                            case 'ERROR_OCCURRED': {
                                console.log("Do something when the embedded experience fails loading.");
                                break;
                            }
                        }
                    }
                };
                const embeddedConsoleExperience = await embeddingContext.embedConsole(frameOptions, contentOptions);
            };
        </script>
    </head>

    <body onload="embedSession()">
        <div id="experience-container"></div>
    </body>

</html>
```

### SDK 1.0
<a name="embedded-analytics-full-console-for-authenticated-users-sdkv1"></a>

```
<!DOCTYPE html>
<html>

    <head>
        <title>QuickSight Console Embedding</title>
        <script src="https://unpkg.com/amazon-quicksight-embedding-sdk@1.0.15/dist/quicksight-embedding-js-sdk.min.js"></script>
        <script type="text/javascript">
            var session

            function onError(payload) {
                console.log("Do something when the session fails loading");
            }

            function embedSession() {
                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", // replace this dummy url with the one generated via embedding API
                    container: containerDiv,
                    parameters: {
                        country: "United States"
                    },
                    scrolling: "no",
                    height: "700px",
                    width: "1000px",
                    locale: "en-US",
                    footerPaddingEnabled: true,
                    defaultEmbeddingVisualType: "TABLE", // this option only applies to QuickSight console embedding and is not used for dashboard embedding
                };
                session = QuickSightEmbedding.embedSession(options);
                session.on("error", onError);
            }

            function onCountryChange(obj) {
                session.setParameters({country: obj.value});
            }
        </script>
    </head>

    <body onload="embedSession()">
        <span>
            <label for="country">Country</label>
            <select id="country" name="country" onchange="onCountryChange(this)">
                <option value="United States">United States</option>
                <option value="Mexico">Mexico</option>
                <option value="Canada">Canada</option>
            </select>
        </span>
        <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'[Amazon Quick Sight Embedding SDK](https://github.com/awslabs/amazon-quicksight-embedding-sdk#step-3-create-the-quicksight-session-object) da. GitHub Questo repository è gestito da un gruppo di sviluppatori 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
  ```

# Abilitazione delle funzionalità di BI generativa nelle console incorporate per gli utenti registrati
<a name="embedding-consoles-genbi"></a>


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


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

È possibile abilitare le seguenti funzionalità di BI generativa nella console incorporata:
+ Riepiloghi esecutivi: se abilitati, gli utenti registrati di Author Pro e Reader Pro possono generare riepiloghi esecutivi che forniscono un riepilogo di tutte le informazioni che Amazon Quick Sight ha generato per la dashboard per scoprire facilmente le informazioni chiave.
+ Creazione: se abilitata, gli utenti Author Pro possono utilizzare la BI generativa per creare campi calcolati e creare e perfezionare elementi visivi.
+ Domande e risposte: se abilitata, gli utenti Author Pro e Reader Pro possono utilizzare le domande e risposte basate sull'intelligenza artificiale per suggerire e rispondere a domande relative ai propri dati.
+ Storie di dati: se abilitate, gli utenti Author Pro e Reader Pro possono fornire dettagli per generare rapidamente una prima bozza della loro storia di dati.

**Per abilitare le funzionalità di BI generativa nelle console incorporate per gli utenti registrati**
+ Segui la procedura descritta in [Incorporare la piena funzionalità della console Amazon Quick Sight per gli utenti registrati per](https://docs.aws.amazon.com/quicksight/latest/user/embedded-analytics-full-console-for-authenticated-users.html) incorporare una console con le seguenti modifiche:

  1. Quando generi l'URL nella fase 2, imposta `Enabled: true` il `FeatureConfigurations` parametro per ciascuna delle funzionalità che desideri abilitare in [GenerateEmbedUrlForRegisteredUser](https://docs.aws.amazon.com/quicksight/latest/APIReference/API_GenerateEmbedUrlForRegisteredUser.html)o [GenerateEmbedUrlForRegisteredUserWithIdentity](https://docs.aws.amazon.com/quicksight/latest/APIReference/API_GenerateEmbedUrlForRegisteredUserWithIdentity.html) APIs, come mostrato nell'esempio seguente. Se non viene fornita alcuna configurazione, le funzionalità sono disabilitate per impostazione predefinita.

     ```
     ExperienceConfiguration: {
             QuickSightConsole: {
                 InitialPath: "initial_path",
                 AmazonQInQuickSight: {
                     FeatureConfigurations: { 
                         COMMENT: Enable executive summaries
                         ExecutiveSummary: {
                             Enabled: true
                         },
                         COMMENT: Enable Generative BI authoring
                         GenerativeAuthoring: {
                             Enabled: true
                         },
                         COMMENT: Enable Q&A
                         DataQnA: {
                             Enabled: true
                         },
                         COMMENT: Enable data stories
                         DataStories: {
                             Enabled: true
                         }       
                     }
                 }
             }
         }
     }
     ```

  1. Quando incorpori l'URL della console con Amazon Quick Sight Embedding SDK nella fase 3, imposta i valori nell'esempio seguente come desideri. Se non viene fornita alcuna configurazione, le funzionalità sono disabilitate per impostazione predefinita.
**Nota**  
Non esiste alcuna opzione SDK per abilitare le storie di dati. Se le storie di dati sono abilitate con l'API come mostrato nel passaggio precedente, saranno disponibili per gli utenti registrati.

     ```
     const contentOptions = {
         toolbarOptions: {
             executiveSummary: true, // Enable executive summaries
             buildVisual: true, // Enable Generative BI authoring
             dataQnA: true // Enable Q&A
         }
     };
     ```

# Integrazione di Amazon Q nell'esperienza di domande e risposte generative di Amazon Quick Sight
<a name="embedding-gen-bi"></a>


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

Nelle sezioni seguenti, puoi trovare informazioni dettagliate su come configurare un'esperienza di domande e risposte generative integrata che utilizzi funzionalità NLQ avanzate fornite da. LLMs L'esperienza Domande e risposte generative è il sostituto consigliato della barra di ricerca Q incorporata e offre agli utenti un'esperienza di BI aggiornata.

**Topics**
+ [

## Integrazione di Amazon Q nell'esperienza di domande e risposte generative di Amazon Quick Sight per utenti registrati
](#embedded-analytics-gen-bi-authenticated-users)
+ [

## Integrazione di Amazon Q nell'esperienza di domande e risposte generative rapide per utenti anonimi (non registrati)
](#embedded-analytics-gen-bi-anonymous-users)

## Integrazione di Amazon Q nell'esperienza di domande e risposte generative di Amazon Quick Sight per utenti registrati
<a name="embedded-analytics-gen-bi-authenticated-users"></a>

Nelle sezioni seguenti, puoi trovare informazioni dettagliate su come configurare un'esperienza di domande e risposte generative integrata per gli utenti registrati di Amazon Quick Sight.

**Topics**
+ [

### Fase 1: Configurazione delle autorizzazioni
](#embedded-analytics-gen-bi-authenticated-users-step-1)
+ [

### Fase 2: Generazione dell'URL con il codice di autenticazione allegato
](#embedded-analytics-gen-bi-authenticated-users-step-2)
+ [

### Passaggio 3: Incorporare l'URL dell'esperienza Domande e risposte generative
](#embedded-analytics-gen-bi-authenticated-users-step-3)
+ [

### Funzionalità facoltative incorporate per l'esperienza di domande e risposte generative
](#embedded-analytics-gen-bi-authenticated-users-step-4)

### Fase 1: Configurazione delle autorizzazioni
<a name="embedded-analytics-gen-bi-authenticated-users-step-1"></a>

Nella sezione seguente, puoi scoprire come configurare autorizzazioni per l'applicazione di backend o server Web per incorporare l'esperienza Domande e risposte generative. Questa attività richiede l'accesso amministrativo a AWS Identity and Access Management (IAM).

Ogni utente che accede a un'esperienza di domande e risposte generative assume un ruolo che gli conferisce l'accesso e le autorizzazioni di Amazon Quick Sight. Per far ciò, crea un ruolo IAM nell' 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 l'incorporamento per un pool di utenti specifico. URLs 

Con l'aiuto del carattere jolly *\$1*, puoi concedere le autorizzazioni per generare un URL per tutti gli utenti in uno spazio dei nomi specifico. Oppure puoi concedere le autorizzazioni per generare un URL per un sottoinsieme di utenti in spazi dei nomi specifici. Per questo, aggiungi `quicksight:GenerateEmbedUrlForRegisteredUser`.

Puoi creare una condizione nella tua policy IAM che limiti i domini che gli sviluppatori possono elencare nel parametro `AllowedDomains` di un'operazione API `GenerateEmbedUrlForRegisteredUser`. Il parametro `AllowedDomains` è un parametro facoltativo. Offre agli sviluppatori la possibilità di sovrascrivere i domini statici configurati nel menu Manage **Amazon Quick Sight** e di elencare invece fino a tre domini o sottodomini che possono accedere a un URL generato. Questo URL viene quindi incorporato nel sito web di uno sviluppatore. Solo i domini elencati nel parametro possono accedere all'esperienza Domande e risposte generative incorporata. Senza questa condizione, gli sviluppatori possono elencare nel parametro `AllowedDomains` qualsiasi dominio su Internet. 

Per limitare i domini che gli sviluppatori possono utilizzare con questo parametro, aggiungi una condizione `AllowedEmbeddingDomains` alla tua policy IAM. Per ulteriori informazioni sul `AllowedDomains` parametro, consulta [GenerateEmbedUrlForRegisteredUser](https://docs.aws.amazon.com//quicksight/latest/APIReference/API_GenerateEmbedUrlForRegisteredUser.html)*Amazon Quick Sight API Reference*.

**Best practice di sicurezza per gli operatori di condizioni IAM**  
Gli operatori di condizioni IAM configurati in modo errato possono consentire l'accesso non autorizzato alle risorse Quick incorporate tramite variazioni di URL. Quando utilizzi la chiave `quicksight:AllowedEmbeddingDomains` condition nelle tue policy IAM, utilizza operatori di condizione che consentano domini specifici o neghino tutti i domini che non sono specificamente consentiti. Per ulteriori informazioni sugli operatori di condizioni IAM, consulta [IAM JSON Policy elements: Condition operators](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_elements_condition_operators.html) nella IAM User Guide.  
Molte varianti di URL diverse possono puntare alla stessa risorsa. Ad esempio, i seguenti elementi si risolvono URLs tutti allo stesso contenuto:  
`https://example.com`
`https://example.com/`
`https://Example.com`
Se la tua politica utilizza operatori che non tengono conto di queste variazioni di URL, un utente malintenzionato può aggirare le tue restrizioni fornendo varianti URL equivalenti.  
Devi verificare che la tua policy IAM utilizzi operatori di condizioni appropriati per evitare di aggirare le vulnerabilità e garantire che solo i domini previsti possano accedere alle tue risorse incorporate.

Queste autorizzazioni sono fornite dalla seguente policy di esempio.

Inoltre, se stai creando utenti alle prime armi che saranno lettori di Amazon Quick Sight, assicurati di aggiungere l'`quicksight:RegisterUser`autorizzazione nella policy.

La seguente politica di esempio fornisce l'autorizzazione a recuperare un URL di incorporamento per gli utenti alle prime armi che devono essere lettori di Amazon Quick Sight.

Infine, è 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. 

Di seguito è mostrata una policy di attendibilità di esempio.

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

****  

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

------

Per ulteriori informazioni sulle policy di attendibilità 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: Generazione dell'URL con il codice di autenticazione allegato
<a name="embedded-analytics-gen-bi-authenticated-users-step-2"></a>

Nella sezione seguente, è possibile scoprire come autenticare l'utente e ottenere l'URL dell'argomento Q incorporabile nel server delle applicazioni. Se prevedi di incorporare l'esperienza di domande e risposte generative per i tipi di identità IAM o Amazon Quick Sight, condividi l'argomento Q con gli utenti.

Quando un utente accede all'applicazione, l'applicazione assume il ruolo IAM per conto dell'utente. Quindi l'app 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 dell'argomento Q 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. La sicurezza a livello di riga basata su tag può essere utilizzata per l'incorporamento della barra Q da parte di utenti anonimi.

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

#### Java
<a name="embedded-analytics-gen-bi-authenticated-users-java"></a>

```
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.GenerateEmbedUrlForRegisteredUserRequest;
import com.amazonaws.services.quicksight.model.GenerateEmbedUrlForRegisteredUserResult;
import com.amazonaws.services.quicksight.model.RegisteredUserEmbeddingExperienceConfiguration;
import com.amazonaws.services.quicksight.model.RegisteredUserGenerativeQnAEmbeddingConfiguration;

/**
 * Class to call QuickSight AWS SDK to get url for embedding Generative Q&A experience.
 */
public class RegisteredUserGenerativeQnAEmbeddingSample {

    private final AmazonQuickSight quickSightClient;

    public RegisteredUserGenerativeQnAEmbeddingSample() {
        this.quickSightClient = AmazonQuickSightClientBuilder
                    .standard()
                    .withRegion(Regions.US_EAST_1.getName())
                    .withCredentials(new AWS CredentialsProvider() {
                            @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, // AWS Account ID
            final String topicId, // Topic ID to embed
            final List<String> allowedDomains, // Runtime allowed domain for embedding
            final String userArn // Registered user arn to use for embedding. Refer to Get Embed Url section in developer portal to find how to get user arn for a QuickSight user.
            ) throws Exception {

        final RegisteredUserEmbeddingExperienceConfiguration experienceConfiguration = new RegisteredUserEmbeddingExperienceConfiguration()
                .withGenerativeQnA(new RegisteredUserGenerativeQnAEmbeddingConfiguration().withInitialTopicId(topicId));
        final GenerateEmbedUrlForRegisteredUserRequest generateEmbedUrlForRegisteredUserRequest = new GenerateEmbedUrlForRegisteredUserRequest();
        generateEmbedUrlForRegisteredUserRequest.setAwsAccountId(accountId);
        generateEmbedUrlForRegisteredUserRequest.setUserArn(userArn);
        generateEmbedUrlForRegisteredUserRequest.setAllowedDomains(allowedDomains);
        generateEmbedUrlForRegisteredUserRequest.setExperienceConfiguration(experienceConfiguration);

        final GenerateEmbedUrlForRegisteredUserResult generateEmbedUrlForRegisteredUserResult = quickSightClient.generateEmbedUrlForRegisteredUser(generateEmbedUrlForRegisteredUserRequest);

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

#### JavaScript
<a name="embedded-analytics-gen-bi-authenticated-users-js"></a>

**Nota**  
La generazione di URL incorporati APIs non può essere richiamata direttamente dai browser. Fai invece riferimento all'esempio Node.JS.

#### Python3
<a name="embedded-analytics-gen-bi-authenticated-users-py"></a>

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

sts = boto3.client('sts')

# Function to generate embedded URL  
# accountId: AWS account ID
# topicId: Topic ID to embed
# userArn: arn of registered user
# allowedDomains: Runtime allowed domain for embedding
# roleArn: IAM user role to use for embedding
# sessionName: session name for the roleArn assume role
def getEmbeddingURL(accountId, topicId, userArn, allowedDomains, roleArn, sessionName):
    try:
        assumedRole = sts.assume_role(
            RoleArn = roleArn,
            RoleSessionName = sessionName,
        )
    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:
            quicksightClient = assumedRoleSession.client('quicksight', region_name='us-west-2')
            response = quicksightClient.generate_embed_url_for_registered_user(
                AwsAccountId=accountId,
                ExperienceConfiguration = {
                    'GenerativeQnA': {
                        'InitialTopicId': topicId
                    }
                },
                UserArn = userArn,
                AllowedDomains = allowedDomains,
                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:
            return "Error generating embedding url: " + str(e)
```

#### Node.js
<a name="embedded-analytics-gen-bi-authenticated-users-node"></a>

L'esempio seguente mostra JavaScript (Node.js) che è possibile utilizzare sul server dell'app per generare l'URL per la 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 quicksightClient = new AWS.Service({
    region: 'us-east-1'
});

quicksightClient.generateEmbedUrlForRegisteredUser({
    'AwsAccountId': '111122223333',
    'ExperienceConfiguration': { 
        'GenerativeQnA': {
            'InitialTopicId': 'U4zJMVZ2n2stZflc8Ou3iKySEb3BEV6f'
        }
    },
    'UserArn': 'REGISTERED_USER_ARN',
    'AllowedDomains': allowedDomains,
    'SessionLifetimeInMinutes': 100
}, function(err, data) {
    console.log('Errors: ');
    console.log(err);
    console.log('Response: ');
    console.log(data);
});
```

#### .NET/C\$1
<a name="embedded-analytics-gen-bi-authenticated-users-cs"></a>

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

**Example**  

```
using System;
using Amazon.QuickSight;
using Amazon.QuickSight.Model;

namespace GenerateGenerativeQnAEmbedUrlForRegisteredUser
{
    class Program
    {
        static void Main(string[] args)
        {
            var quicksightClient = new AmazonQuickSightClient(
                AccessKey,
                SecretAccessKey,
                SessionToken,
                Amazon.RegionEndpoint.USEast1);
            try
            {
                RegisteredUserGenerativeQnAEmbeddingConfiguration registeredUserGenerativeQnAEmbeddingConfiguration
                    = new RegisteredUserGenerativeQnAEmbeddingConfiguration
                    {
                        InitialTopicId = "U4zJMVZ2n2stZflc8Ou3iKySEb3BEV6f"
                    };
                RegisteredUserEmbeddingExperienceConfiguration registeredUserEmbeddingExperienceConfiguration
                    = new RegisteredUserEmbeddingExperienceConfiguration
                    {
                        GenerativeQnA = registeredUserGenerativeQnAEmbeddingConfiguration
                    }; 
                
                Console.WriteLine(
                    quicksightClient.GenerateEmbedUrlForRegisteredUserAsync(new GenerateEmbedUrlForRegisteredUserRequest
                    {
                        AwsAccountId = "111122223333",
                        ExperienceConfiguration = registeredUserEmbeddingExperienceConfiguration,
                        UserArn = "REGISTERED_USER_ARN",
                        AllowedDomains = allowedDomains,
                        SessionLifetimeInMinutes = 100
                    }).Result.EmbedUrl
                );
            } catch (Exception ex) {
                Console.WriteLine(ex.Message);
            }
        }
    }
}
```

#### AWS CLI
<a name="embedded-analytics-gen-bi-authenticated-users-cli"></a>

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:GenerateEmbedUrlForRegisteredUser`. Se stai adottando un just-in-time approccio per aggiungere utenti quando utilizzano un argomento nella barra di ricerca Q, anche per il ruolo è necessario abilitare le autorizzazioni. `quicksight:RegisterUser`

```
aws sts assume-role \
     --role-arn "arn:aws:iam::111122223333:role/embedding_quicksight_q_generative_qna_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. Per 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_q_search_bar_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 fornire i tuoi utenti in Amazon Quick Sight in anticipo o per effettuare il provisioning la prima volta che accedono all'esperienza di domande e risposte generative. 

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_q_generative_qna_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 il nome della risorsa Amazon (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_q_generative_qna_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 `generate-embed-url-for-registered-user` dal server delle applicazioni. Questo restituisce l'URL del pannello di controllo incorporato. L'esempio seguente mostra come generare l'URL per una dashboard incorporata utilizzando una chiamata lato server per utenti autenticati tramite AWS Managed Microsoft AD o Single Sign-On (IAM Identity Center).

```
aws quicksight generate-embed-url-for-anonymous-user \
--aws-account-id 111122223333 \
--namespace default-or-something-else \
--authorized-resource-arns '["topic-arn-topicId1","topic-arn-topicId2"]' \
--allowed-domains '["domain1","domain2"]' \
--experience-configuration 'GenerativeQnA={InitialTopicId="topicId1"}' \
--session-tags '["Key": tag-key-1,"Value": tag-value-1,{"Key": tag-key-1,"Value": tag-value-1}]' \
--session-lifetime-in-minutes 15
```

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

### Passaggio 3: Incorporare l'URL dell'esperienza Domande e risposte generative
<a name="embedded-analytics-gen-bi-authenticated-users-step-3"></a>

Nella sezione seguente, puoi scoprire come incorporare l'URL dell'esperienza Domande e risposte generative nella pagina del sito web o dell'applicazione. Puoi farlo con l'[SDK di incorporamento di Amazon Quick Sight](https://www.npmjs.com/package/amazon-quicksight-embedding-sdk) ()JavaScript. Con il kit SDK, puoi procedere come segue: 
+ Posiziona l'esperienza Domande e risposte generative su una pagina HTML.
+ Personalizza il layout e l'aspetto dell'esperienza incorporata per adattarla alle esigenze delle tue applicazioni.
+ Gestisci stati di errore con messaggi personalizzati per l'applicazione.

Chiama l'operazione API `GenerateEmbedUrlForRegisteredUser` per generare 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 valore `auth_code` che consente una sessione di single sign-on. 

Di seguito viene mostrata una risposta di esempio da `generate-embed-url-for-registered-user`.

```
//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://quicksightdomain/embedding/12345/q/search...",
"RequestId": "7bee030e-f191-45c4-97fe-d9faf0e03713"
}
```

Incorpora l'esperienza di domande e risposte generative nella tua pagina web utilizzando l'[SDK di incorporamento Amazon Quick Sight o aggiungendo questo](https://www.npmjs.com/package/amazon-quicksight-embedding-sdk) 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. 

Assicurati che il dominio su cui ospitare l'esperienza di domande e risposte generative incorporata sia nell'elenco dei domini *consentiti, l'elenco dei* domini approvati per il tuo abbonamento Amazon Quick Sight. Questo requisito protegge i tuoi dati impedendo ai domini non approvati di ospitare pannelli di controllo incorporati. Per ulteriori informazioni sull'aggiunta di domini per un'esperienza Domande e risposte generative incorporata, consulta [Gestione dei domini](manage-domains.md).

Puoi utilizzare Amazon Quick Sight Embedding SDK per personalizzare il layout e l'aspetto dell'esperienza di domande e risposte generative incorporata in base alla tua applicazione. Utilizza la proprietà `panelType` per configurare lo stato di destinazione dell'esperienza Domande e risposte generative quando viene visualizzata nella tua applicazione. Imposta la proprietà `panelType` su `'FULL'` per visualizzare l'intero pannello dell'esperienza Domande e risposte generative. Questo pannello è simile all'esperienza che gli utenti di Amazon Quick Sight hanno nella console Amazon Quick Sight. L'altezza della cornice del pannello non viene modificata in base all'interazione dell'utente e rispetta il valore impostato nella proprietà `frameOptions.height`. L'immagine seguente mostra il pannello dell'esperienza di domande e risposte generative che viene renderizzato quando imposti il valore `panelType` su `'FULL'`.

Imposta la proprietà `panelType` su `'SEARCH_BAR'` per rendere l'esperienza di domande e risposte generative come barra di ricerca. Questa barra di ricerca è simile al modo in cui viene visualizzata la barra di ricerca Q quando è incorporata in un'applicazione. La barra di ricerca di Domande e risposte generative si espande in un pannello più grande che mostra le opzioni di selezione degli argomenti, l'elenco dei suggerimenti di domande, il pannello delle risposte o la bacheca.

L'altezza minima predefinita della barra di ricerca di Domande e risposte generative viene visualizzata al caricamento delle risorse incorporate. Si consiglia di impostare il valore `frameOptions.height` su `"38px"` per ottimizzare l'esperienza della barra di ricerca. Utilizza la proprietà `focusedHeight` per impostare la dimensione ottimale del menu a discesa per la selezione degli argomenti e dell'elenco di suggerimenti per le domande. Utilizza la proprietà `expandedHeight` per impostare la dimensione ottimale del pannello delle risposte e della bacheca. Se sceglie l'opzione `'SEARCH_BAR'`, si consiglia di assegnare al container padre lo stile position; lo stile absolute è per evitare spostamenti indesiderati del contenuto nell'applicazione. L'immagine seguente mostra la barra di ricerca dell'esperienza di domande e risposte generative che viene renderizzato quando imposti il valore `panelType` su `'SEARCH_BAR'`.

Dopo aver configurato la `panelType` proprietà, utilizza l'SDK di incorporamento Amazon Quick Sight per personalizzare le seguenti proprietà dell'esperienza di domande e risposte generative.
+ Il titolo del pannello Domande e risposte generative (si applica solo all'opzione `panelType: FULL`). 
+ Il testo del segnaposto della barra di ricerca.
+ Se la selezione dell'argomento è consentita.
+ Se i nomi degli argomenti sono visualizzati o nascosti.
+ Se l'icona di Amazon Q è visualizzata o nascosta (si applica solo all'opzione `panelType: FULL`).
+ Se la bacheca è visualizzata o nascosta.
+ Se gli utenti possono ingrandire il pannello Domande e risposte generative a tutto schermo.
+ Il tema del pannello Domande e risposte generative. È possibile passare un ARN del tema personalizzato nell'SDK per modificare l'aspetto del contenuto del riquadro. I temi iniziali di Amazon Quick Sight non sono supportati per i pannelli di BI generativa incorporati. Per utilizzare un tema iniziale di Amazon Quick Sight, salvalo come tema personalizzato in Amazon Quick Sight.

Quando usi Amazon Quick Sight Embedding SDK, l'esperienza di domande e risposte generative sulla tua pagina viene ridimensionata dinamicamente in base allo stato. Utilizzando Amazon Quick Sight Embedding SDK, puoi anche controllare i parametri all'interno dell'esperienza di domande e risposte generative e ricevere callback in termini di completamento del caricamento della pagina, modifiche di stato ed errori. 

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

#### SDK 2.0
<a name="collapsible-gen-bi-embedding-example"></a>

```
<!DOCTYPE html>
<html>
    <head>
        <title>Generative Q&A Embedding Example</title>
        <script src="https://unpkg.com/amazon-quicksight-embedding-sdk@2.7.0/dist/quicksight-embedding-js-sdk.min.js"></script>
        <script type="text/javascript">
            const embedGenerativeQnA = async() => {    
                const {createEmbeddingContext} = QuickSightEmbedding;

                const embeddingContext = await createEmbeddingContext({
                    onChange: (changeEvent, metadata) => {
                        console.log('Context received a change', changeEvent, metadata);
                    },
                });

                const frameOptions = {
                    url: "<YOUR_EMBED_URL>", // replace this value with the url generated via embedding API
                    container: '#experience-container',
                    height: "700px",
                    width: "1000px",
                    onChange: (changeEvent, metadata) => {
                        switch (changeEvent.eventName) {
                            case 'FRAME_MOUNTED': {
                                console.log("Do something when the experience frame is mounted.");
                                break;
                            }
                            case 'FRAME_LOADED': {
                                console.log("Do something when the experience frame is loaded.");
                                break;
                            }
                        }
                    },
                };

                const contentOptions = {
                    // Optional panel settings. Default behavior is equivalent to {panelType: 'FULL'}
                    panelOptions: {
                        panelType: 'FULL',
                        title: 'custom title', // Optional
                        showQIcon: false, // Optional, Default: true
                    },
                    // Use SEARCH_BAR panel type for the landing state to be similar to embedQSearchBar
                    // with generative capability enabled topics
                    /*
                    panelOptions: {
                        panelType: 'SEARCH_BAR',
                        focusedHeight: '250px',
                        expandedHeight: '500px',
                    },
                    */
                    showTopicName: false, // Optional, Default: true
                    showPinboard: false, // Optional, Default: true
                    allowTopicSelection: false, // Optional, Default: true
                    allowFullscreen: false, // Optional, Default: true
                    searchPlaceholderText: "custom search placeholder", // Optional
                    themeOptions: { // Optional
                        themeArn: 'arn:aws:quicksight:<Region>:<AWS-Account-ID>:theme/<Theme-ID>'
                    }
                    onMessage: async (messageEvent, experienceMetadata) => {
                        switch (messageEvent.eventName) {
                            case 'Q_SEARCH_OPENED': {
                                // called when pinboard is shown / visuals are rendered
                                console.log("Do something when SEARCH_BAR type panel is expanded");
                                break;
                            }
                            case 'Q_SEARCH_FOCUSED': {
                                // called when question suggestions or topic selection dropdown are shown
                                console.log("Do something when SEARCH_BAR type panel is focused");
                                break;
                            }
                            case 'Q_SEARCH_CLOSED': {
                                // called when shrinked to initial bar height
                                console.log("Do something when SEARCH_BAR type panel is collapsed");
                                break;
                            }
                            case 'Q_PANEL_ENTERED_FULLSCREEN': {
                                console.log("Do something when panel enters full screen mode");
                                break;
                            }
                            case 'Q_PANEL_EXITED_FULLSCREEN': {
                                console.log("Do something when panel exits full screen mode");
                                break;
                            }
                            case 'CONTENT_LOADED': {
                                console.log("Do something after experience is loaded");
                                break;
                            }
                            case 'ERROR_OCCURRED': {
                                console.log("Do something when experience fails to load");
                                break;
                            }
                        }
                    }
                };
                const embeddedGenerativeQnExperience = await embeddingContext.embedGenerativeQnA(frameOptions, contentOptions);
            };
        </script>
    </head>

    <body onload="embedGenerativeQnA()">
        <div id="experience-container"></div>
    </body>

</html>
```

Affinché questo esempio funzioni, assicurati di utilizzare l'SDK Amazon Quick Sight Embedding per caricare l'esperienza di domande e risposte generative incorporata sul tuo sito web. 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 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
  ```

### Funzionalità facoltative incorporate per l'esperienza di domande e risposte generative
<a name="embedded-analytics-gen-bi-authenticated-users-step-4"></a>

Le seguenti funzionalità facoltative sono disponibili per l'esperienza Domande e risposte generative incorporata utilizzando l'SDK di incorporamento. 

#### Invocare le azioni della barra di ricerca di Domande e risposte generative
<a name="w2aac35c27c21c43c29b9c21b5"></a>
+ Imposta una domanda: questa funzionalità invia una domanda all'esperienza Domande e risposte generative e interroga immediatamente la domanda.

  ```
  embeddedGenerativeQnExperience.setQuestion('show me monthly revenue');
  ```
+ Chiudi il pannello delle risposte (si applica all'opzione della barra di ricerca Domande e risposte generative): questa funzionalità chiude il pannello delle risposte e riporta l'iframe allo stato originale della barra di ricerca.

  ```
  embeddedGenerativeQnExperience.close();
  ```

Per ulteriori informazioni, consulta l'[SDK di incorporamento di Amazon Quick Sight](https://github.com/awslabs/amazon-quicksight-embedding-sdk).

## Integrazione di Amazon Q nell'esperienza di domande e risposte generative rapide per utenti anonimi (non registrati)
<a name="embedded-analytics-gen-bi-anonymous-users"></a>


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

Nelle sezioni seguenti sono riportate le informazioni dettagliate su come configurare un'esperienza Domande e risposte generative incorporata per gli utenti anonimi (non registrati).

**Topics**
+ [

### Fase 1: Configurazione delle autorizzazioni
](#embedded-analytics-gen-bi-anonymous-users-step-1)
+ [

### Fase 2: Generazione dell'URL con il codice di autenticazione allegato
](#embedded-analytics-gen-bi-anonymous-users-step-2)
+ [

### Passaggio 3: Incorporare l'URL dell'esperienza Domande e risposte generative
](#embedded-analytics-gen-bi-anonymous-users-step-3)
+ [

### Funzionalità facoltative incorporate per l'esperienza di domande e risposte generative
](#embedded-analytics-gen-bi-anonymous-users-step-4)

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

Nella sezione seguente, puoi scoprire come configurare autorizzazioni per l'applicazione di backend o server Web per incorporare l'esperienza Domande e risposte generative. Questa attività richiede l'accesso amministrativo a AWS Identity and Access Management (IAM).

Ogni utente che accede a un'esperienza di domande e risposte generative assume un ruolo che gli conferisce l'accesso e le autorizzazioni di Amazon Quick Sight. Per far ciò, crea un ruolo IAM nell' 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 l'incorporamento per un pool di utenti specifico. URLs 

Con l'aiuto del carattere jolly *\$1*, puoi concedere le autorizzazioni per generare un URL per tutti gli utenti in uno spazio dei nomi specifico. Oppure puoi concedere le autorizzazioni per generare un URL per un sottoinsieme di utenti in spazi dei nomi specifici. Per questo, aggiungi `quicksight:GenerateEmbedUrlForAnonymousUser`.

Puoi creare una condizione nella tua policy IAM che limiti i domini che gli sviluppatori possono elencare nel parametro `AllowedDomains` di un'operazione API `GenerateEmbedUrlForAnonymousUser`. Il parametro `AllowedDomains` è un parametro facoltativo. Offre agli sviluppatori la possibilità di sovrascrivere i domini statici configurati nel menu Manage **Amazon Quick Sight** e di elencare invece fino a tre domini o sottodomini che possono accedere a un URL generato. Questo URL viene quindi incorporato nel sito web di uno sviluppatore. Solo i domini elencati nel parametro possono accedere alla barra di ricerca Q incorporata. Senza questa condizione, gli sviluppatori possono elencare nel parametro `AllowedDomains` qualsiasi dominio su Internet. 

Per limitare i domini che gli sviluppatori possono utilizzare con questo parametro, aggiungi una condizione `AllowedEmbeddingDomains` alla tua policy IAM. Per ulteriori informazioni sul `AllowedDomains` parametro, consulta [GenerateEmbedUrlForAnonymousUser](https://docs.aws.amazon.com//quicksight/latest/APIReference/API_GenerateEmbedUrlForAnonymousUser.html)*Amazon Quick Sight API Reference*.

**Best practice di sicurezza per gli operatori di condizioni IAM**  
Gli operatori di condizioni IAM configurati in modo errato possono consentire l'accesso non autorizzato alle risorse Quick incorporate tramite variazioni di URL. Quando utilizzi la chiave `quicksight:AllowedEmbeddingDomains` condition nelle tue policy IAM, utilizza operatori di condizione che consentano domini specifici o neghino tutti i domini che non sono specificamente consentiti. Per ulteriori informazioni sugli operatori di condizioni IAM, consulta [IAM JSON Policy elements: Condition operators](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_elements_condition_operators.html) nella IAM User Guide.  
Molte varianti di URL diverse possono puntare alla stessa risorsa. Ad esempio, i seguenti elementi si risolvono URLs tutti allo stesso contenuto:  
`https://example.com`
`https://example.com/`
`https://Example.com`
Se la tua politica utilizza operatori che non tengono conto di queste variazioni di URL, un utente malintenzionato può aggirare le tue restrizioni fornendo varianti URL equivalenti.  
Devi verificare che la tua policy IAM utilizzi operatori di condizioni appropriati per evitare di aggirare le vulnerabilità e garantire che solo i domini previsti possano accedere alle tue risorse incorporate.

È 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 caricare l'esperienza Domande e risposte generative. Di seguito è mostrata una policy di attendibilità di esempio.

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

****  

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

------

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: Generazione dell'URL con il codice di autenticazione allegato
<a name="embedded-analytics-gen-bi-anonymous-users-step-2"></a>

Nella sezione seguente, è possibile scoprire come autenticare l'utente e ottenere l'URL dell'argomento Q incorporabile nel server delle applicazioni.

Quando un utente accede all'applicazione, l'applicazione assume il ruolo IAM per conto dell'utente. Quindi l'app 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. 

#### Java
<a name="embedded-analytics-gen-bi-anonymous-users-java"></a>

```
import java.util.List;
import com.amazonaws.auth.AWSCredentials;
import com.amazonaws.auth.AWSCredentialsProvider;
import com.amazonaws.auth.BasicAWSCredentials;
import com.amazonaws.regions.Regions;
import com.amazonaws.services.quicksight.AmazonQuickSight;
import com.amazonaws.services.quicksight.AmazonQuickSightClientBuilder;
import com.amazonaws.services.quicksight.model.AnonymousUserGenerativeQnAEmbeddingConfiguration;
import com.amazonaws.services.quicksight.model.AnonymousUserEmbeddingExperienceConfiguration;
import com.amazonaws.services.quicksight.model.GenerateEmbedUrlForAnonymousUserRequest;
import com.amazonaws.services.quicksight.model.GenerateEmbedUrlForAnonymousUserResult;
import com.amazonaws.services.quicksight.model.SessionTag;

/**
* Class to call QuickSight AWS SDK to generate embed url for anonymous user.
*/
public class GenerateEmbedUrlForAnonymousUserExample {

    private final AmazonQuickSight quickSightClient;

    public GenerateEmbedUrlForAnonymousUserExample() {
        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 GenerateEmbedUrlForAnonymousUser(
        final String accountId, // YOUR AWS ACCOUNT ID
        final String initialTopicId, // Q TOPIC ID TO WHICH THE CONSTRUCTED URL POINTS AND EXPERIENCE PREPOPULATES INITIALLY
        final String namespace, // ANONYMOUS EMBEDDING REQUIRES SPECIFYING A VALID NAMESPACE FOR WHICH YOU WANT THE EMBEDDING URL
        final List<String> authorizedResourceArns, // Q TOPIC ARN LIST TO EMBED
        final List<String> allowedDomains, // RUNTIME ALLOWED DOMAINS FOR EMBEDDING
        final List<SessionTag> sessionTags // SESSION TAGS USED FOR ROW-LEVEL SECURITY
    ) throws Exception {
        AnonymousUserEmbeddingExperienceConfiguration experienceConfiguration = new AnonymousUserEmbeddingExperienceConfiguration();
        AnonymousUserGenerativeQnAEmbeddingConfiguration generativeQnAConfiguration = new AnonymousUserGenerativeQnAEmbeddingConfiguration();
        generativeQnAConfiguration.setInitialTopicId(initialTopicId);
        experienceConfiguration.setGenerativeQnA(generativeQnAConfiguration);

        GenerateEmbedUrlForAnonymousUserRequest generateEmbedUrlForAnonymousUserRequest = new GenerateEmbedUrlForAnonymousUserRequest()
            .withAwsAccountId(accountId)
            .withNamespace(namespace)
            .withAuthorizedResourceArns(authorizedResourceArns)
            .withExperienceConfiguration(experienceConfiguration)
            .withSessionTags(sessionTags)
            .withSessionLifetimeInMinutes(600L); // OPTIONAL: VALUE CAN BE [15-600]. DEFAULT: 600
            .withAllowedDomains(allowedDomains);

        GenerateEmbedUrlForAnonymousUserResult result = quickSightClient.generateEmbedUrlForAnonymousUser(generateEmbedUrlForAnonymousUserRequest);

        return result.getEmbedUrl();
    }

}
```

#### JavaScript
<a name="embedded-analytics-gen-bi-anonymous-users-js"></a>

**Nota**  
La generazione di URL da APIs incorporare non può essere richiamata direttamente dai browser. Fai invece riferimento all'esempio Node.JS.

#### Python3
<a name="embedded-analytics-gen-bi-anonymous-users-py"></a>

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

# Create QuickSight and STS clients
quicksightClient = boto3.client('quicksight',region_name='us-west-2')
sts = boto3.client('sts')

# Function to generate embedded URL for anonymous user
# accountId: YOUR AWS ACCOUNT ID
# topicId: Topic ID to embed
# quicksightNamespace: VALID NAMESPACE WHERE YOU WANT TO DO NOAUTH EMBEDDING
# authorizedResourceArns: TOPIC ARN LIST TO EMBED
# allowedDomains: RUNTIME ALLOWED DOMAINS FOR EMBEDDING
# sessionTags: SESSION TAGS USED FOR ROW-LEVEL SECURITY
def generateEmbedUrlForAnonymousUser(accountId, quicksightNamespace, authorizedResourceArns, allowedDomains, sessionTags):
    try:
        response = quicksightClient.generate_embed_url_for_anonymous_user(
            AwsAccountId = accountId,
            Namespace = quicksightNamespace,
            AuthorizedResourceArns = authorizedResourceArns,
            AllowedDomains = allowedDomains,
            ExperienceConfiguration = {
                'GenerativeQnA': {
                        'InitialTopicId': topicId
                    }
            },
            SessionTags = sessionTags,
            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
<a name="embedded-analytics-gen-bi-anonymous-users-node"></a>

L'esempio seguente mostra JavaScript (Node.js) che è possibile utilizzare sul server dell'app per generare l'URL per la 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 quicksightClient = new AWS.Service({
    region: 'us-east-1',
});

quicksightClient.generateEmbedUrlForAnonymousUser({
    'AwsAccountId': '111122223333',
    'Namespace': 'DEFAULT'
    'AuthorizedResourceArns': '["topic-arn-topicId1","topic-arn-topicId2"]',
    'AllowedDomains': allowedDomains,
    'ExperienceConfiguration': { 
        'GenerativeQnA': {
            'InitialTopicId': 'U4zJMVZ2n2stZflc8Ou3iKySEb3BEV6f'
        }
    },
    'SessionTags': '["Key": tag-key-1,"Value": tag-value-1,{"Key": tag-key-1,"Value": tag-value-1}]',
    'SessionLifetimeInMinutes': 15
}, function(err, data) {
    console.log('Errors: ');
    console.log(err);
    console.log('Response: ');
    console.log(data);
});
```

#### .NET/C\$1
<a name="embedded-analytics-gen-bi-anonymous-users-cs"></a>

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

**Example**  

```
using System;
using Amazon.QuickSight;
using Amazon.QuickSight.Model;

namespace GenerateGenerativeQnAEmbedUrlForAnonymousUser
{
    class Program
    {
        static void Main(string[] args)
        {
            var quicksightClient = new AmazonQuickSightClient(
                AccessKey,
                SecretAccessKey,
                SessionToken,
                Amazon.RegionEndpoint.USEast1);
            try
            {
                AnonymousUserGenerativeQnAEmbeddingConfiguration anonymousUserGenerativeQnAEmbeddingConfiguration
                    = new AnonymousUserGenerativeQnAEmbeddingConfiguration
                    {
                        InitialTopicId = "U4zJMVZ2n2stZflc8Ou3iKySEb3BEV6f"
                    };
                AnonymousUserEmbeddingExperienceConfiguration anonymousUserEmbeddingExperienceConfiguration
                    = new AnonymousUserEmbeddingExperienceConfiguration
                    {
                        GenerativeQnA = anonymousUserGenerativeQnAEmbeddingConfiguration
                    }; 
                
                Console.WriteLine(
                    quicksightClient.GenerateEmbedUrlForAnonymousUserAsync(new GenerateEmbedUrlForAnonymousUserRequest
                    {
                        AwsAccountId = "111122223333",
                        Namespace = "DEFAULT",
                        AuthorizedResourceArns '["topic-arn-topicId1","topic-arn-topicId2"]',
                        AllowedDomains = allowedDomains,
                        ExperienceConfiguration = anonymousUserEmbeddingExperienceConfiguration,
                        SessionTags = '["Key": tag-key-1,"Value": tag-value-1,{"Key": tag-key-1,"Value": tag-value-1}]',
                        SessionLifetimeInMinutes = 15,
                    }).Result.EmbedUrl
                );
            } catch (Exception ex) {
                Console.WriteLine(ex.Message);
            }
        }
    }
}
```

#### AWS CLI
<a name="embedded-analytics-gen-bi-anonymous-users-cli"></a>

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:GenerateEmbedUrlForAnonymousUser`.

```
aws sts assume-role \
     --role-arn "arn:aws:iam::111122223333:role/embedding_quicksight_generative_qna_role" \
     --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. Per 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_q_search_bar_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. 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. 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 `generate-embed-url-for-anynymous-user` 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 generate-embed-url-for-anonymous-user \
--aws-account-id 111122223333 \
--namespace default-or-something-else \
--authorized-resource-arns '["topic-arn-topicId","topic-arn-topicId2"]' \
--allowed-domains '["domain1","domain2"]' \
--experience-configuration 'GenerativeQnA={InitialTopicId="topicId1"}' \
--session-tags '["Key": tag-key-1,"Value": tag-value-1,{"Key": tag-key-1,"Value": tag-value-1}]' \
--session-lifetime-in-minutes 15
```

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

### Passaggio 3: Incorporare l'URL dell'esperienza Domande e risposte generative
<a name="embedded-analytics-gen-bi-anonymous-users-step-3"></a>

Nella sezione seguente, puoi scoprire come incorporare l'URL dell'esperienza Domande e risposte generative nella pagina del sito web o dell'applicazione. Puoi farlo con l'[SDK di incorporamento di Amazon Quick Sight](https://www.npmjs.com/package/amazon-quicksight-embedding-sdk) ()JavaScript. Con il kit SDK, puoi procedere come segue: 
+ Posiziona l'esperienza Domande e risposte generative su una pagina HTML.
+ Personalizza il layout e l'aspetto dell'esperienza incorporata per adattarla alle esigenze delle tue applicazioni.
+ Gestisci stati di errore con messaggi personalizzati per l'applicazione.

Chiama l'operazione API `GenerateEmbedUrlForAnonymousUser` per generare 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 valore `auth_code` che consente una sessione di single sign-on. 

Di seguito viene mostrata una risposta di esempio da `generate-embed-url-for-anonymous-user`.

```
//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://quicksightdomain/embedding/12345/q/search...",
     "RequestId": "7bee030e-f191-45c4-97fe-d9faf0e03713"
}
```

Incorpora l'esperienza di domande e risposte generative nella tua pagina web con l'SDK di [incorporamento Amazon Quick Sight o aggiungendo questo](https://www.npmjs.com/package/amazon-quicksight-embedding-sdk) 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. 

Assicurati che il dominio per ospitare l'esperienza di domande e risposte generative sia nell'elenco dei domini *consentiti, l'elenco dei* domini approvati per il tuo abbonamento Amazon Quick Sight. Questo requisito protegge i tuoi dati impedendo ai domini non approvati di ospitare l'esperienza Domande e risposte generative incorporata. Per ulteriori informazioni sull'aggiunta di domini per un'esperienza Domande e risposte generative incorporata, consulta [Gestione dei domini](manage-domains.md).

Puoi utilizzare Amazon Quick Sight Embedding SDK per personalizzare il layout e l'aspetto dell'esperienza di domande e risposte generative incorporata in base alla tua applicazione. Utilizza la proprietà `panelType` per configurare lo stato di destinazione dell'esperienza Domande e risposte generative quando viene visualizzata nella tua applicazione. Imposta la proprietà `panelType` su `'FULL'` per visualizzare l'intero pannello dell'esperienza Domande e risposte generative. Questo pannello è simile all'esperienza che gli utenti di Amazon Quick Sight hanno nella console Amazon Quick Sight. L'altezza della cornice del pannello non viene modificata in base all'interazione dell'utente e rispetta il valore impostato nella proprietà `frameOptions.height`. L'immagine seguente mostra il pannello dell'esperienza di domande e risposte generative che viene renderizzato quando imposti il valore `panelType` su `'FULL'`.

Imposta la proprietà `panelType` su `'SEARCH_BAR'` per rendere l'esperienza di domande e risposte generative come barra di ricerca. Questa barra di ricerca è simile al modo in cui viene visualizzata la barra di ricerca Q quando è incorporata in un'applicazione. La barra di ricerca di Domande e risposte generative si espande in un pannello più grande che mostra le opzioni di selezione degli argomenti, l'elenco dei suggerimenti di domande, il pannello delle risposte o la bacheca.

L'altezza minima predefinita della barra di ricerca di Domande e risposte generative viene visualizzata al caricamento delle risorse incorporate. Si consiglia di impostare il valore `frameOptions.height` su `"38px"` per ottimizzare l'esperienza della barra di ricerca. Utilizza la proprietà `focusedHeight` per impostare la dimensione ottimale del menu a discesa per la selezione degli argomenti e dell'elenco di suggerimenti per le domande. Utilizza la proprietà `expandedHeight` per impostare la dimensione ottimale del pannello delle risposte e della bacheca. Se sceglie l'opzione `'SEARCH_BAR'`, si consiglia di assegnare al container padre lo stile position; lo stile absolute è per evitare spostamenti indesiderati del contenuto nell'applicazione. L'immagine seguente mostra la barra di ricerca dell'esperienza di domande e risposte generative che viene renderizzato quando imposti il valore `panelType` su `'SEARCH_BAR'`.

Dopo aver configurato la `panelType` proprietà, utilizza l'SDK di incorporamento Amazon Quick Sight per personalizzare le seguenti proprietà dell'esperienza di domande e risposte generative.
+ Il titolo del pannello Domande e risposte generative (si applica solo all'opzione `panelType: FULL`). 
+ Il testo del segnaposto della barra di ricerca.
+ Se la selezione dell'argomento è consentita.
+ Se i nomi degli argomenti sono visualizzati o nascosti.
+ Se l'icona di Amazon Q è visualizzata o nascosta (si applica solo all'opzione `panelType: FULL`).
+ Se la bacheca è visualizzata o nascosta.
+ Se gli utenti possono ingrandire il pannello Domande e risposte generative a tutto schermo.
+ Il tema del pannello Domande e risposte generative. È possibile passare un ARN del tema personalizzato nell'SDK per modificare l'aspetto del contenuto del riquadro. I temi iniziali di Amazon Quick Sight non sono supportati per i pannelli di BI generativa incorporati. Per utilizzare un tema iniziale di Amazon Quick Sight, salvalo come tema personalizzato in Amazon Quick Sight.

Quando usi Amazon Quick Sight Embedding SDK, l'esperienza di domande e risposte generative sulla tua pagina viene ridimensionata dinamicamente in base allo stato. Con Amazon Quick Sight Embedding SDK, puoi anche controllare i parametri nell'ambito dell'esperienza di domande e risposte generative e ricevere richiami in termini di completamento del caricamento della pagina, modifiche di stato ed errori. 

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

#### SDK 2.0
<a name="embedded-analytics-gen-bi-anonymous-users-sdkv2"></a>

```
<!DOCTYPE html>
<html>
    <head>
        <title>Generative Q&A Embedding Example</title>
        <script src="https://unpkg.com/amazon-quicksight-embedding-sdk@2.7.0/dist/quicksight-embedding-js-sdk.min.js"></script>
        <script type="text/javascript">
            const embedGenerativeQnA = async() => {    
                const {createEmbeddingContext} = QuickSightEmbedding;

                const embeddingContext = await createEmbeddingContext({
                    onChange: (changeEvent, metadata) => {
                        console.log('Context received a change', changeEvent, metadata);
                    },
                });

                const frameOptions = {
                    url: "<YOUR_EMBED_URL>", // replace this value with the url generated via embedding API
                    container: '#experience-container',
                    height: "700px",
                    width: "1000px",
                    onChange: (changeEvent, metadata) => {
                        switch (changeEvent.eventName) {
                            case 'FRAME_MOUNTED': {
                                console.log("Do something when the experience frame is mounted.");
                                break;
                            }
                            case 'FRAME_LOADED': {
                                console.log("Do something when the experience frame is loaded.");
                                break;
                            }
                        }
                    },
                };

                const contentOptions = {
                    // Optional panel settings. Default behavior is equivalent to {panelType: 'FULL'}
                    panelOptions: {
                        panelType: 'FULL',
                        title: 'custom title', // Optional
                        showQIcon: false, // Optional, Default: true
                    },
                    // Use SEARCH_BAR panel type for the landing state to be similar to embedQSearchBar
                    // with generative capability enabled topics
                    /*
                    panelOptions: {
                        panelType: 'SEARCH_BAR',
                        focusedHeight: '250px',
                        expandedHeight: '500px',
                    },
                    */
                    showTopicName: false, // Optional, Default: true
                    showPinboard: false, // Optional, Default: true
                    allowTopicSelection: false, // Optional, Default: true
                    allowFullscreen: false, // Optional, Default: true
                    searchPlaceholderText: "custom search placeholder", // Optional
                    themeOptions: { // Optional
                        themeArn: 'arn:aws:quicksight:<Region>:<AWS-Account-ID>:theme/<Theme-ID>'
                    }
                    onMessage: async (messageEvent, experienceMetadata) => {
                        switch (messageEvent.eventName) {
                            case 'Q_SEARCH_OPENED': {
                                // called when pinboard is shown / visuals are rendered
                                console.log("Do something when SEARCH_BAR type panel is expanded");
                                break;
                            }
                            case 'Q_SEARCH_FOCUSED': {
                                // called when question suggestions or topic selection dropdown are shown
                                console.log("Do something when SEARCH_BAR type panel is focused");
                                break;
                            }
                            case 'Q_SEARCH_CLOSED': {
                                // called when shrinked to initial bar height
                                console.log("Do something when SEARCH_BAR type panel is collapsed");
                                break;
                            }
                            case 'Q_PANEL_ENTERED_FULLSCREEN': {
                                console.log("Do something when panel enters full screen mode");
                                break;
                            }
                            case 'Q_PANEL_EXITED_FULLSCREEN': {
                                console.log("Do something when panel exits full screen mode");
                                break;
                            }
                            case 'CONTENT_LOADED': {
                                console.log("Do something after experience is loaded");
                                break;
                            }
                            case 'ERROR_OCCURRED': {
                                console.log("Do something when experience fails to load");
                                break;
                            }
                        }
                    }
                };
                const embeddedGenerativeQnExperience = await embeddingContext.embedGenerativeQnA(frameOptions, contentOptions);
            };
        </script>
    </head>

    <body onload="embedGenerativeQnA()">
        <div id="experience-container"></div>
    </body>

</html>
```

Affinché questo esempio funzioni, assicurati di utilizzare l'SDK Amazon Quick Sight Embedding per caricare l'esperienza di domande e risposte generative incorporata sul tuo sito web. 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 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
  ```

### Funzionalità facoltative incorporate per l'esperienza di domande e risposte generative
<a name="embedded-analytics-gen-bi-anonymous-users-step-4"></a>

Le seguenti funzionalità facoltative sono disponibili per l'esperienza Domande e risposte generative incorporata utilizzando l'SDK di incorporamento. 

#### Invocare le azioni della barra di ricerca di Domande e risposte generative
<a name="w2aac35c27c21c43c29c13c25b5"></a>
+ Imposta una domanda: questa funzionalità invia una domanda all'esperienza Domande e risposte generative e interroga immediatamente la domanda.

  ```
  embeddedGenerativeQnExperience.setQuestion('show me monthly revenue');
  ```
+ Chiudi il pannello delle risposte (si applica all'opzione della barra di ricerca Domande e risposte generative): questa funzionalità chiude il pannello delle risposte e riporta l'iframe allo stato originale della barra di ricerca.

  ```
  embeddedGenerativeQnExperience.close();
  ```

Per ulteriori informazioni, consulta l'[SDK di incorporamento di Amazon Quick Sight](https://github.com/awslabs/amazon-quicksight-embedding-sdk).

# Incorporamento della barra di ricerca Amazon Quick Sight Q (Classic)
<a name="embedding-quicksight-q"></a>


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

**Nota**  
La barra di ricerca integrata di Amazon Quick Sight Q offre la classica esperienza di domande e risposte di Amazon Quick Sight. Amazon Quick Sight si integra con Amazon Q Business per lanciare una nuova esperienza di domande e risposte generative. Si consiglia agli sviluppatori di utilizzare la nuova esperienza Domande e risposte generative. Per ulteriori informazioni sull'esperienza di domande e risposte generative integrata, consulta [Incorporare Amazon Q nell'esperienza di domande e risposte generative di Amazon Quick Sight](https://docs.aws.amazon.com/quicksight/latest/user/embedding-gen-bi.html).

Utilizza i seguenti argomenti per scoprire come incorporare la barra di ricerca di Amazon Quick Sight Q con Amazon Quick Sight APIs.

**Topics**
+ [

# Incorporamento della barra di ricerca Amazon Quick Sight Q per gli utenti registrati
](embedded-analytics-q-search-bar-for-authenticated-users.md)
+ [

# Incorporamento della barra di ricerca Amazon Quick Sight Q per utenti anonimi (non registrati)
](embedded-analytics-q-search-bar-for-anonymous-users.md)

# Incorporamento della barra di ricerca Amazon Quick Sight Q per gli utenti registrati
<a name="embedded-analytics-q-search-bar-for-authenticated-users"></a>


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


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

**Nota**  
La barra di ricerca integrata di Amazon Quick Sight Q offre la classica esperienza di domande e risposte di Amazon Quick Sight. Amazon Quick Sight si integra con Amazon Q Business per lanciare una nuova esperienza di domande e risposte generative. Si consiglia agli sviluppatori di utilizzare la nuova esperienza Domande e risposte generative. Per ulteriori informazioni sull'esperienza di domande e risposte generative integrata, consulta [Incorporare Amazon Q nell'esperienza di domande e risposte generative di Amazon Quick Sight](https://docs.aws.amazon.com/quicksight/latest/user/embedding-gen-bi.html).

Nelle sezioni seguenti, puoi trovare informazioni dettagliate su come configurare una barra di ricerca Amazon Quick Sight Q incorporata per gli utenti registrati di Amazon Quick Sight.

**Topics**
+ [

## Fase 1: Configurazione delle autorizzazioni
](#embedded-q-bar-for-authenticated-users-step-1)
+ [

## Fase 2: Generazione dell'URL con il codice di autenticazione allegato
](#embedded-q-bar-for-authenticated-users-step-2)
+ [

## Fase 3: Incorporamento dell'URL della barra di ricerca Q
](#embedded-q-bar-for-authenticated-users-step-3)
+ [

## Funzionalità opzionali di incorporamento della barra di ricerca Amazon Quick Sight Q
](#embedded-q-bar-for-authenticated-users-step-4)

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

**Nota**  
La barra di ricerca integrata di Amazon Quick Sight Q offre la classica esperienza di domande e risposte di Amazon Quick Sight. Amazon Quick Sight si integra con Amazon Q Business per lanciare una nuova esperienza di domande e risposte generative. Si consiglia agli sviluppatori di utilizzare la nuova esperienza Domande e risposte generative. Per ulteriori informazioni sull'esperienza di domande e risposte generative integrata, consulta [Incorporare Amazon Q nell'esperienza di domande e risposte generative di Amazon Quick Sight](https://docs.aws.amazon.com/quicksight/latest/user/embedding-gen-bi.html).

Nella sezione seguente, puoi scoprire come configurare autorizzazioni per l'applicazione di back-end o server Web per incorporare la barra di ricerca Q. Questa attività richiede l'accesso amministrativo a (IAM). AWS Identity and Access Management 

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 l'incorporamento URLs per un pool di utenti specifico. 

Con l'aiuto del carattere jolly *\$1*, puoi concedere le autorizzazioni per generare un URL per tutti gli utenti in uno spazio dei nomi specifico. Oppure puoi concedere le autorizzazioni per generare un URL per un sottoinsieme di utenti in spazi dei nomi specifici. Per questo, aggiungi `quicksight:GenerateEmbedUrlForRegisteredUser`.

Puoi creare una condizione nella tua policy IAM che limiti i domini che gli sviluppatori possono elencare nel parametro `AllowedDomains` di un'operazione API `GenerateEmbedUrlForRegisteredUser`. Il parametro `AllowedDomains` è un parametro facoltativo. Offre agli sviluppatori la possibilità di sovrascrivere i domini statici configurati nel menu Manage **Amazon Quick Sight** e di elencare invece fino a tre domini o sottodomini che possono accedere a un URL generato. Questo URL viene quindi incorporato nel sito web di uno sviluppatore. Solo i domini elencati nel parametro possono accedere alla barra di ricerca Q incorporata. Senza questa condizione, gli sviluppatori possono elencare nel parametro `AllowedDomains` qualsiasi dominio su Internet. 

Per limitare i domini che gli sviluppatori possono utilizzare con questo parametro, aggiungi una condizione `AllowedEmbeddingDomains` alla tua policy IAM. Per ulteriori informazioni sul `AllowedDomains` parametro, consulta [GenerateEmbedUrlForRegisteredUser](https://docs.aws.amazon.com//quicksight/latest/APIReference/API_GenerateEmbedUrlForRegisteredUser.html)*Amazon Quick Sight API Reference*.

**Best practice di sicurezza per gli operatori di condizioni IAM**  
Gli operatori di condizioni IAM configurati in modo errato possono consentire l'accesso non autorizzato alle risorse Quick incorporate tramite variazioni di URL. Quando utilizzi la chiave `quicksight:AllowedEmbeddingDomains` condition nelle tue policy IAM, utilizza operatori di condizione che consentano domini specifici o neghino tutti i domini che non sono specificamente consentiti. Per ulteriori informazioni sugli operatori di condizioni IAM, consulta [IAM JSON Policy elements: Condition operators](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_elements_condition_operators.html) nella IAM User Guide.  
Molte varianti di URL diverse possono puntare alla stessa risorsa. Ad esempio, i seguenti elementi si risolvono URLs tutti allo stesso contenuto:  
`https://example.com`
`https://example.com/`
`https://Example.com`
Se la tua politica utilizza operatori che non tengono conto di queste variazioni di URL, un utente malintenzionato può aggirare le tue restrizioni fornendo varianti URL equivalenti.  
Devi verificare che la tua policy IAM utilizzi operatori di condizioni appropriati per evitare di aggirare le vulnerabilità e garantire che solo i domini previsti possano accedere alle tue risorse incorporate.

Queste autorizzazioni sono fornite dalla seguente policy di esempio.

Inoltre, se stai creando utenti alle prime armi che saranno lettori di Amazon Quick Sight, assicurati di aggiungere l'`quicksight:RegisterUser`autorizzazione nella policy.

La seguente politica di esempio fornisce l'autorizzazione a recuperare un URL di incorporamento per gli utenti alle prime armi che devono essere lettori di Amazon Quick Sight.

Infine, è 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. 

Di seguito è mostrata una policy di attendibilità di esempio.

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

****  

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

------

Per ulteriori informazioni sulle policy di attendibilità 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: Generazione dell'URL con il codice di autenticazione allegato
<a name="embedded-q-bar-for-authenticated-users-step-2"></a>

**Nota**  
La barra di ricerca integrata di Amazon Quick Sight Q offre la classica esperienza di domande e risposte di Amazon Quick Sight. Amazon Quick Sight si integra con Amazon Q Business per lanciare una nuova esperienza di domande e risposte generative. Si consiglia agli sviluppatori di utilizzare la nuova esperienza Domande e risposte generative. Per ulteriori informazioni sull'esperienza di domande e risposte generative integrata, consulta [Incorporare Amazon Q nell'esperienza di domande e risposte generative di Amazon Quick Sight](https://docs.aws.amazon.com/quicksight/latest/user/embedding-gen-bi.html).

Nella sezione seguente, è possibile scoprire come autenticare l'utente e ottenere l'URL dell'argomento Q incorporabile nel server delle applicazioni. Se prevedi di incorporare la barra Q per i tipi di identità IAM o Amazon Quick Sight, condividi l'argomento Q con gli utenti.

Quando un utente accede all'applicazione, l'applicazione assume il ruolo IAM per conto dell'utente. Quindi l'app 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 dell'argomento Q 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
<a name="embedded-q-bar-for-embedded-q-bar-for-authenticated-users-java"></a>

```
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.GenerateEmbedUrlForRegisteredUserRequest;
import com.amazonaws.services.quicksight.model.GenerateEmbedUrlForRegisteredUserResult;
import com.amazonaws.services.quicksight.model.RegisteredUserEmbeddingExperienceConfiguration;
import com.amazonaws.services.quicksight.model.RegisteredUserQSearchBarEmbeddingConfiguration;

        /**
 * Class to call QuickSight AWS SDK to get url for embedding the Q search bar.
        */
public class RegisteredUserQSearchBarEmbeddingConfiguration {

            private final AmazonQuickSight quickSightClient;

    public RegisteredUserQSearchBarEmbeddingConfiguration() {
        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, // AWS Account ID
            final String topicId, // Topic ID to embed
            final List<String> allowedDomains, // Runtime allowed domain for embedding
            final String userArn // Registered user arn to use for embedding. Refer to Get Embed Url section in developer portal to find how to get user arn for a QuickSight user.
            ) throws Exception {
        final RegisteredUserEmbeddingExperienceConfiguration experienceConfiguration = new RegisteredUserEmbeddingExperienceConfiguration()
                .withQSearchBar(new RegisteredUserQSearchBarEmbeddingConfiguration().withInitialTopicId(topicId));
        final GenerateEmbedUrlForRegisteredUserRequest generateEmbedUrlForRegisteredUserRequest = new GenerateEmbedUrlForRegisteredUserRequest();
        generateEmbedUrlForRegisteredUserRequest.setAwsAccountId(accountId);
        generateEmbedUrlForRegisteredUserRequest.setUserArn(userArn);
        generateEmbedUrlForRegisteredUserRequest.setAllowedDomains(allowedDomains);
        generateEmbedUrlForRegisteredUserRequest.setExperienceConfiguration(QSearchBar);

        final GenerateEmbedUrlForRegisteredUserResult generateEmbedUrlForRegisteredUserResult = quickSightClient.generateEmbedUrlForRegisteredUser(generateEmbedUrlForRegisteredUserRequest);

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

### JavaScript
<a name="embedded-q-bar-for-embedded-q-bar-for-authenticated-users-js"></a>

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

function generateEmbedUrlForRegisteredUser(
    accountId,
    topicId, // Topic ID to embed
    openIdToken, // Cognito-based token
    userArn, // registered user arn
    roleArn, // IAM user role to use for embedding
    sessionName, // Session name for the roleArn assume role
    allowedDomains, // Runtime allowed domain for embedding
    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 getQSearchBarParams = {
        "AwsAccountId": accountId,
                "ExperienceConfiguration": {
                    "QSearchBar": {
                        "InitialTopicId": topicId
                    }
                },
                "UserArn": userArn,
        "AllowedDomains": allowedDomains,
        "SessionLifetimeInMinutes": 600
    };

            const quicksightGetQSearchBar = 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
                }
    });

            quicksightGetQSearchBar.generateEmbedUrlForRegisteredUser(getQSearchBarParams, 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
<a name="embedded-q-bar-for-embedded-q-bar-for-authenticated-users-python"></a>

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

sts = boto3.client('sts')

# Function to generate embedded URL  
# accountId: AWS account ID
# topicId: Topic ID to embed
# userArn: arn of registered user
# allowedDomains: Runtime allowed domain for embedding
# roleArn: IAM user role to use for embedding
# sessionName: session name for the roleArn assume role
def getEmbeddingURL(accountId, topicId, userArn, allowedDomains, roleArn, sessionName):
    try:
        assumedRole = sts.assume_role(
            RoleArn = roleArn,
            RoleSessionName = sessionName,
        )
    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:
            quicksightClient = assumedRoleSession.client('quicksight', region_name='us-west-2')
            response = quicksightClient.generate_embed_url_for_registered_user(
                AwsAccountId=accountId,
                ExperienceConfiguration = {
                    "QSearchBar": {
                        "InitialTopicId": topicId
                    }
                },
                UserArn = userArn,
                AllowedDomains = allowedDomains,
                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:
            return "Error generating embedding url: " + str(e)
```

### Node.js
<a name="embedded-q-bar-for-embedded-q-bar-for-authenticated-users-node"></a>

L'esempio seguente mostra il file JavaScript (Node.js) che puoi usare sul server dell'app per generare l'URL per la 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 quicksightClient = new AWS.Service({
    apiConfig: require('./quicksight-2018-04-01.min.json'),
    region: 'us-east-1',
});

quicksightClient.generateEmbedUrlForRegisteredUser({
    'AwsAccountId': '111122223333',
    'ExperienceConfiguration': { 
        'QSearchBar': {
            'InitialTopicId': 'U4zJMVZ2n2stZflc8Ou3iKySEb3BEV6f'
        }
    },
    'UserArn': 'REGISTERED_USER_ARN',
    'AllowedDomains': allowedDomains,
    'SessionLifetimeInMinutes': 100
}, 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://quicksightdomain/embed/12345/dashboards/67890/sheets/12345/visuals/67890...",
        RequestId: '7bee030e-f191-45c4-97fe-d9faf0e03713' 
    }
```

### .NET/C\$1
<a name="embedded-q-bar-for-embedded-q-bar-for-authenticated-users-cs"></a>

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

**Example**  

```
using System;
using Amazon.QuickSight;
using Amazon.QuickSight.Model;

namespace GenerateDashboardEmbedUrlForRegisteredUser
{
    class Program
    {
        static void Main(string[] args)
        {
            var quicksightClient = new AmazonQuickSightClient(
                AccessKey,
                SecretAccessKey,
                SessionToken,
                Amazon.RegionEndpoint.USEast1);
            try
            {
                RegisteredUserQSearchBarEmbeddingConfiguration registeredUserQSearchBarEmbeddingConfiguration
                    = new RegisteredUserQSearchBarEmbeddingConfiguration
                    {
                        InitialTopicId = "U4zJMVZ2n2stZflc8Ou3iKySEb3BEV6f"
                    };
                RegisteredUserEmbeddingExperienceConfiguration registeredUserEmbeddingExperienceConfiguration
                    = new RegisteredUserEmbeddingExperienceConfiguration
                    {
                        QSearchBar = registeredUserQSearchBarEmbeddingConfiguration
                    }; 
                
                Console.WriteLine(
                    quicksightClient.GenerateEmbedUrlForRegisteredUserAsync(new GenerateEmbedUrlForRegisteredUserRequest
                    {
                        AwsAccountId = "111122223333",
                        ExperienceConfiguration = registeredUserEmbeddingExperienceConfiguration,
                        UserArn = "REGISTERED_USER_ARN",
                        AllowedDomains = allowedDomains,
                        SessionLifetimeInMinutes = 100
                    }).Result.EmbedUrl
                );
            } catch (Exception ex) {
                Console.WriteLine(ex.Message);
            }
        }
    }
}
```

### AWS CLI
<a name="embedded-q-bar-for-embedded-q-bar-for-authenticated-users-cli"></a>

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:GenerateEmbedUrlForRegisteredUser`. Se stai adottando un just-in-time approccio per aggiungere utenti quando utilizzano un argomento nella barra di ricerca Q, anche per il ruolo è necessario abilitare le autorizzazioni. `quicksight:RegisterUser`

```
aws sts assume-role \
     --role-arn "arn:aws:iam::111122223333:role/embedding_quicksight_q_search_bar_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. Per 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_q_search_bar_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 barra di ricerca Q. 

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_q_search_bar_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 il nome della risorsa Amazon (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_q_search_bar_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 dashboard. 

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

```
aws quicksight generate-embed-url-for-registered-user \
--aws-account-id 111122223333 \
--session-lifetime-in-minutes 600 \
--user-arn arn:aws:quicksight:us-east-1:111122223333:user/default/embedding_quicksight_q_search_bar_role/embeddingsession
--allowed-domains '["domain1","domain2"]' \
--experience-configuration QSearchBar={InitialTopicId=U4zJMVZ2n2stZflc8Ou3iKySEb3BEV6f}
```

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

## Fase 3: Incorporamento dell'URL della barra di ricerca Q
<a name="embedded-q-bar-for-authenticated-users-step-3"></a>

**Nota**  
La barra di ricerca integrata di Amazon Quick Sight Q offre la classica esperienza di domande e risposte di Amazon Quick Sight. Amazon Quick Sight si integra con Amazon Q Business per lanciare una nuova esperienza di domande e risposte generative. Si consiglia agli sviluppatori di utilizzare la nuova esperienza Domande e risposte generative. Per ulteriori informazioni sull'esperienza di domande e risposte generative integrata, consulta [Incorporare Amazon Q nell'esperienza di domande e risposte generative di Amazon Quick Sight](https://docs.aws.amazon.com/quicksight/latest/user/embedding-gen-bi.html).

Nella sezione seguente, puoi scoprire come incorporare l'URL della barra di ricerca Q dalla fase 3 nella pagina del sito web o dell'applicazione. Puoi farlo con l'[SDK di incorporamento di Amazon Quick Sight](https://www.npmjs.com/package/amazon-quicksight-embedding-sdk) ()JavaScript. Con il kit SDK, puoi procedere come segue: 
+ Posiziona la barra di ricerca Q su una pagina HTML.
+ Passa i parametri nella barra di ricerca Q.
+ Gestisci stati di errore con messaggi personalizzati per l'applicazione.

Chiama l'operazione API `GenerateEmbedUrlForRegisteredUser` per generare 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 valore `auth_code` che consente una sessione di single sign-on. 

Di seguito viene mostrata una risposta di esempio da `generate-embed-url-for-registered-user`.

```
//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://quicksightdomain/embedding/12345/q/search...",
     "RequestId": "7bee030e-f191-45c4-97fe-d9faf0e03713"
}
```

Incorpora la barra di ricerca Q 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. 

Per fare ciò, assicurati che il dominio su cui ospitare la barra di ricerca Q incorporata sia *nell'elenco dei domini consentiti*, l'elenco dei domini approvati per il tuo abbonamento Amazon Quick Sight. Questo requisito protegge i tuoi dati impedendo ai domini non approvati di ospitare pannelli di controllo incorporati. Per ulteriori informazioni sull'aggiunta di domini per una barra di ricerca Q incorporata, consulta [Gestione dei domini](https://docs.aws.amazon.com/quicksight/latest/user/manage-qs-domains-and-embedding.html) e incorporamento.

Quando usi Amazon Quick Sight Embedding SDK, la barra di ricerca Q sulla tua pagina viene ridimensionata dinamicamente in base allo stato. Utilizzando Amazon Quick Sight Embedding SDK, puoi anche controllare i parametri all'interno della barra di ricerca Q 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.

### SDK 2.0
<a name="embedded-q-bar-for-authenticated-users-sdkv2"></a>

```
<!DOCTYPE html>
<html>

    <head>
        <title>Q Search Bar Embedding Example</title>
        <script src="https://unpkg.com/amazon-quicksight-embedding-sdk@2.0.0/dist/quicksight-embedding-js-sdk.min.js"></script>
        <script type="text/javascript">
            const embedQSearchBar = async() => {    
                const {
                    createEmbeddingContext,
                } = QuickSightEmbedding;

                const embeddingContext = await createEmbeddingContext({
                    onChange: (changeEvent, metadata) => {
                        console.log('Context received a change', changeEvent, metadata);
                    },
                });

                const frameOptions = {
                    url: "<YOUR_EMBED_URL>", // replace this value with the url generated via embedding API
                    container: '#experience-container',
                    height: "700px",
                    width: "1000px",
                    onChange: (changeEvent, metadata) => {
                        switch (changeEvent.eventName) {
                            case 'FRAME_MOUNTED': {
                                console.log("Do something when the experience frame is mounted.");
                                break;
                            }
                            case 'FRAME_LOADED': {
                                console.log("Do something when the experience frame is loaded.");
                                break;
                            }
                        }
                    },
                };

                const contentOptions = {
                    hideTopicName: false, 
                    theme: '<YOUR_THEME_ID>',
                    allowTopicSelection: true,
                    onMessage: async (messageEvent, experienceMetadata) => {
                        switch (messageEvent.eventName) {
                            case 'Q_SEARCH_OPENED': {
                                console.log("Do something when Q Search content expanded");
                                break;
                            }
                            case 'Q_SEARCH_CLOSED': {
                                console.log("Do something when Q Search content collapsed");
                                break;
                            }
                            case 'Q_SEARCH_SIZE_CHANGED': {
                                console.log("Do something when Q Search size changed");
                                break;
                            }
                            case 'CONTENT_LOADED': {
                                console.log("Do something when the Q Search is loaded.");
                                break;
                            }
                            case 'ERROR_OCCURRED': {
                                console.log("Do something when the Q Search fails loading.");
                                break;
                            }
                        }
                    }
                };
                const embeddedDashboardExperience = await embeddingContext.embedQSearchBar(frameOptions, contentOptions);
            };
        </script>
    </head>

    <body onload="embedQSearchBar()">
        <div id="experience-container"></div>
    </body>

</html>
```

### SDK 1.0
<a name="embedded-q-bar-for-authenticated-users-sdkv1"></a>

```
<!DOCTYPE html>
<html>

    <head>
        <title>QuickSight Q Search Bar Embedding</title>
        <script src="https://unpkg.com/amazon-quicksight-embedding-sdk@1.18.0/dist/quicksight-embedding-js-sdk.min.js"></script>
        <script type="text/javascript">
            var session

            function onError(payload) {
                console.log("Do something when the session fails loading");
            }

            function onOpen() {
                console.log("Do something when the Q search bar opens");
            }

            function onClose() {
                console.log("Do something when the Q search bar closes");
            }

            function embedQSearchBar() {
                var containerDiv = document.getElementById("embeddingContainer");
                var options = {
                    url: "https://us-east-1.quicksight.aws.amazon.com/sn/dashboards/dashboardId?isauthcode=true&identityprovider=quicksight&code=authcode", // replace this dummy url with the one generated via embedding API
                    container: containerDiv,
                    width: "1000px",
                    locale: "en-US",
                    qSearchBarOptions: {
                        expandCallback: onOpen,
                        collapseCallback: onClose,
                        iconDisabled: false,
                        topicNameDisabled: false, 
                        themeId: 'bdb844d0-0fe9-4d9d-b520-0fe602d93639',
                        allowTopicSelection: true
                    }
                };
                session = QuickSightEmbedding.embedQSearchBar(options);
                session.on("error", onError);
            }

            function onCountryChange(obj) {
                session.setParameters({country: obj.value});
            }
        </script>
    </head>

    <body onload="embedQSearchBar()">
        <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
  ```

## Funzionalità opzionali di incorporamento della barra di ricerca Amazon Quick Sight Q
<a name="embedded-q-bar-for-authenticated-users-step-4"></a>

**Nota**  
La barra di ricerca integrata di Amazon Quick Sight Q offre la classica esperienza di domande e risposte di Amazon Quick Sight. Amazon Quick Sight si integra con Amazon Q Business per lanciare una nuova esperienza di domande e risposte generative. Si consiglia agli sviluppatori di utilizzare la nuova esperienza Domande e risposte generative. Per ulteriori informazioni sull'esperienza di domande e risposte generative integrata, consulta [Incorporare Amazon Q nell'esperienza di domande e risposte generative di Amazon Quick Sight](https://docs.aws.amazon.com/quicksight/latest/user/embedding-gen-bi.html).

Le seguenti funzionalità facoltative sono disponibili per la barra di ricerca Q incorporata utilizzando l'SDK di incorporamento. 

### Richiamo delle operazioni della barra di ricerca Q
<a name="w2aac35c27c21c43c31c15c21b7"></a>

Le seguenti opzioni sono supportate solo per l'incorporamento della barra di ricerca Q. 
+ Imposta una domanda sulla barra di ricerca Q: questa funzione invia una domanda alla barra di ricerca Q e interroga immediatamente la domanda. Inoltre, apre automaticamente la finestra a comparsa di Q.

  ```
  qBar.setQBarQuestion('show me monthly revenue');
  ```
+ Chiudi il popover Q: questa funzione chiude la finestra a comparsa di Q e riporta l'iframe alla dimensione originale della barra di ricerca Q.

  ```
  qBar.closeQPopover();
  ```

Per ulteriori informazioni, consulta l'[SDK di incorporamento di Amazon Quick Sight](https://github.com/awslabs/amazon-quicksight-embedding-sdk).

# Incorporamento della barra di ricerca Amazon Quick Sight Q per utenti anonimi (non registrati)
<a name="embedded-analytics-q-search-bar-for-anonymous-users"></a>


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

**Nota**  
La barra di ricerca integrata di Amazon Quick Sight Q offre la classica esperienza di domande e risposte di Amazon Quick Sight. Amazon Quick Sight si integra con Amazon Q Business per lanciare una nuova esperienza di domande e risposte generative. Si consiglia agli sviluppatori di utilizzare la nuova esperienza Domande e risposte generative. Per ulteriori informazioni sull'esperienza di domande e risposte generative integrata, consulta [Incorporare Amazon Q nell'esperienza di domande e risposte generative di Amazon Quick Sight](https://docs.aws.amazon.com/quicksight/latest/user/embedding-gen-bi.html).

Nelle sezioni seguenti, puoi trovare informazioni dettagliate su come configurare una barra di ricerca Amazon Quick Sight Q incorporata per utenti anonimi (non registrati).

**Topics**
+ [

## Fase 1: Configurazione delle autorizzazioni
](#embedded-q-bar-for-anonymous-users-step-1)
+ [

## Fase 2: Generazione dell'URL con il codice di autenticazione allegato
](#embedded-q-bar-for-anonymous-users-step-2)
+ [

## Fase 3: Incorporamento dell'URL della barra di ricerca Q
](#embedded-q-bar-for-anonymous-users-step-3)
+ [

## Funzionalità opzionali di incorporamento della barra di ricerca Amazon Quick Sight Q
](#embedded-q-bar-for-anonymous-users-step-4)

## Fase 1: Configurazione delle autorizzazioni
<a name="embedded-q-bar-for-anonymous-users-step-1"></a>

**Nota**  
La barra di ricerca integrata di Amazon Quick Sight Q offre la classica esperienza di domande e risposte di Amazon Quick Sight. Amazon Quick Sight si integra con Amazon Q Business per lanciare una nuova esperienza di domande e risposte generative. Si consiglia agli sviluppatori di utilizzare la nuova esperienza Domande e risposte generative. Per ulteriori informazioni sull'esperienza di domande e risposte generative integrata, consulta [Incorporare Amazon Q nell'esperienza di domande e risposte generative di Amazon Quick Sight](https://docs.aws.amazon.com/quicksight/latest/user/embedding-gen-bi.html).

Nella sezione seguente, puoi scoprire come configurare autorizzazioni per l'applicazione di back-end o server Web per incorporare la barra di ricerca Q. Questa attività richiede l'accesso amministrativo a (IAM). AWS Identity and Access Management 

Ogni utente che accede a una barra di ricerca Q assume un ruolo che gli consente l'accesso ad Amazon Quick Sight e le autorizzazioni per la barra di ricerca Q. Per renderlo possibile, 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 l'incorporamento URLs per un pool di utenti specifico. 

Con l'aiuto del carattere jolly *\$1*, puoi concedere le autorizzazioni per generare un URL per tutti gli utenti in uno spazio dei nomi specifico. Oppure puoi concedere le autorizzazioni per generare un URL per un sottoinsieme di utenti in spazi dei nomi specifici. Per questo, aggiungi `quicksight:GenerateEmbedUrlForAnonymousUser`.

Puoi creare una condizione nella tua policy IAM che limiti i domini che gli sviluppatori possono elencare nel parametro `AllowedDomains` di un'operazione API `GenerateEmbedUrlForAnonymousUser`. Il parametro `AllowedDomains` è un parametro facoltativo. Offre agli sviluppatori la possibilità di sovrascrivere i domini statici configurati nel menu Manage **Amazon Quick Sight** e di elencare invece fino a tre domini o sottodomini che possono accedere a un URL generato. Questo URL viene quindi incorporato nel sito web di uno sviluppatore. Solo i domini elencati nel parametro possono accedere alla barra di ricerca Q incorporata. Senza questa condizione, gli sviluppatori possono elencare nel parametro `AllowedDomains` qualsiasi dominio su Internet. 

Per limitare i domini che gli sviluppatori possono utilizzare con questo parametro, aggiungi una condizione `AllowedEmbeddingDomains` alla tua policy IAM. Per ulteriori informazioni sul `AllowedDomains` parametro, consulta [GenerateEmbedUrlForAnonymousUser](https://docs.aws.amazon.com//quicksight/latest/APIReference/API_GenerateEmbedUrlForAnonymousUser.html)*Amazon Quick Sight API Reference*.

**Best practice di sicurezza per gli operatori di condizioni IAM**  
Gli operatori di condizioni IAM configurati in modo errato possono consentire l'accesso non autorizzato alle risorse Quick incorporate tramite variazioni di URL. Quando utilizzi la chiave `quicksight:AllowedEmbeddingDomains` condition nelle tue policy IAM, utilizza operatori di condizione che consentano domini specifici o neghino tutti i domini che non sono specificamente consentiti. Per ulteriori informazioni sugli operatori di condizioni IAM, consulta [IAM JSON Policy elements: Condition operators](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_elements_condition_operators.html) nella IAM User Guide.  
Molte varianti di URL diverse possono puntare alla stessa risorsa. Ad esempio, i seguenti elementi si risolvono URLs tutti allo stesso contenuto:  
`https://example.com`
`https://example.com/`
`https://Example.com`
Se la tua politica utilizza operatori che non tengono conto di queste variazioni di URL, un utente malintenzionato può aggirare le tue restrizioni fornendo varianti URL equivalenti.  
Devi verificare che la tua policy IAM utilizzi operatori di condizioni appropriati per evitare di aggirare le vulnerabilità e garantire che solo i domini previsti possano accedere alle tue risorse incorporate.

È 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 la barra di ricerca Q. Di seguito è mostrata una policy di attendibilità di esempio.

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

****  

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

------

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: Generazione dell'URL con il codice di autenticazione allegato
<a name="embedded-q-bar-for-anonymous-users-step-2"></a>

**Nota**  
La barra di ricerca integrata di Amazon Quick Sight Q offre la classica esperienza di domande e risposte di Amazon Quick Sight. Amazon Quick Sight si integra con Amazon Q Business per lanciare una nuova esperienza di domande e risposte generative. Si consiglia agli sviluppatori di utilizzare la nuova esperienza Domande e risposte generative. Per ulteriori informazioni sull'esperienza di domande e risposte generative integrata, consulta [Incorporare Amazon Q nell'esperienza di domande e risposte generative di Amazon Quick Sight](https://docs.aws.amazon.com/quicksight/latest/user/embedding-gen-bi.html).

Nella sezione seguente, è possibile scoprire come autenticare l'utente e ottenere l'URL dell'argomento Q incorporabile nel server delle applicazioni.

Quando un utente accede all'applicazione, l'applicazione assume il ruolo IAM per conto dell'utente. Quindi l'app 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. 

Per ulteriori informazioni, consulta [https://docs.aws.amazon.com/quicksight/latest/APIReference/AnonymousUserQSearchBarEmbeddingConfiguration.html](https://docs.aws.amazon.com/quicksight/latest/APIReference/AnonymousUserQSearchBarEmbeddingConfiguration.html).

### Java
<a name="embedded-q-bar-for-anonymous-users-java"></a>

```
        import java.util.List;
        import com.amazonaws.auth.AWSCredentials;
        import com.amazonaws.auth.AWSCredentialsProvider;
        import com.amazonaws.auth.BasicAWSCredentials;
        import com.amazonaws.regions.Regions;
        import com.amazonaws.services.quicksight.AmazonQuickSight;
        import com.amazonaws.services.quicksight.AmazonQuickSightClientBuilder;
        import com.amazonaws.services.quicksight.model.AnonymousUserQSearchBarEmbeddingConfiguration;
        import com.amazonaws.services.quicksight.model.AnonymousUserEmbeddingExperienceConfiguration;
        import com.amazonaws.services.quicksight.model.GenerateEmbedUrlForAnonymousUserRequest;
        import com.amazonaws.services.quicksight.model.GenerateEmbedUrlForAnonymousUserResult;
        import com.amazonaws.services.quicksight.model.SessionTag;


        /**
        * Class to call QuickSight AWS SDK to generate embed url for anonymous user.
        */
        public class GenerateEmbedUrlForAnonymousUserExample {

            private final AmazonQuickSight quickSightClient;

            public GenerateEmbedUrlForAnonymousUserExample() {
                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 GenerateEmbedUrlForAnonymousUser(
                final String accountId, // YOUR AWS ACCOUNT ID
                final String initialTopicId, // Q TOPIC ID TO WHICH THE CONSTRUCTED URL POINTS AND SEARCHBAR PREPOPULATES INITIALLY
                final String namespace, // ANONYMOUS EMBEDDING REQUIRES SPECIFYING A VALID NAMESPACE FOR WHICH YOU WANT THE EMBEDDING URL
                final List<String> authorizedResourceArns, // Q SEARCHBAR TOPIC ARN LIST TO EMBED
                final List<String> allowedDomains, // RUNTIME ALLOWED DOMAINS FOR EMBEDDING
                final List<SessionTag> sessionTags // SESSION TAGS USED FOR ROW-LEVEL SECURITY
            ) throws Exception {
                AnonymousUserEmbeddingExperienceConfiguration experienceConfiguration = new AnonymousUserEmbeddingExperienceConfiguration();
                AnonymousUserQSearchBarEmbeddingConfiguration qSearchBarConfiguration = new AnonymousUserQSearchBarEmbeddingConfiguration();
                qSearchBarConfiguration.setInitialTopicId(initialTopicId);
                experienceConfiguration.setQSearchBar(qSearchBarConfiguration);

                GenerateEmbedUrlForAnonymousUserRequest generateEmbedUrlForAnonymousUserRequest = new GenerateEmbedUrlForAnonymousUserRequest()
                    .withAwsAccountId(accountId)
                    .withNamespace(namespace)
                    .withAuthorizedResourceArns(authorizedResourceArns)
                    .withExperienceConfiguration(experienceConfiguration)
                    .withSessionTags(sessionTags)
                    .withSessionLifetimeInMinutes(600L); // OPTIONAL: VALUE CAN BE [15-600]. DEFAULT: 600
                    .withAllowedDomains(allowedDomains);

                GenerateEmbedUrlForAnonymousUserResult qSearchBarEmbedUrl = quickSightClient.generateEmbedUrlForAnonymousUser(generateEmbedUrlForAnonymousUserRequest);

                return qSearchBarEmbedUrl.getEmbedUrl();
            }

        }
```

### JavaScript
<a name="embedded-q-bar-for-anonymous-users-js"></a>

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

function generateEmbedUrlForAnonymousUser(
    accountId, // YOUR AWS ACCOUNT ID
    initialTopicId, // Q TOPIC ID TO WHICH THE CONSTRUCTED URL POINTS
    quicksightNamespace, // VALID NAMESPACE WHERE YOU WANT TO DO NOAUTH EMBEDDING
    authorizedResourceArns, // Q SEARCHBAR TOPIC ARN LIST TO EMBED
    allowedDomains, // RUNTIME ALLOWED DOMAINS FOR EMBEDDING
    sessionTags, // SESSION TAGS USED FOR ROW-LEVEL SECURITY
    generateEmbedUrlForAnonymousUserCallback, // SUCCESS CALLBACK METHOD
    errorCallback // ERROR CALLBACK METHOD
    ) {
    const experienceConfiguration = {
        "QSearchBar": {
            "InitialTopicId": initialTopicId // TOPIC ID CAN BE FOUND IN THE URL ON THE TOPIC AUTHOR PAGE
        }
    };
    
    const generateEmbedUrlForAnonymousUserParams = {
        "AwsAccountId": accountId,
        "Namespace": quicksightNamespace,
        "AuthorizedResourceArns": authorizedResourceArns,
        "AllowedDomains": allowedDomains,
        "ExperienceConfiguration": experienceConfiguration,
        "SessionTags": sessionTags,
        "SessionLifetimeInMinutes": 600
    };

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

    quicksightClient.generateEmbedUrlForAnonymousUser(generateEmbedUrlForAnonymousUserParams, 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 THIS API
                    "Access-Control-Allow-Headers": "Content-Type"
                },
                "body": JSON.stringify(data),
                "isBase64Encoded": false
            }
            generateEmbedUrlForAnonymousUserCallback(result);
        }
    });
}
```

### Python3
<a name="embedded-q-bar-for-anonymous-users-py"></a>

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

# Create QuickSight and STS clients
quicksightClient = boto3.client('quicksight',region_name='us-west-2')
sts = boto3.client('sts')

# Function to generate embedded URL for anonymous user
# accountId: YOUR AWS ACCOUNT ID
# quicksightNamespace: VALID NAMESPACE WHERE YOU WANT TO DO NOAUTH EMBEDDING
# authorizedResourceArns: TOPIC ARN LIST TO EMBED
# allowedDomains: RUNTIME ALLOWED DOMAINS FOR EMBEDDING
# experienceConfiguration: configuration which specifies the TOPIC ID to point URL to
# sessionTags: SESSION TAGS USED FOR ROW-LEVEL SECURITY
def generateEmbedUrlForAnonymousUser(accountId, quicksightNamespace, authorizedResourceArns, allowedDomains, experienceConfiguration, sessionTags):
    try:
        response = quicksightClient.generate_embed_url_for_anonymous_user(
            AwsAccountId = accountId,
            Namespace = quicksightNamespace,
            AuthorizedResourceArns = authorizedResourceArns,
            AllowedDomains = allowedDomains,
            ExperienceConfiguration = experienceConfiguration,
            SessionTags = sessionTags,
            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
<a name="embedded-q-bar-for-anonymous-users-nodejs"></a>

L'esempio seguente mostra JavaScript (Node.js) che puoi usare sul server dell'app per generare l'URL per la 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 quicksightClient = new AWS.Service({
    apiConfig: require('./quicksight-2018-04-01.min.json'),
    region: 'us-east-1',
});

quicksightClient.generateEmbedUrlForAnonymousUser({
    'AwsAccountId': '111122223333',
    'Namespace': 'DEFAULT'
    'AuthorizedResourceArns': '["topic-arn-topicId1","topic-arn-topicId2"]',
    'AllowedDomains': allowedDomains,
    'ExperienceConfiguration': { 
        'QSearchBar': {
            'InitialTopicId': 'U4zJMVZ2n2stZflc8Ou3iKySEb3BEV6f'
        }
    },
    'SessionTags': '["Key": tag-key-1,"Value": tag-value-1,{"Key": tag-key-1,"Value": tag-value-1}]',
    'SessionLifetimeInMinutes': 15
}, 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://quicksightdomain/embed/12345/dashboards/67890/sheets/12345/visuals/67890...',
        RequestId: '7bee030e-f191-45c4-97fe-d9faf0e03713' 
    }
```

### .NET/C\$1
<a name="embedded-q-bar-for-anonymous-users-cs"></a>

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

**Example**  

```
using System;
using Amazon.QuickSight;
using Amazon.QuickSight.Model;

namespace GenerateQSearchBarEmbedUrlForAnonymousUser
{
    class Program
    {
        static void Main(string[] args)
        {
            var quicksightClient = new AmazonQuickSightClient(
                AccessKey,
                SecretAccessKey,
                SessionToken,
                Amazon.RegionEndpoint.USEast1);
            try
            {
                AnonymousUserQSearchBarEmbeddingConfiguration anonymousUserQSearchBarEmbeddingConfiguration
                    = new AnonymousUserQSearchBarEmbeddingConfiguration
                    {
                        InitialTopicId = "U4zJMVZ2n2stZflc8Ou3iKySEb3BEV6f"
                    };
                AnonymousUserEmbeddingExperienceConfiguration anonymousUserEmbeddingExperienceConfiguration
                    = new AnonymousUserEmbeddingExperienceConfiguration
                    {
                        QSearchBar = anonymousUserQSearchBarEmbeddingConfiguration
                    }; 
                
                Console.WriteLine(
                    quicksightClient.GenerateEmbedUrlForAnonymousUserAsync(new GenerateEmbedUrlForAnonymousUserRequest
                    {
                        AwsAccountId = "111122223333",
                        Namespace = "DEFAULT",
                        AuthorizedResourceArns '["topic-arn-topicId1","topic-arn-topicId2"]',
                        AllowedDomains = allowedDomains,
                        ExperienceConfiguration = anonymousUserEmbeddingExperienceConfiguration,
                        SessionTags = '["Key": tag-key-1,"Value": tag-value-1,{"Key": tag-key-1,"Value": tag-value-1}]',
                        SessionLifetimeInMinutes = 15,
                    }).Result.EmbedUrl
                );
            } catch (Exception ex) {
                Console.WriteLine(ex.Message);
            }
        }
    }
}
```

### AWS CLI
<a name="embedded-q-bar-for-anonymous-users-cli"></a>

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:GenerateEmbedUrlForAnonymousUser`.

```
aws sts assume-role \
     --role-arn "arn:aws:iam::111122223333:role/embedding_quicksight_q_search_bar_role" \
     --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. Per 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_q_search_bar_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. 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. 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 `generate-embed-url-for-anynymous-user` 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 generate-embed-url-for-anonymous-user \
--aws-account-id 111122223333 \
--namespace default-or-something-else \
--authorized-resource-arns '["topic-arn-topicId1","topic-arn-topicId2"]' \
--allowed-domains '["domain1","domain2"]' \
--experience-configuration 'QSearchBar={InitialTopicId="topicId1"}' \
--session-tags '["Key": tag-key-1,"Value": tag-value-1,{"Key": tag-key-1,"Value": tag-value-1}]' \
--session-lifetime-in-minutes 15
```

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

## Fase 3: Incorporamento dell'URL della barra di ricerca Q
<a name="embedded-q-bar-for-anonymous-users-step-3"></a>

**Nota**  
La barra di ricerca integrata di Amazon Quick Sight Q offre la classica esperienza di domande e risposte di Amazon Quick Sight. Amazon Quick Sight si integra con Amazon Q Business per lanciare una nuova esperienza di domande e risposte generative. Si consiglia agli sviluppatori di utilizzare la nuova esperienza Domande e risposte generative. Per ulteriori informazioni sull'esperienza di domande e risposte generative integrata, consulta [Incorporare Amazon Q nell'esperienza di domande e risposte generative di Amazon Quick Sight](https://docs.aws.amazon.com/quicksight/latest/user/embedding-gen-bi.html).

Nella sezione seguente, puoi scoprire come incorporare l'URL della barra di ricerca Q dalla fase 3 nella pagina del sito web o dell'applicazione. Puoi farlo con l'[SDK di incorporamento di Amazon Quick Sight](https://www.npmjs.com/package/amazon-quicksight-embedding-sdk) ()JavaScript. Con il kit SDK, puoi procedere come segue: 
+ Posiziona la barra di ricerca Q su una pagina HTML.
+ Passa i parametri nella barra di ricerca Q.
+ Gestisci stati di errore con messaggi personalizzati per l'applicazione.

Chiama l'operazione API `GenerateEmbedUrlForAnonymousUser` per generare 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 valore `auth_code` che consente una sessione di single sign-on. 

Di seguito viene mostrata una risposta di esempio da `generate-embed-url-for-anonymous-user`.

```
//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://quicksightdomain/embedding/12345/q/search...",
     "RequestId": "7bee030e-f191-45c4-97fe-d9faf0e03713"
}
```

Incorpora la barra di ricerca Q 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. 

Per fare ciò, assicurati che il dominio su cui ospitare la barra di ricerca Q incorporata sia *nell'elenco dei domini consentiti*, l'elenco dei domini approvati per il tuo abbonamento Amazon Quick Sight. Questo requisito protegge i tuoi dati impedendo ai domini non approvati di ospitare la barra di ricerca Q incorporata. Per ulteriori informazioni sull'aggiunta di domini per una barra di ricerca Q incorporata, consulta [Gestione dei domini](https://docs.aws.amazon.com/quicksight/latest/user/manage-qs-domains-and-embedding.html) e incorporamento.

Quando usi Amazon Quick Sight Embedding SDK, la barra di ricerca Q sulla tua pagina viene ridimensionata dinamicamente in base allo stato. Utilizzando Amazon Quick Sight Embedding SDK, puoi anche controllare i parametri all'interno della barra di ricerca Q 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.

### SDK 2.0
<a name="embedded-q-bar-for-anonymous-users-sdkv2"></a>

```
<!DOCTYPE html>
<html>

    <head>
        <title>Q Search Bar Embedding Example</title>
        <script src="https://unpkg.com/amazon-quicksight-embedding-sdk@2.0.0/dist/quicksight-embedding-js-sdk.min.js"></script>
        <script type="text/javascript">
            const embedQSearchBar = async() => {    
                const {
                    createEmbeddingContext,
                } = QuickSightEmbedding;

                const embeddingContext = await createEmbeddingContext({
                    onChange: (changeEvent, metadata) => {
                        console.log('Context received a change', changeEvent, metadata);
                    },
                });

                const frameOptions = {
                    url: "<YOUR_EMBED_URL>", // replace this value with the url generated via embedding API
                    container: '#experience-container',
                    height: "700px",
                    width: "1000px",
                    onChange: (changeEvent, metadata) => {
                        switch (changeEvent.eventName) {
                            case 'FRAME_MOUNTED': {
                                console.log("Do something when the experience frame is mounted.");
                                break;
                            }
                            case 'FRAME_LOADED': {
                                console.log("Do something when the experience frame is loaded.");
                                break;
                            }
                        }
                    },
                };

                const contentOptions = {
                    hideTopicName: false, 
                    theme: '<YOUR_THEME_ID>',
                    allowTopicSelection: true,
                    onMessage: async (messageEvent, experienceMetadata) => {
                        switch (messageEvent.eventName) {
                            case 'Q_SEARCH_OPENED': {
                                console.log("Do something when Q Search content expanded");
                                break;
                            }
                            case 'Q_SEARCH_CLOSED': {
                                console.log("Do something when Q Search content collapsed");
                                break;
                            }
                            case 'Q_SEARCH_SIZE_CHANGED': {
                                console.log("Do something when Q Search size changed");
                                break;
                            }
                            case 'CONTENT_LOADED': {
                                console.log("Do something when the Q Search is loaded.");
                                break;
                            }
                            case 'ERROR_OCCURRED': {
                                console.log("Do something when the Q Search fails loading.");
                                break;
                            }
                        }
                    }
                };
                const embeddedDashboardExperience = await embeddingContext.embedQSearchBar(frameOptions, contentOptions);
            };
        </script>
    </head>

    <body onload="embedQSearchBar()">
        <div id="experience-container"></div>
    </body>

</html>
```

### SDK 1.0
<a name="embedded-q-bar-for-anonymous-users-sdkv1"></a>

```
<!DOCTYPE html>
<html>

    <head>
        <title>QuickSight Q Search Bar Embedding</title>
        <script src="https://unpkg.com/amazon-quicksight-embedding-sdk@1.18.0/dist/quicksight-embedding-js-sdk.min.js"></script>
        <script type="text/javascript">
            var session

            function onError(payload) {
                console.log("Do something when the session fails loading");
            }

            function onOpen() {
                console.log("Do something when the Q search bar opens");
            }

            function onClose() {
                console.log("Do something when the Q search bar closes");
            }

            function embedQSearchBar() {
                var containerDiv = document.getElementById("embeddingContainer");
                var options = {
                    url: "https://us-east-1.quicksight.aws.amazon.com/sn/dashboards/dashboardId?isauthcode=true&identityprovider=quicksight&code=authcode", // replace this dummy url with the one generated via embedding API
                    container: containerDiv,
                    width: "1000px",
                    locale: "en-US",
                    qSearchBarOptions: {
                        expandCallback: onOpen,
                        collapseCallback: onClose,
                        iconDisabled: false,
                        topicNameDisabled: false, 
                        themeId: 'bdb844d0-0fe9-4d9d-b520-0fe602d93639',
                        allowTopicSelection: true
                    }
                };
                session = QuickSightEmbedding.embedQSearchBar(options);
                session.on("error", onError);
            }

            function onCountryChange(obj) {
                session.setParameters({country: obj.value});
            }
        </script>
    </head>

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

</html>
```

Affinché questo esempio funzioni, assicurati di utilizzare l'SDK Amazon Quick Sight Embedding per caricare la barra di ricerca Q 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
  ```

## Funzionalità opzionali di incorporamento della barra di ricerca Amazon Quick Sight Q
<a name="embedded-q-bar-for-anonymous-users-step-4"></a>

**Nota**  
La barra di ricerca integrata di Amazon Quick Sight Q offre la classica esperienza di domande e risposte di Amazon Quick Sight. Amazon Quick Sight si integra con Amazon Q Business per lanciare una nuova esperienza di domande e risposte generative. Si consiglia agli sviluppatori di utilizzare la nuova esperienza Domande e risposte generative. Per ulteriori informazioni sull'esperienza di domande e risposte generative integrata, consulta [Incorporare Amazon Q nell'esperienza di domande e risposte generative di Amazon Quick Sight](https://docs.aws.amazon.com/quicksight/latest/user/embedding-gen-bi.html).

Le seguenti funzionalità facoltative sono disponibili per la barra di ricerca Q incorporata utilizzando l'SDK di incorporamento. 

### Richiamo delle operazioni della barra di ricerca Q
<a name="w2aac35c27c21c43c31c17c21b7"></a>

Le seguenti opzioni sono supportate solo per l'incorporamento della barra di ricerca Q. 
+ Imposta una domanda sulla barra di ricerca Q: questa funzione invia una domanda alla barra di ricerca Q e interroga immediatamente la domanda. Inoltre, apre automaticamente la finestra a comparsa di Q.

  ```
  qBar.setQBarQuestion('show me monthly revenue');
  ```
+ Chiudi il popover Q: questa funzione chiude la finestra a comparsa di Q e riporta l'iframe alla dimensione originale della barra di ricerca Q.

  ```
  qBar.closeQPopover();
  ```

Per ulteriori informazioni, consulta l'[SDK di incorporamento di Amazon Quick Sight](https://github.com/awslabs/amazon-quicksight-embedding-sdk).

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