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

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