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

# Analisi integrate per Amazon Quick Sight
<a name="embedded-analytics"></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 tramite le vecchie operazioni API, consulta [Incorporamento dell'analisi utilizzando le operazioni API GetDashboardEmbedURL e GetSessionEmbedURL](embedded-analytics-deprecated.md).


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


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

Con l'analisi integrata di Amazon Quick Sight, puoi integrare senza problemi esperienze basate sui dati nelle tue applicazioni software. Puoi personalizzare i componenti incorporati in base al tuo marchio. Questa funzionalità offre la potenza di Amazon Quick Sight agli utenti finali, dove possono analizzare e interagire con i dati senza mai uscire dall'applicazione. Migliorare l'esperienza utente riducendo la complessità cognitiva offre agli utenti una migliore opportunità di comprensione e una maggiore efficacia. 

Amazon Quick Sight supporta l'incorporamento di questi elementi: 
+ Console Amazon Quick Sight (esperienza di creazione completa per gli utenti registrati)
+ Dashboard e immagini di Amazon Quick Sight (per utenti registrati, utenti anonimi, utenti finali pubblici)
+ Barra di ricerca Amazon Quick Sight Q (per utenti registrati e utenti anonimi)

Con una console Amazon Quick Sight integrata, puoi incorporare l'esperienza Amazon Quick Sight completa. In questo modo è possibile utilizzare gli strumenti di creazione di Amazon Quick Sight come parte dell'applicazione, anziché nel contesto di un Console di gestione AWS sito Web indipendente. Gli utenti di una console Amazon Quick Sight integrata devono essere registrati come autori o amministratori di Amazon Quick Sight nel tuo. Account AWS Devono inoltre essere autenticati nello stesso Account AWS, utilizzando uno qualsiasi dei metodi di autenticazione supportati da Amazon Quick Sight. 

Con una dashboard o un elemento visivo Amazon Quick Sight incorporato, i lettori ottengono le stesse funzionalità e interattività di cui usufruiscono in una dashboard o in un'immagine pubblicata. Per utilizzare un pannello di controllo o un elemento visivo incorporato, i lettori (visualizzatori) possono includere quanto segue:
+ Utenti Amazon Quick Sight autenticati nel tuo account Account AWS con qualsiasi metodo supportato da Amazon Quick Sight.
+ Visitatori non autenticati di un sito web o di un'applicazione: questa opzione richiede pacchetti di sessione con tariffazione della capacità. Per informazioni sui tipi di abbonamento, consulta [Comprendere gli abbonamenti e i ruoli di Amazon Quick Sight](https://docs.aws.amazon.com/quicksight/latest/user/user-types.html#subscription-role-mapping).
+ Più utenti finali visualizzano un display su monitor o schermi di grandi dimensioni tramite accesso programmatico.

Se la tua app risiede anche in AWS, non è necessario che l'app risieda nello Account AWS stesso abbonamento Amazon Quick Sight. Tuttavia, l'app deve essere in grado di assumere il ruolo AWS Identity and Access Management (IAM) che usi per le chiamate API. 

Prima di incorporare i contenuti, assicurati di utilizzare l'edizione Amazon Quick Sight Enterprise nel luogo in Account AWS cui intendi utilizzare l'incorporamento. 

L'incorporamento di Amazon Quick Sight è disponibile in tutte le aree supportate Regioni AWS. 

**Topics**
+ [

# Incorporare l'analisi di Amazon Quick Sight nelle tue applicazioni
](embedding-overview.md)
+ [

# Incorporamento di risorse Amazon Quick Sight personalizzate nella tua applicazione
](customize-and-personalize-embedded-analytics.md)
+ [

# Incorporamento di elementi visivi e dashboard di Amazon Quick Sight con un codice di incorporamento in 1 clic
](1-click-embedding.md)
+ [

# Integrazione con Amazon Quick Sight APIs
](embedded-analytics-api.md)

# Incorporare l'analisi di Amazon Quick Sight nelle tue applicazioni
<a name="embedding-overview"></a>


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

Per incorporare l'analisi, puoi eseguire l'API di incorporamento di Amazon Quick Sight per generare il codice di incorporamento. In alternativa, per le dashboard, puoi copiare un codice di incorporamento quando condividi la dashboard in Amazon Quick Sight. Ciascuna opzione è descritta di seguito.

## Incorporamento con 1 clic per gli utenti registrati
<a name="embedding-overview-1-click"></a>

Quando condividi un pannello di controllo con utenti registrati nel tuo account, puoi copiare un codice di incorporamento per il pannello e incollarlo nel codice HTML dell'applicazione interna. 

L'uso dell'incorporamento aziendale con 1 clic è ideale quando desideri incorporare una dashboard di Amazon Quick Sight in un'applicazione interna in cui gli utenti devono autenticarsi. Quando copi il codice di incorporamento, ottieni un codice di incorporamento statico che non cambia.

Per ulteriori informazioni, consulta [Incorporamento di immagini e dashboard di Amazon Quick Sight per gli utenti registrati con un codice di incorporamento in 1 clic](embedded-analytics-1-click.md).

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

L'incorporamento con l'API Amazon Quick Sight è ideale quando desideri incorporare l'esperienza Amazon Quick Sight in un'applicazione interna in cui gli utenti devono autenticarsi o in un'applicazione esterna a cui chiunque può accedere. Quando si utilizzano le operazioni dell'API di incorporamento per generare un codice di incorporamento, si ottiene un codice monouso.

Per ulteriori informazioni, consulta [Integrazione con Amazon Quick Sight APIs](embedded-analytics-api.md).

# Incorporamento di risorse Amazon Quick Sight personalizzate nella tua applicazione
<a name="customize-and-personalize-embedded-analytics"></a>

Puoi utilizzare l'analisi integrata di Amazon Quick Sight per incorporare nella tua applicazione risorse Amazon Quick Sight personalizzate per soddisfare le tue esigenze aziendali. Per quanto riguarda le dashboard e gli elementi visivi incorporati, gli autori di Amazon Quick Sight possono aggiungere filtri e approfondimenti a cui i lettori possono accedere mentre navigano nella dashboard o nell'immagine. Gli sviluppatori di Amazon Quick Sight possono anche utilizzare Amazon Quick Sight SDKs per creare integrazioni più strette tra le loro applicazioni SaaS e le risorse integrate di Amazon Quick Sight per aggiungere azioni di callback dei datapoint alle immagini su una dashboard in fase di esecuzione.

Per ulteriori informazioni su Amazon Quick Sight SDKs, consulta `amazon-quicksight-embedding-sdk` on [GitHub](https://github.com/awslabs/amazon-quicksight-embedding-sdk)o [NPM](https://www.npmjs.com/package/amazon-quicksight-embedding-sdk).

Di seguito, puoi trovare le descrizioni su come utilizzare Amazon Quick Sight SDKs per personalizzare le analisi integrate di Amazon Quick Sight.

**Topics**
+ [

# Aggiungere azioni di callback incorporate in fase di esecuzione in Amazon Quick Sight
](embedding-custom-actions-callback.md)
+ [

# Filtraggio dei dati in fase di esecuzione per pannelli di controllo e immagini integrati di Amazon Quick Sight
](embedding-runtime-filtering.md)
+ [

# Personalizza l'aspetto dei pannelli di controllo e degli elementi visivi incorporati di Amazon Quick Sight
](embedding-runtime-theming.md)
+ [

# Utilizzo dell'SDK Amazon Quick Sight Embedding per abilitare collegamenti condivisibili a visualizzazioni di dashboard integrate
](embedded-view-sharing.md)

# Aggiungere azioni di callback incorporate in fase di esecuzione in Amazon Quick Sight
<a name="embedding-custom-actions-callback"></a>

Usa le azioni di callback integrate nei datapoint per creare integrazioni più strette tra la tua applicazione SaaS (Software as a Service) e i pannelli visivi e i pannelli di controllo incorporati di Amazon Quick Sight. Gli sviluppatori possono registrare punti dati da richiamare con l'SDK di incorporamento Amazon Quick Sight. Quando si registra un'azione di callback per un elemento visivo, i lettori possono selezionare un punto dati sull'elemento per ricevere una callback che fornisce dati specifici per il punto dati selezionato. Queste informazioni possono essere utilizzate per contrassegnare i record chiave, compilare dati non elaborati specifici del punto dati, acquisire record e compilare dati per i processi di back-end.

Le callback incorporate non sono supportate per contenuti visivi, caselle di testo o approfondimenti personalizzati.

Prima di iniziare a registrare i punti dati per la callback, aggiorna l'SDK di incorporamento alla versione 2.3.0. Per ulteriori informazioni sull'utilizzo di Amazon Quick Sight Embedding SDK, consulta la [amazon-quicksight-embedding-sdk](https://github.com/awslabs/amazon-quicksight-embedding-sdk)pagina. GitHub

Un callback datapoint può essere registrato su uno o più elementi visivi in fase di esecuzione tramite Amazon Quick Sight SDK. Puoi anche registrare un callback datapoint per qualsiasi interazione supportata dalla struttura dell'API. [VisualCustomAction](https://docs.aws.amazon.com/quicksight/latest/APIReference/API_VisualCustomAction.html) Ciò consente alla callback di punti dati di iniziare quando l'utente seleziona il punto dati sull'elemento visivo o quando il punto dati viene selezionato dal relativo menu contestuale. L'esempio seguente registra una callback di punti dati che il lettore avvia quando seleziona un punto dati sull'elemento visivo.

```
/const MY_GET_EMBED_URL_ENDPOINT =
  "https://my.api.endpoint.domain/MyGetEmbedUrlApi"; // Sample URL

// The dashboard id to embed
const MY_DASHBOARD_ID = "my-dashboard"; // Sample ID

// The container element in your page that will have the embedded dashboard
const MY_DASHBOARD_CONTAINER = "#experience-container"; // Sample ID

// SOME HELPERS

const ActionTrigger = {
  DATA_POINT_CLICK: "DATA_POINT_CLICK",
  DATA_POINT_MENU: "DATA_POINT_MENU",
};

const ActionStatus = {
  ENABLED: "ENABLED",
  DISABLED: "DISABLED",
};

// This function makes a request to your endpoint to obtain an embed url for a given dashboard id
// The example implementation below assumes the endpoint takes dashboardId as request data
// and returns an object with EmbedUrl property
const myGetEmbedUrl = async (dashboardId) => {
  const apiOptions = {
    dashboardId,
  };
  const apiUrl = new URL(MY_GET_EMBED_URL_ENDPOINT);
  apiUrl.search = new URLSearchParams(apiOptions).toString();
  const apiResponse = await fetch(apiUrl.toString());
  const apiResponseData = await apiResponse.json();
  return apiResponseData.EmbedUrl;
};

// This function constructs a custom action object
const myConstructCustomActionModel = (
  customActionId,
  actionName,
  actionTrigger,
  actionStatus
) => {
  return {
    Name: actionName,
    CustomActionId: customActionId,
    Status: actionStatus,
    Trigger: actionTrigger,
    ActionOperations: [
      {
        CallbackOperation: {
          EmbeddingMessage: {},
        },
      },
    ],
  };
};

// This function adds a custom action on the first visual of first sheet of the embedded dashboard
const myAddVisualActionOnFirstVisualOfFirstSheet = async (
  embeddedDashboard
) => {
  // 1. List the sheets on the dashboard
  const { SheetId } = (await embeddedDashboard.getSheets())[0];
  // If you'd like to add action on the current sheet instead, you can use getSelectedSheetId method
  // const SheetId = await embeddedDashboard.getSelectedSheetId();

  // 2. List the visuals on the specified sheet
  const { VisualId } = (await embeddedDashboard.getSheetVisuals(SheetId))[0];

  // 3. Add the custom action to the visual
  try {
    const customActionId = "custom_action_id"; // Sample ID
    const actionName = "Flag record"; // Sample name
    const actionTrigger = ActionTrigger.DATA_POINT_CLICK; // or ActionTrigger.DATA_POINT_MENU
    const actionStatus = ActionStatus.ENABLED;
    const myCustomAction = myConstructCustomActionModel(
      customActionId,
      actionName,
      actionTrigger,
      actionStatus
    );
    const response = await embeddedDashboard.addVisualActions(
      SheetId,
      VisualId,
      [myCustomAction]
    );
    if (!response.success) {
      console.log("Adding visual action failed", response.errorCode);
    }
  } catch (error) {
    console.log("Adding visual action failed", error);
  }
};

const parseDatapoint = (visualId, datapoint) => {
  datapoint.Columns.forEach((Column, index) => {
    // FIELD | METRIC
    const columnType = Object.keys(Column)[0];

    // STRING | DATE | INTEGER | DECIMAL
    const valueType = Object.keys(Column[columnType])[0];
    const { Column: columnMetadata } = Column[columnType][valueType];

    const value = datapoint.RawValues[index][valueType];
    const formattedValue = datapoint.FormattedValues[index];

    console.log(
      `Column: ${columnMetadata.ColumnName} has a raw value of ${value}
           and formatted value of ${formattedValue.Value} for visual: ${visualId}`
    );
  });
};

// This function is used to start a custom workflow after the end user selects a datapoint
const myCustomDatapointCallbackWorkflow = (callbackData) => {
  const { VisualId, Datapoints } = callbackData;

  parseDatapoint(VisualId, Datapoints);
};

// EMBEDDING THE DASHBOARD

const main = async () => {
  // 1. Get embed url
  let url;
  try {
    url = await myGetEmbedUrl(MY_DASHBOARD_ID);
  } catch (error) {
    console.log("Obtaining an embed url failed");
  }

  if (!url) {
    return;
  }

  // 2. Create embedding context
  const embeddingContext = await createEmbeddingContext();

  // 3. Embed the dashboard
  const embeddedDashboard = await embeddingContext.embedDashboard(
    {
      url,
      container: MY_DASHBOARD_CONTAINER,
      width: "1200px",
      height: "300px",
      resizeHeightOnSizeChangedEvent: true,
    },
    {
      onMessage: async (messageEvent) => {
        const { eventName, message } = messageEvent;
        switch (eventName) {
          case "CONTENT_LOADED": {
            await myAddVisualActionOnFirstVisualOfFirstSheet(embeddedDashboard);
            break;
          }
          case "CALLBACK_OPERATION_INVOKED": {
            myCustomDatapointCallbackWorkflow(message);
            break;
          }
        }
      },
    }
  );
};

main().catch(console.error);
```

È inoltre possibile configurare l'esempio precedente per avviare la callback di punti dati quando l'utente apre il menu contestuale. Per l'esempio precedente, imposta il valore di `actionTrigger` su `ActionTrigger.DATA_POINT_MENU`.

Una volta registrata la callback di punti dati viene applicata alla maggior parte dei punti dati sugli elementi visivi specificati. Le callback non si applicano ai totali o ai subtotali degli elementi visivi. Quando un lettore interagisce con un datapoint, viene `CALLBACK_OPERATION_INVOKED` inviato un messaggio all'SDK di incorporamento di Amazon Quick Sight. Questo messaggio viene acquisito dal gestore `onMessage`. Il messaggio contiene i valori non elaborati e visualizzati per l'intera riga di dati associata al punto dati selezionato. Contiene anche i metadati delle colonne per tutte le colonne dell'elemento visivo in cui è contenuto il punto dati. Di seguito è illustrato un esempio di messaggio `CALLBACK_OPERATION_INVOKED`.

```
{
   CustomActionId: "custom_action_id",
   DashboardId: "dashboard_id",
   SheetId: "sheet_id",
   VisualId: "visual_id",
   DataPoints: [
        {
            RawValues: [
                    {
                        String: "Texas" // 1st raw value in row
                    },
                    {
                        Integer: 1000 // 2nd raw value in row
                    }
            ],
            FormattedValues: [
                    {Value: "Texas"}, // 1st formatted value in row
                    {Value: "1,000"} // 2nd formatted value in row
            ],
            Columns: [
                    { // 1st column metadata
                        Dimension: {
                            String: {
                                Column: {
                                    ColumnName: "State",
                                    DatsetIdentifier: "..."
                                }
                            }
                        }
                    },
                    { // 2nd column metadata
                        Measure: {
                            Integer: {
                                Column: {
                                    ColumnName: "Cancelled",
                                    DatsetIdentifier: "..."
                                },
                                AggregationFunction: {
                                    SimpleNumericalAggregation: "SUM"
                                }
                            }
                        }
                    }
            ]
        }
   ]
}
```

# Filtraggio dei dati in fase di esecuzione per pannelli di controllo e immagini integrati di Amazon Quick Sight
<a name="embedding-runtime-filtering"></a>

Puoi utilizzare i metodi di filtro nell'SDK di incorporamento Amazon Quick Sight per sfruttare la potenza dei filtri Amazon Quick Sight all'interno della tua applicazione Software as a Service (SaaS) in fase di esecuzione. I filtri di runtime consentono agli imprenditori di integrare la propria applicazione con i pannelli di controllo e gli elementi visivi incorporati di Amazon Quick Sight. A tale scopo, crea controlli di filtro personalizzati nell'applicazione e applicate filtri preimpostati in base ai dati dell'applicazione. Quindi, gli sviluppatori possono personalizzare le configurazioni dei filtri per gli utenti finali durante il runtime.

Gli sviluppatori possono creare, interrogare, aggiornare e rimuovere i filtri Amazon Quick Sight su un pannello di controllo o un elemento visivo incorporato dalla loro applicazione con Amazon Quick Sight Embedding SDK. Crea oggetti filtro Amazon Quick Sight nella tua applicazione con il modello di [FilterGroup](https://docs.aws.amazon.com/quicksight/latest/APIReference/API_FilterGroup.html)dati e applicali a dashboard e immagini incorporate utilizzando i metodi di filtro. Per ulteriori informazioni sull'utilizzo di Amazon Quick Sight Embedding SDK, consulta la [amazon-quicksight-embedding-sdk](https://github.com/awslabs/amazon-quicksight-embedding-sdk)pagina. GitHub

**Prerequisiti**

Prima di iniziare, assicurati di utilizzare Amazon Quick Sight Embedding SDK versione 2.5.0 o successiva.

## Concetti e terminologia
<a name="runtime-filtering-terminology"></a>

La seguente terminologia può essere utile quando lavori con il filtro di runtime incorporato.
+ *Gruppo di filtri*: un gruppo di filtri individuali. I filtri che si trovano all'interno di un `FilterGroup` vengono introdotti da un operatore OR l'uno con l'altro. I filtri all'interno di a [FilterGroup](https://docs.aws.amazon.com/quicksight/latest/APIReference/API_FilterGroup.html)vengono applicati agli stessi fogli o immagini.
+ *Filtro*: un singolo filtro. Il filtro può essere di tipo di filtro di categoria, numerico o data/ora. Per ulteriori informazioni sui filtri, consulta [Filtri](https://docs.aws.amazon.com/quicksight/latest/APIReference/API_Filter.html).

## Configurazione
<a name="runtime-filtering-setup"></a>

Prima di cominciare, assicurati di disporre delle seguenti risorse e informazioni.
+ L'ID del foglio a cui si desidera applicare l'ambito di `FilterGroup`. Questo può essere ottenuto con il metodo `getSheets` dell'SDK Embedding.
+ L'identificativo di set di dati e colonna da filtrare. Ciò può essere ottenuto tramite l'operazione [DescribeDashboardDefinition](https://docs.aws.amazon.com/APIReference/API_DescribeDashboardDefinition.html)API.

  A seconda del tipo di colonna utilizzato, potrebbero esserci restrizioni sui tipi di filtri che possono essere aggiunti a una risorsa incorporata. Per ulteriori informazioni sulle restrizioni dei filtri, consulta [Filtri](https://docs.aws.amazon.com/quicksight/latest/APIReference/API_Filter.html).
+ L'ID dell'elemento visivo dell'oggetto visivo a cui applicare l'ambito di `FilterGroup`, se applicabile. Questo può essere ottenuto con il metodo `getSheetVisuals` dell'SDK Embedding.

  Oltre al metodo `getSheetVisuals`, il `FilterGroup` che aggiungi può essere limitato solo al foglio attualmente selezionato.

Per utilizzare questa funzionalità, devi già disporre di una dashboard o di un elemento visivo incorporato nell'applicazione tramite Amazon Quick Sight Embedding SDK. Per ulteriori informazioni sull'utilizzo di Amazon Quick Sight Embedding SDK, consulta la [amazon-quicksight-embedding-sdk](https://github.com/awslabs/amazon-quicksight-embedding-sdk)pagina. GitHub

## Interfaccia del metodo SDK
<a name="runtime-filtering-sdk-interface"></a>

**Metodi getter di incorporamento del pannello di controllo**

La tabella seguente descrive i diversi metodi getter di incorporamento del pannello di controllo che gli sviluppatori possono utilizzare.


| Metodo | Description | 
| --- | --- | 
|  `getFilterGroupsForSheet(sheetId: string) `  |  Restituisce tutto FilterGroups ciò che è attualmente compreso nell'ambito del foglio fornito nel parametro.  | 
|  `getFilterGroupsForVisual(sheetId: string, visualId: string)`  |  Restituisce tutti i `FilterGroups` attualmente compresi nell'ambito del foglio fornito nel parametro.  | 

Se il foglio fornito nel parametro non è il foglio attualmente selezionato del pannello di controllo incorporato, i metodi precedenti restituiscono un errore.

**Metodi getter di incorporamento degli elementi visivi**

La tabella seguente descrive i diversi metodi getter di incorporamento degli elementi visivi che gli sviluppatori possono utilizzare.


| Metodo | Description | 
| --- | --- | 
|  `getFilterGroups()`  |  Restituisce tutti i `FilterGroups` che sono attualmente inclusi nell'elemento visivo incorporato.  | 

**Metodi setter**

La tabella seguente descrive i diversi metodi setter che gli sviluppatori possono utilizzare per l'incorporamento del pannello di controllo o dell'elemento visivo.


| Metodo | Description | 
| --- | --- | 
|  `addFilterGroups(filterGroups: FilterGroup[])`  |  Aggiunge e applica il valore fornito **FilterGroups**alla dashboard o alla grafica incorporata. Un `ResponseMessage` che indica se l'aggiunta è avvenuta correttamente.  | 
|  `updateFilterGroups(filterGroups: FilterGroup[])`  |  Aggiorna `FilterGroups` sull'esperienza incorporata che contiene lo stesso `FilterGroupId` del `FilterGroup` fornito nel parametro. Un `ResponseMessage` che indica se l'aggiornamento è avvenuto correttamente.  | 
|  `removeFilterGroups(filterGroupsOrIds: FilterGroup[] \| string[])`  |  Rimuove l'elemento fornito FilterGroups dal pannello di controllo e restituisce un messaggio `ResponseMessage` che indica se il tentativo di rimozione è riuscito.  | 

Il `FilterGroup` che viene fornito deve essere limitato al foglio o all'elemento visivo incorporato attualmente selezionato.

# Personalizza l'aspetto dei pannelli di controllo e degli elementi visivi incorporati di Amazon Quick Sight
<a name="embedding-runtime-theming"></a>

Puoi utilizzare Amazon Quick Sight Embedding SDK (versione 2.5.0 e successive) per apportare modifiche al tema delle dashboard e degli elementi visivi Amazon Quick Sight incorporati in fase di esecuzione. Il tema Runtime semplifica l'integrazione dell'applicazione Software as a Service (SaaS) con le risorse integrate di Amazon Quick Sight. I temi di runtime ti consentono di sincronizzare il tema dei tuoi contenuti incorporati con i temi dell'applicazione principale in cui sono incorporate le tue risorse Amazon Quick Sight. È inoltre possibile utilizzare il tema del runtime per aggiungere opzioni di personalizzazione per i lettori. Le modifiche ai temi possono essere applicate alle risorse incorporate al momento dell'inizializzazione o per tutta la durata del pannello di controllo o dell'elemento visivo incorporato.

Per ulteriori informazioni sui temi, consulta [Utilizzo di temi in Amazon Quick Sight](themes-in-quicksight.md). Per ulteriori informazioni sull'utilizzo di Amazon Quick Sight Embedding SDK, consulta la [amazon-quicksight-embedding-sdk](https://github.com/awslabs/amazon-quicksight-embedding-sdk)pagina. GitHub

**Prerequisiti**

Prima di iniziare, assicurati di soddisfare i seguenti requisiti.
+ Stai utilizzando Amazon Quick Sight Embedding SDK versione 2.5.0 o successiva.
+ Autorizzazioni per accedere al tema su cui si desidera lavorare. Per concedere le autorizzazioni a un tema in Amazon Quick Sight, effettua una chiamata `UpdateThemePermissions` API o usa l'icona **Condividi** accanto al tema nell'editor di analisi della console Amazon Quick Sight.

## Concetti e terminologia
<a name="runtime-theming-terminology"></a>

La seguente terminologia può essere utile quando lavori con il tema di runtime incorporato.
+ *Tema*: una raccolta di impostazioni che puoi applicare a più analisi e pannelli di controllo che modificano il modo in cui il contenuto viene visualizzato.
+ *ThemeConfiguration*— Un oggetto di configurazione che contiene tutte le proprietà di visualizzazione di un tema.
+ *Sovrascrittura del tema*: un oggetto `ThemeConfiguration` che viene applicato al tema attivo per sovrascrivere alcuni o tutti gli aspetti della visualizzazione del contenuto.
+ *ARN del tema: un* Amazon Resource Name (ARN) che identifica un tema Amazon Quick Sight. Di seguito è riportato un esempio di ARN del tema personalizzato.

  `arn:aws:quicksight:region:account-id:theme/theme-id`

  I temi iniziali forniti da Amazon Quick Sight non hanno una regione nell'ARN del tema. Di seguito è riportato un esempio di ARN del tema iniziale.

  `arn:aws:quicksight::aws:theme/CLASSIC`

## Configurazione
<a name="runtime-theming-setup"></a>

Assicurati di disporre delle informazioni seguenti per iniziare a lavorare con i temi del runtime.
+ Il tema ARNs dei temi che desideri utilizzare. Puoi scegliere un tema esistente oppure crearne uno nuovo. Per ottenere un elenco di tutti i temi e i temi ARNs presenti nel tuo account Amazon Quick Sight, effettua una chiamata all'operazione [ListThemes](https://docs.aws.amazon.com/quicksight/latest/APIReference/API_ListThemes.html)API. Per informazioni sui temi Amazon Quick Sight preimpostati, consulta[Impostazione di un tema predefinito per le analisi di Amazon Quick con Amazon Quick APIs](customizing-quicksight-default-theme.md).
+ Se utilizzi l'incorporamento di utenti registrati, assicurati che l'utente abbia accesso ai temi che desideri utilizzare.

  Se utilizzi l'incorporamento anonimo di utenti, passa un elenco di temi ARNs al `AuthorizedResourceArns` parametro dell'`GenerateEmbedUrlForAnonymousUser`API. Agli utenti anonimi viene concesso l'accesso a qualsiasi tema elencato nel parametro `AuthorizedResourceArns`.

## Interfaccia del metodo SDK
<a name="runtime-theming-sdk-interface"></a>

**Metodi setter**

La tabella seguente descrive i diversi metodi setter che gli sviluppatori possono utilizzare per un tema del runtime.


| Metodo | Description | 
| --- | --- | 
|  `setTheme(themeArn: string)`  |  Sostituisce il tema attivo di un pannello di controllo o di un elemento visivo con un altro tema. Se applicato, la sovrascrittura del tema viene rimossa. Se non hai accesso al tema o se il tema non esiste, viene restituito un errore.  | 
|  `setThemeOverride(themeOverride: ThemeConfiguration)`  |  Imposta un `ThemeConfiguration` dinamico per sovrascrivere il tema attivo corrente. Questo sostituisce la sovrascrittura del tema precedentemente impostato. Tutti i valori che non vengono forniti nel nuovo `ThemeConfiguration` vengono utilizzati di default sui valori del tema correntemente attivo. Se il `ThemeConfiguration` fornito non è valido, viene restituito un errore.  | 

## Inizializzazione del contenuto incorporato con un tema
<a name="runtime-theming-sdk-initialize"></a>

Per inizializzare un pannello di controllo o un elemento visivo incorporato con un tema non predefinito, definisci un oggetto `themeOptions` nei parametri `DashboardContentOptions` o `VisualContentOptions` e imposta la proprietà `themeArn` all'interno di `themeOptions` sull'ARN del tema desiderato.

L'esempio seguente inizializza un pannello di controllo incorporato con il tema `MIDNIGHT`.

```
import { createEmbeddingContext } from 'amazon-quicksight-embedding-sdk';

const embeddingContext = await createEmbeddingContext();

const {
    embedDashboard,
} = embeddingContext;

const frameOptions = {
    url: '<YOUR_EMBED_URL>',
    container: '#experience-container',
};
const contentOptions = {
    themeOptions: {
        themeArn: "arn:aws:quicksight::aws:theme/MIDNIGHT"
    }
};

// Embedding a dashboard experience
const embeddedDashboardExperience = await embedDashboard(frameOptions, contentOptions);
```

## Inizializzazione del contenuto incorporato con la sovrascrittura di un tema
<a name="runtime-theming-runtime-initialize-override"></a>

Gli sviluppatori possono utilizzare le sovrascritture dei temi per definire il tema di un pannello di controllo o di un elemento visivo incorporato durante il runtime. Ciò consente alla dashboard o alla visualizzazione di ereditare un tema da un'applicazione di terze parti senza la necessità di preconfigurare un tema in Amazon Quick Sight. Per inizializzare un pannello di controllo o un elemento visivo incorporato con una sovrascrittura del tema, imposta la proprietà `themeOverride` all'interno di `themeOptions` sui parametri `DashboardContentOptions` o `VisualContentOptions`. L'esempio seguente sostituisce il carattere del tema di un pannello di controllo dal carattere predefinito su `Amazon Ember`.

```
import { createEmbeddingContext } from 'amazon-quicksight-embedding-sdk';

const embeddingContext = await createEmbeddingContext();

const {
    embedDashboard,
} = embeddingContext;

const frameOptions = {
    url: '<YOUR_EMBED_URL>',
    container: '#experience-container',
};
const contentOptions = {
    themeOptions: {
        "themeOverride":{"Typography":{"FontFamilies":[{"FontFamily":"Comic Neue"}]}}
    }
};

// Embedding a dashboard experience
const embeddedDashboardExperience = await embedDashboard(frameOptions, contentOptions);
```

## Inizializzazione del contenuto incorporato con temi precaricati
<a name="runtime-theming-runtime-initialize-preloaded"></a>

Gli sviluppatori possono configurare un set di temi del pannello di controllo da precaricare al momento dell'inizializzazione. Ciò è particolarmente utile per passare rapidamente da una visualizzazione all'altra, ad esempio tra le modalità chiaro e scuro. È possibile inizializzare un pannello di controllo o un elemento visivo incorporato con un massimo di cinque temi precaricati. Per utilizzare temi precaricati, imposta la proprietà `preloadThemes` in `DashboardContentOptions` o `VisualContentOptions` con un array di massimo cinque `themeArns`. L'esempio seguente precarica i temi iniziali `Midnight` e `Rainier` in un pannello di controllo.

```
import { createEmbeddingContext } from 'amazon-quicksight-embedding-sdk';

const embeddingContext = await createEmbeddingContext();

const {
    embedDashboard,
} = embeddingContext;

const frameOptions = {
    url: '<YOUR_EMBED_URL>',
    container: '#experience-container',
};
const contentOptions = {
    themeOptions: {
        "preloadThemes": ["arn:aws:quicksight::aws:theme/RAINIER", "arn:aws:quicksight::aws:theme/MIDNIGHT"]
    }
};

// Embedding a dashboard experience
const embeddedDashboardExperience = await embedDashboard(frameOptions, contentOptions);
```

# Utilizzo dell'SDK Amazon Quick Sight Embedding per abilitare collegamenti condivisibili a visualizzazioni di dashboard integrate
<a name="embedded-view-sharing"></a>

Gli sviluppatori di Amazon Quick Sight possono utilizzare Amazon Quick Sight Embedding SDK (versione 2.8.0 e successive) per consentire ai lettori di dashboard incorporati di ricevere e distribuire link condivisibili alla loro visualizzazione di una dashboard incorporata. Gli sviluppatori possono utilizzare l'incorporamento di dashboard o console per generare un link condivisibile alla pagina dell'applicazione con il riferimento di Amazon Quick Sight incapsulato utilizzando l'SDK Amazon Quick Sight Embedding. I lettori di Amazon Quick Sight possono quindi inviare questo link condivisibile ai loro colleghi. Quando il loro collega accede al link condiviso, viene indirizzato alla pagina dell'applicazione che contiene la dashboard Amazon Quick Sight integrata. Gli sviluppatori possono anche generare e salvare link condivisibili di visualizzazioni di dashboard che possono essere utilizzati come segnalibri per lettori anonimi di Amazon Quick Sight quando utilizzano l'incorporamento anonimo.

**Prerequisiti**

Prima di iniziare, assicurati di utilizzare Amazon Quick Sight Embedding SDK versione 2.8.0 o successiva

**Topics**
+ [

# Abilitazione della configurazione delle `SharedView` funzionalità per l'analisi integrata di Amazon Quick Sight
](embedded-view-sharing-set-up.md)
+ [

# Creazione di una visualizzazione condivisa con l'`createSharedView`API Amazon Quick Sight
](embedded-view-sharing-sdk-create.md)
+ [

# Utilizzo di una visualizzazione condivisa di Amazon Quick Sight
](embedded-view-sharing-sdk-consume.md)

# Abilitazione della configurazione delle `SharedView` funzionalità per l'analisi integrata di Amazon Quick Sight
<a name="embedded-view-sharing-set-up"></a>

Quando crei un'istanza incorporata con l'API Amazon Quick Sight, imposta il valore di `SharedView` nel `FeatureConfigurations` payload su`true`, come mostrato nell'esempio seguente. `SharedView`sostituisce le `StatePersistence` configurazioni per gli utenti registrati che accedono ai dashboard incorporati. Se un utente del pannello di controllo ha `StatePersistence` disabilitato e `SharedView` abilitato, il suo stato persisterà.

```
const generateNewEmbedUrl = async () => {
    const generateUrlPayload = {
        experienceConfiguration: {
            QuickSightConsole: {
            FeatureConfigurations: {
                "SharedView": { 
                    "Enabled": true
                 },
            },
        },
    }
    const result: GenerateEmbedUrlResult = await generateEmbedUrlForRegisteredUser(generateUrlPayload);
    return result.url;
};
```

# Creazione di una visualizzazione condivisa con l'`createSharedView`API Amazon Quick Sight
<a name="embedded-view-sharing-sdk-create"></a>

Dopo aver aggiornato l'SDK Embedding alla versione 2.8.0 o successiva, utilizza l'API `createSharedView` per creare una nuova vista condivisa. Registra `sharedViewId` e `dashboardId` restituiti dall'operazione. L'esempio seguente crea una nuova vista condivisa.

```
const response = await embeddingFrame.createSharedView();
const sharedViewId = response.message.sharedViewId;
const dashboardId = response.message.dashboardId;
```

`createSharedView` può essere chiamato solo quando un utente visualizza un pannello di controllo. Per la creazione di una vista condivisa specifica della console, assicurati che gli utenti siano nella pagina del pannello di controllo prima di abilitare l'azione `createSharedView`. Puoi farlo con l'evento `PAGE_NAVIGATION`, mostrato nell'esempio seguente.

```
const contentOptions = {
    onMessage: async (messageEvent, metadata) => {
    switch (messageEvent.eventName) {
            case 'CONTENT_LOADED': {
                console.log("Do something when the embedded experience is fully loaded.");
                break;
            }
            case 'ERROR_OCCURRED': {
                console.log("Do something when the embedded experience fails loading.");
                break;
            }
            case 'PAGE_NAVIGATION': {
                setPageType(messageEvent.message.pageType); 
                if (messageEvent.message.pageType === 'DASHBOARD') {
                    setShareEnabled(true);
                    } else {
                    setShareEnabled(false);
                }
                break;
            }
        }
    }
};
```

# Utilizzo di una visualizzazione condivisa di Amazon Quick Sight
<a name="embedded-view-sharing-sdk-consume"></a>

Dopo aver creato una nuova vista condivisa, utilizza l'SDK Embedding per rendere la vista condivisa utilizzabile per altri utenti. Gli esempi seguenti configurano una visualizzazione condivisa dei consumabili per un pannello di controllo incorporato in Amazon Quick Sight.

------
#### [ With an appended URL ]

Aggiungi `sharedViewId` all'URL di incorporamento, in ` /views/{viewId}`, ed esponi questo URL ai tuoi utenti. Gli utenti possono utilizzare questo URL per accedere alla vista condivisa.

```
const response = await dashboardFrame.createSharedView();
const newEmbedUrl = await generateNewEmbedUrl();
const formattedUrl = new URL(newEmbedUrl);
formattedUrl.pathname = formattedUrl.pathname.concat('/views/' + response.message.sharedViewId);
const baseUrl = formattedUrl.href;
alert("Click to view this QuickSight shared view", baseUrl);
```

------
#### [ With the contentOptions SDK ]

Passa `viewId` a `contentOptions` per aprire l'esperienza con il `viewId` fornito.

```
const contentOptions = {
    toolbarOptions: {
        ...
    },
    viewId: sharedViewId,
};

const embeddedDashboard = await embeddingContext.embedDashboard(
    {container: containerRef.current},
    contentOptions
);
```

------
#### [ With the InitialPath property ]

```
const shareView = async() => {
    const returnValue = await consoleFrame.createSharedView();
    const {dashboardId, sharedViewId} = returnValue.message;
    const newEmbedUrl = await generateNewEmbedUrl(`/dashboards/${dashboardId}/views/${sharedViewId}`);
    setShareUrl(newEmbedUrl);
};

const generateNewEmbedUrl = async (initialPath) => {
    const generateUrlPayload = {
        experienceConfiguration: {
            QuickSightConsole: {
            InitialPath: initialPath,
            FeatureConfigurations: {
                "SharedView": { 
                    "Enabled": true
                 },
            },
        },
    }
    const result: GenerateEmbedUrlResult = await generateEmbedUrlForRegisteredUser(generateUrlPayload);
    return result.url;
};
```

------

# Incorporamento di elementi visivi e dashboard di Amazon Quick Sight con un codice di incorporamento in 1 clic
<a name="1-click-embedding"></a>

Puoi incorporare un elemento visivo o un pannello di controllo nella tua applicazione utilizzando un codice di incorporamento. Ottieni questo codice quando condividi la dashboard o dal menu **visivo Incorpora** in Amazon Quick Sight. 

Puoi incorporare un elemento visivo o un pannello di controllo nella tua applicazione interna per gli utenti registrati. Oppure puoi attivare la condivisione pubblica nella console Amazon Quick Sight. In questo modo, chiunque acceda a Internet può accedere a un elemento visivo o a un pannello di controllo condiviso incorporata in un'applicazione pubblica, un wiki o un portale.

Di seguito, puoi trovare le descrizioni su come incorporare elementi visivi e pannelli di controllo utilizzando il codice di incorporamento del pannello di controllo o dell'elemento visivo con 1 clic.

**Topics**
+ [

# Incorporamento di immagini e dashboard di Amazon Quick Sight per gli utenti registrati con un codice di incorporamento in 1 clic
](embedded-analytics-1-click.md)
+ [

# Incorporamento di immagini e dashboard di Amazon Quick Sight per utenti anonimi con un codice di incorporamento in 1 clic
](embedded-analytics-1-click-public.md)

# Incorporamento di immagini e dashboard di Amazon Quick Sight per gli utenti registrati con un codice di incorporamento in 1 clic
<a name="embedded-analytics-1-click"></a>


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

Puoi incorporare un'immagine o un pannello di controllo nella tua applicazione interna per gli utenti registrati del tuo account Amazon Quick Sight. Puoi farlo utilizzando il codice di incorporamento che ottieni quando condividi la dashboard o dal menu **visivo Incorpora** in Amazon Quick Sight. Non è necessario eseguire l'API di incorporamento di Amazon Quick Sight per generare il codice di incorporamento. Puoi copiare il codice di incorporamento da Amazon Quick Sight e incollarlo nel codice HTML dell'applicazione interna.

Quando utenti e gruppi (o tutti gli utenti del tuo account Amazon Quick Sight) che hanno accesso alla dashboard che desideri incorporare o che contiene l'immagine che desideri incorporare accedono alla tua applicazione interna, viene richiesto loro di accedere all'account Amazon Quick Sight con le proprie credenziali. Dopo l'autenticazione, possono accedere all'elemento visivo o al pannello di controllo sulla loro pagina interna. Se hai abilitato il Single Sign-On, agli utenti non viene richiesto di accedere nuovamente.

Di seguito, puoi trovare le descrizioni su come incorporare elementi visivi e pannelli di controllo per gli utenti registrati utilizzando il codice di incorporamento del pannello di controllo o dell'elemento visivo.

## Prima di iniziare
<a name="embedded-analytics-1-click-prerequisites"></a>

Prima di iniziare, assicurati di:
+ Le impostazioni del tuo browser Internet contengono una delle seguenti opzioni per consentire la comunicazione tra il popup e l'iframe:
  + Supporto nativo per l'API Broadcast Channel di Mozilla. Per ulteriori informazioni, consulta [API Broadcast Channel](https://developer.mozilla.org/en-US/docs/Web/API/Broadcast_Channel_API) nella documentazione di Mozilla.
  + Supporto di IndexedDB.
  + LocalStorage supporto.
+ Le impostazioni "blocca tutti i cookie" del tuo browser Internet sono disattivate.

## Fase 1: Concessione dell'accesso al pannello di controllo
<a name="embedded-analystics-1-click-share"></a>

Per consentire agli utenti di accedere al pannello di controllo incorporato, concedi loro l'autorizzazione per visualizzarla. Puoi concedere l'accesso a un pannello di controllo a singoli utenti e gruppi oppure a tutti i membri del tuo account. Le autorizzazioni degli elementi visivi sono determinate a livello di pannello di controllo. Per concedere l'accesso agli elementi visivi incorporati, concedi l'accesso alla pannello di controllo a cui appartiene l'elemento visivo. Per ulteriori informazioni, consulta [Concessione dell'accesso a un pannello di controllo](share-a-dashboard.md).

## Fase 2: Inserimento del dominio in cui si desidera incorporare l'elemento visivo o il pannello di controllo nell'elenco degli elementi consentiti
<a name="embedded-analytics-1-click-allow-list"></a>

Per incorporare immagini e dashboard nella tua applicazione interna, assicurati che il dominio in cui stai incorporando sia elencato nell'elenco consentito nel tuo account Amazon Quick Sight. Per ulteriori informazioni, consulta [Elenco consentiti dei domini statici](manage-domains.md#embedding-static).

## Fase 3: Ottenimento del codice di incorporamento
<a name="embedded-analytics-1-click-code"></a>

Usa la procedura seguente per ottenere il codice di incorporamento di un elemento visivo o del pannello di controllo.

**Ottenimento del codice di incorporamento del pannello di controllo**

1. Apri la dashboard pubblicata in Amazon Quick Sight e scegli **Condividi** in alto a destra. Quindi scegli **Condividi pannello di controllo**.

1. Nella pagina **Condividi pannello di controllo** che si apre, scegli **Copia codice di incorporamento** in alto a sinistra.

   Il codice di incorporamento viene copiato negli appunti ed è simile al seguente. `quicksightdomain`In questo esempio è l'URL che usi per accedere al tuo account Amazon Quick Sight.

   ```
   <iframe
           width="960"
           height="720"
           src="https://quicksightdomain/sn/embed/share/accounts/accountid/dashboards/dashboardid?directory_alias=account_directory_alias">
       </iframe>
   ```

**Ottenimento del codice di incorporamento dell'elemento visivo**

1. Apri la dashboard pubblicata in Amazon Quick Sight e scegli l'immagine che desideri incorporare. Quindi, apri il menu associato all'elemento visivo in alto a destra e scegli **Incorpora elementi visivi**.

1. Nel riquadro **Incorpora elementi visivi** che si apre, scegli **Copia il codice**.

   Il codice di incorporamento viene copiato negli appunti ed è simile al seguente. `quicksightdomain`In questo esempio è l'URL che usi per accedere al tuo account Amazon Quick Sight.

   ```
   <iframe
           width="600"
           height="400"
           src="https://quicksightdomain/sn/embed/share/accounts/111122223333/dashboards/DASHBOARDID/sheets/SHEETID>/visuals/VISUALID">
       </iframe>
   ```

## Fase 4: Incollare il codice nella pagina HTML dell'applicazione interna
<a name="embedded-analytics-1-click-html"></a>

Utilizza la seguente procedura per incollare il codice di incorporamento nella pagina HTML dell'applicazione interna

**Incollare il codice nella pagina HTML dell'applicazione interna**
+ Apri il codice HTML di qualsiasi pagina in cui desideri incorporare il pannello di controllo e incolla il codice di incorporamento.

  L'esempio seguente mostra l'aspetto che avrebbe per un pannello di controllo incorporato. `quicksightdomain`In questo esempio è l'URL che usi per accedere al tuo account Amazon Quick Sight.

  ```
  <!DOCTYPE html>
      <html>
      <body>
  
      <h2>Example.com - Employee Portal</h2>
      <h3>Current shipment stats</h3>
          <iframe
          width="960"
          height="720"
          src="https://quicksightdomain/sn/embed/share/accounts/accountid/dashboards/dashboardid?directory_alias=account_directory_alias">
      </iframe>
  
      </body>
      </html>
  ```

  L'esempio seguente mostra l'aspetto che avrebbe per un elemento visivo incorporato. `quicksightdomain`In questo esempio è l'URL che usi per accedere al tuo account Amazon Quick Sight.

  ```
  <!DOCTYPE html>
      <html>
      <body>
  
      <h2>Example.com - Employee Portal</h2>
      <h3>Current shipment stats</h3>
          <iframe
          width="600"
          height="400"
          src="https://quicksightdomain/sn/embed/share/accounts/111122223333/dashboards/DASHBOARDID/sheets/SHEETID>/visuals/VISUALID?directory_alias=account_directory_alias">
      </iframe>
  
      </body>
      </html>
  ```

Ad esempio, supponiamo di voler incorporare l'elemento visivo o il pannello di controllo in una pagina interna di Google Sites. Puoi aprire la pagina su Google Sites e incollare il codice di incorporamento in un widget di incorporamento.

Se desideri incorporare la visualizzazione o la dashboard in un SharePoint sito Microsoft interno, puoi creare una nuova pagina e incollare il codice di incorporamento in una web part Embed.

# Incorporamento di immagini e dashboard di Amazon Quick Sight per utenti anonimi con un codice di incorporamento in 1 clic
<a name="embedded-analytics-1-click-public"></a>


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

Puoi incorporare un'immagine o un pannello di controllo in siti pubblici utilizzando il codice di incorporamento che ottieni quando condividi l'immagine o la dashboard in Amazon Quick Sight. Puoi anche attivare la condivisione pubblica utilizzando la console Amazon Quick Sight e concedere automaticamente l'accesso a una visualizzazione o a una dashboard condivisa a chiunque sia su Internet. 

Di seguito, puoi scoprire come attivare la condivisione pubblica per un elemento visivo o un pannello di controllo e incorporarli affinché chiunque su Internet possa vederli. In entrambi i casi, puoi farlo utilizzando il codice di incorporamento con 1 clic.

## Prima di iniziare
<a name="embedded-analytics-1-click-prerequisites"></a>

Prima di iniziare, assicurati di:
+ Le impostazioni del tuo browser Internet contengono una delle seguenti opzioni per consentire la comunicazione tra il popup e l'iframe utilizzati dalla condivisione:
  + Supporto nativo per l'API Broadcast Channel di Mozilla. Per ulteriori informazioni, consulta [API Broadcast Channel](https://developer.mozilla.org/en-US/docs/Web/API/Broadcast_Channel_API) nella documentazione di Mozilla.
  + Supporto di IndexedDB.
  + LocalStorage supporto.
+ Le impostazioni "blocca tutti i cookie" del tuo browser Internet sono disattivate.

## Fase 1: Attivazione dell'accesso pubblico per il pannello di controllo
<a name="embedded-analytics-1-click-step-1"></a>

Per consentire a chiunque su Internet di accedere all'elemento visivo o al pannello di controllo incorporato, attiva innanzitutto l'accesso pubblico al pannello di controllo. Le autorizzazioni degli elementi visivi sono determinate a livello di pannello di controllo. Per concedere l'accesso agli elementi visivi incorporati, concedi l'accesso alla pannello di controllo a cui appartiene l'elemento visivo. Per ulteriori informazioni, consulta [Consentire a tutti gli utenti di Internet l'accesso a una dashboard di Amazon Quick Sight](share-a-dashboard-grant-access-anyone.md).

## Fase 2: Inserimento del dominio in cui si desidera incorporare l'elemento visivo o il pannello di controllo nell'elenco degli elementi consentiti
<a name="embedded-analytics-1-click-step-2"></a>

Per incorporare immagini e dashboard in un'applicazione pubblica, un wiki o un portale, assicurati che il dominio in cui lo stai incorporando sia nell'elenco degli elementi consentiti del tuo account Amazon Quick Sight. 

## Fase 3: Ottenimento del codice di incorporamento
<a name="embedded-analytics-1-click-step-3"></a>

Usa la procedura seguente per ottenere il codice di incorporamento di un elemento visivo o del pannello di controllo.

**Ottenimento del codice di incorporamento del pannello di controllo**

1. Apri la dashboard pubblicata in Amazon Quick Sight e scegli **Condividi** in alto a destra. Quindi scegli **Condividi pannello di controllo**.

1. Nella pagina **Condividi pannello di controllo** che si apre, scegli **Copia codice di incorporamento** in alto a sinistra.

   Il codice di incorporamento viene copiato negli appunti ed è simile al seguente. `quicksightdomain`In questo esempio è l'URL che usi per accedere al tuo account Amazon Quick Sight.

   ```
   <iframe
           width="960"
           height="720"
           src="https://quicksightdomain/sn/
               embed/share/accounts/accountid/dashboards/dashboardid">
       </iframe>
   ```

**Ottenimento del codice di incorporamento dell'elemento visivo**

1. Apri la dashboard pubblicata in Amazon Quick Sight e scegli l'immagine che desideri incorporare. Quindi, apri il menu visivo nell'angolo in alto a destra e scegli **Incorpora elemento visivo**.

1. Nel riquadro **Incorpora elementi visivi** che si apre, scegli **Copia il codice**.

   Il codice di incorporamento viene copiato negli appunti ed è simile al seguente. `quicksightdomain`In questo esempio è l'URL che usi per accedere al tuo account Amazon Quick Sight.

   ```
   <iframe
           width="600"
           height="400"
           src="https://quicksightdomain/sn/embed/share/accounts/111122223333/dashboards/DASHBOARDID/sheets/SHEETID>/visuals/VISUALID">
       </iframe>
   ```

## Fase 4: Incollare il codice di incorporamento in una pagina HTML, una pagina wiki o un portale
<a name="embedded-analytics-1-click-step-4"></a>

Utilizza la procedura seguente per incollare il codice di incorporamento in una pagina HTML, una pagina wiki o un portale.

**Incollare il codice di incorporamento**
+ Apri il codice HTML di qualsiasi pagina in cui desideri incorporare l'elemento visivo o il pannello di controllo e incolla il codice di incorporamento.

  L'esempio seguente mostra l'aspetto che avrebbe per un pannello di controllo incorporato. `quicksightdomain`In questo esempio è l'URL che usi per accedere al tuo account Amazon Quick Sight.

  ```
  <!DOCTYPE html>
      <html>
      <body>
  
      <h2>Example.com - Employee Portal</h2>
      <h3>Current shipment stats</h3>
          <iframe
          width="960"
          height="720"
          src="https://quicksightdomain/sn/
              embed/share/accounts/accountid/dashboards/dashboardid">
      </iframe>
  
      </body>
      </html>
  ```

  L'esempio seguente mostra l'aspetto che avrebbe per un elemento visivo incorporato. `quicksightdomain`In questo esempio è l'URL che usi per accedere al tuo account Amazon Quick Sight.

  ```
  <!DOCTYPE html>
      <html>
      <body>
  
      <h2>Example.com - Employee Portal</h2>
      <h3>Current shipment stats</h3>
          <iframe
          width="600"
          height="400"
          src="https://quicksightdomain/sn/embed/share/accounts/111122223333/dashboards/DASHBOARDID/sheets/SHEETID>/visuals/VISUALID">
      </iframe>
  
      </body>
      </html>
  ```

Se le tue applicazioni destinate al pubblico sono basate su Google Sites, apri la pagina su Google Sites e incolla il codice di incorporamento utilizzando il widget di incorporamento.

Assicurati che i seguenti domini in Amazon Quick Sight siano presenti nell'elenco dei domini consentiti quando esegui l'incorporamento in Google Sites:
+ `https://googleusercontent.com` (attiva i sottodomini)
+ `https://www.gstatic.com`
+ `https://sites.google.com`

Dopo aver incorporato l'elemento visivo o il pannello di controllo nell'applicazione, chiunque possa accedere all'applicazione potrà accedere all'elemento visivo o al pannello di controllo incorporato. Per aggiornare un pannello di controllo condiviso con il pubblico, consulta [Aggiornamento di un pannello di controllo condiviso pubblicamente](share-a-dashboard-grant-access-anyone-update.md). Per disattivare la condivisione pubblica, consulta [Disattivazione delle impostazioni di condivisione pubblica](share-a-dashboard-grant-access-anyone-no-share.md). 

Quando disattivi la condivisione pubblica, nessuno da Internet potrà accedere a uno o più pannelli di controllo che hai incorporato in un'applicazione pubblica o condivisa con un link. La volta successiva che qualcuno tenta di visualizzare un pannello di controllo di questo tipo da Internet, riceverà un messaggio che indica che non può visualizzarlo.

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