Les traductions sont fournies par des outils de traduction automatique. En cas de conflit entre le contenu d'une traduction et celui de la version originale en anglais, la version anglaise prévaudra.

# Intégration de la console Amazon Quick Sight à l'aide de GetSessionEmbedUrl (ancienne API)
<a name="embedded-analytics-full-console-for-authenticated-users-get"></a>

**Important**  
Amazon Quick Sight propose des nouveautés en APIs matière d'intégration des analyses : `GenerateEmbedUrlForAnonymousUser` et`GenerateEmbedUrlForRegisteredUser`.  
Vous pouvez toujours utiliser `GetDashboardEmbedUrl` et `GetSessionEmbedUrl` APIs pour intégrer des tableaux de bord et la console Amazon Quick Sight, mais ils ne contiennent pas les dernières fonctionnalités d'intégration. Pour découvrir l'expérience up-to-date d'intégration la plus récente, consultez la section [Intégration des analyses Amazon Quick Sight dans vos applications](https://docs.aws.amazon.com/quicksight/latest/user/embedding-overview.html).


|  | 
| --- |
|  S’applique à : édition Enterprise  | 


|  | 
| --- |
|    Public cible : développeurs Amazon Quick  | 

Dans les sections suivantes, vous trouverez des informations détaillées sur la manière de fournir l'expérience de console Amazon Quick Sight dans un portail de création personnalisé pour les utilisateurs enregistrés utilisant l'`GetSessionEmbedUrl`API. 

**Topics**
+ [Étape 1 : Configurer des autorisations](embedded-analytics-full-console-for-authenticated-users-get-step-1.md)
+ [Étape 2 : Obtenir l’URL avec le code d’authentification en pièce jointe](embedded-analytics-full-console-for-authenticated-users-get-step-2.md)
+ [Étape 3 : Intégrer l’URL de la session de console](embedded-analytics-full-console-for-authenticated-users-get-step-3.md)

# Étape 1 : Configurer des autorisations
<a name="embedded-analytics-full-console-for-authenticated-users-get-step-1"></a>

**Important**  
Amazon Quick Sight propose des nouveautés en APIs matière d'intégration des analyses : `GenerateEmbedUrlForAnonymousUser` et`GenerateEmbedUrlForRegisteredUser`.  
Vous pouvez toujours utiliser `GetDashboardEmbedUrl` et `GetSessionEmbedUrl` APIs pour intégrer des tableaux de bord et la console Amazon Quick Sight, mais ils ne contiennent pas les dernières fonctionnalités d'intégration. Pour découvrir l'expérience up-to-date d'intégration la plus récente, consultez la section [Intégration des analyses Amazon Quick Sight dans vos applications](https://docs.aws.amazon.com/quicksight/latest/user/embedding-overview.html).

Dans la section suivante, vous apprendrez à configurer les autorisations pour l’application backend ou le serveur web. Cette tâche requiert un accès d’administration à IAM.

Chaque utilisateur qui accède à Amazon Quick Sight assume un rôle qui lui donne accès à Amazon Quick Sight et les autorisations nécessaires pour accéder à la session de console. Pour que cela soit possible, créez un rôle IAM dans votre AWS compte. Associez une politique IAM au rôle afin de fournir des autorisations à n’importe quel utilisateur qui assume ce rôle. Ajoutez `quicksight:RegisterUser` des autorisations pour garantir que le lecteur puisse accéder à Amazon Quick Sight en lecture seule, sans avoir accès à d'autres données ou fonctionnalités de création. Le rôle IAM doit également fournir des autorisations pour récupérer la session URLs de console. Pour cela, ajoutez `quicksight:GetSessionEmbedUrl`.

L’exemple de politique suivant fournit ces autorisations à utiliser avec `IdentityType=IAM`. 

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

****  

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

------

L’exemple de politique suivant autorise la récupération de l’URL d’une session de console. Vous utilisez la politique sans `quicksight:RegisterUser` si vous créez des utilisateurs avant qu’ils n’accèdent à une session intégrée.

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

****  

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

------

Si vous utilisez `QUICKSIGHT` comme `identityType` et fournissez l’Amazon Resource Name (ARN) de l’utilisateur, vous devez également autoriser l’action `quicksight:GetAuthCode` dans votre politique. L’exemple de stratégie suivant fournit cette autorisation.

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

****  

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

------

L’identité IAM de votre application doit avoir une politique d’approbation qui lui est associée afin d’autoriser l’accès au rôle que vous venez de créer. Cela signifie que lorsqu'un utilisateur accède à votre application, celle-ci peut assumer le rôle en son nom et configurer l'utilisateur dans Amazon Quick Sight. L’exemple suivant montre un rôle appelé `embedding_quicksight_console_session_role`, qui possède l’exemple de stratégie précédent en tant que ressource. 

Pour plus d’informations sur les stratégies d’approbation pour OpenId Connect ou l’authentification SAML, consultez les sections suivantes du *Guide de l’utilisateur IAM : *
+ [Création d’un rôle pour l’identité web ou pour la fédération OpenID Connect (console)](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_create_for-idp_oidc.html)
+ [Création d’un rôle pour la fédération SAML 2.0 (console)](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_create_for-idp_saml.html)

# Étape 2 : Obtenir l’URL avec le code d’authentification en pièce jointe
<a name="embedded-analytics-full-console-for-authenticated-users-get-step-2"></a>

**Important**  
Amazon Quick Sight propose des nouveautés en APIs matière d'intégration des analyses : `GenerateEmbedUrlForAnonymousUser` et`GenerateEmbedUrlForRegisteredUser`.  
Vous pouvez toujours utiliser `GetDashboardEmbedUrl` et `GetSessionEmbedUrl` APIs pour intégrer des tableaux de bord et la console Amazon Quick Sight, mais ils ne contiennent pas les dernières fonctionnalités d'intégration. Pour découvrir l'expérience up-to-date d'intégration la plus récente, consultez la section [Intégration des analyses Amazon Quick Sight dans vos applications](https://docs.aws.amazon.com/quicksight/latest/user/embedding-overview.html).

Dans la section suivante, vous découvrirez comment authentifier votre utilisateur et obtenir l’URL de la session de console intégrable sur votre serveur d’applications. 

Lorsqu’un utilisateur accède à votre application, l’application assume le rôle IAM pour le compte de l’utilisateur. Il ajoute ensuite l'utilisateur à Amazon Quick Sight, s'il n'existe pas déjà. Puis, elle transmet un identifiant comme ID de session de rôle unique. 

L'exécution des étapes décrites garantit que chaque utilisateur de la session de console est configuré de manière unique dans Amazon Quick Sight. Elle applique également les paramètres par utilisateur, tels que les valeurs dynamiques et de sécurité par défaut au niveau des lignes pour les paramètres.

Les exemples suivants effectuent l’authentification IAM pour le compte de l’utilisateur. Ce code s’exécute sur votre serveur d’applications.

------
#### [ 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'exemple suivant montre le JavaScript (Node.js) que vous pouvez utiliser sur le serveur d'applications pour obtenir l'URL de la session de console intégrée. Vous pouvez utiliser cette URL dans votre site web ou votre application pour afficher la session de 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’exemple suivant montre le code .NET/C \$1 que vous pouvez utiliser sur le serveur d’applications afin d’obtenir l’URL pour la session de console intégrée. Vous pouvez utiliser cette URL dans votre site web ou votre application pour afficher 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 ]

Pour assumer ce rôle, choisissez l'une des opérations d'API AWS Security Token Service (AWS STS) suivantes :
+ [AssumeRole](https://docs.aws.amazon.com/STS/latest/APIReference/API_AssumeRole.html)— Utilisez cette opération lorsque vous utilisez une identité IAM pour assumer le rôle.
+ [AssumeRoleWithWebIdentity](https://docs.aws.amazon.com/STS/latest/APIReference/API_AssumeRoleWithWebIdentity.html)— Utilisez cette opération lorsque vous utilisez un fournisseur d'identité Web pour authentifier votre utilisateur. 
+ [AssumeRoleWithSaml](https://docs.aws.amazon.com/STS/latest/APIReference/API_AssumeRoleWithSAML.html)— Utilisez cette opération lorsque vous utilisez le protocole SAML pour authentifier vos utilisateurs.

L’exemple suivant illustre la commande de l’interface de ligne de commande pour définir le rôle IAM. Les autorisations doivent être activées pour `quicksight:GetSessionEmbedUrl`. Si vous envisagez d' just-in-timeajouter des utilisateurs lorsqu'ils ouvrent Amazon Quick Sight pour la première fois, les autorisations doivent également être activées pour le rôle`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’opération `assume-role` renvoie trois paramètres de sortie : la clé d’accès, la clé secrète et le jeton de session. 

**Note**  
Si vous obtenez une erreur `ExpiredToken` lorsque vous appelez l’opération `AssumeRole`, ceci est probablement dû au fait que le précédent `SESSION TOKEN` est encore dans les variables de l’environnement. Pour l’effacer, définissez les variables suivantes :  
*AWS\$1ACCESS\$1KEY\$1ID* 
*AWS\$1SECRET\$1CLÉ D'ACCÈS* 
*AWS\$1SESSION\$1JETON* 

L’exemple suivant montre comment définir ces trois paramètres dans l’interface de ligne de commande. Si vous utilisez une machine Microsoft Windows, utilisez `set` au lieu de `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’exécution de ces commandes définit l’ID de session de rôle de l’utilisateur visitant votre site web sur `embedding_quicksight_console_session_role/john.doe@example.com`. L’ID de session de rôle se compose du nom de rôle issu du `role-arn` et de la valeur `role-session-name`. L’utilisation de l’ID de session de rôle unique pour chaque utilisateur garantit que les autorisations appropriées sont définies pour chaque utilisateur. Ceci évite également toute limitation des accès des utilisateurs. Le throttling est une fonctionnalité de sécurité qui empêche le même utilisateur d'accéder à Amazon Quick Sight depuis plusieurs sites. 

L'ID de session du rôle devient également le nom d'utilisateur dans Amazon Quick Sight. Vous pouvez utiliser ce modèle pour configurer vos utilisateurs dans Amazon Quick Sight à l'avance, ou pour les configurer la première fois qu'ils accèdent à une session de console. 

L’exemple suivant montre la commande de l’interface de ligne de commande que vous pouvez utiliser pour provisionner un utilisateur. Pour plus d'informations sur [RegisterUser[DescribeUser](https://docs.aws.amazon.com/quicksight/latest/APIReference/API_DescribeUser.html)](https://docs.aws.amazon.com/quicksight/latest/APIReference/API_RegisterUser.html), et sur les autres opérations de l'API Amazon Quick Sight, consultez la [référence de l'API Amazon Quick Sight](https://docs.aws.amazon.com/quicksight/latest/APIReference/Welcome.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
```

Si l’utilisateur est authentifié via Microsoft AD, vous n’avez pas besoin d’utiliser `RegisterUser` pour le configurer. Ils devraient plutôt être automatiquement abonnés la première fois qu'ils accèdent à Amazon Quick Sight. Pour les utilisateurs Microsoft AD, vous pouvez utiliser `DescribeUser` pour obtenir l’ARN de l’utilisateur.

La première fois qu'un utilisateur accède à Amazon Quick Sight, vous pouvez également ajouter cet utilisateur au groupe approprié. L’exemple suivant montre la commande de l’interface de ligne de commande pour ajouter un utilisateur à un groupe.

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

Vous avez désormais un utilisateur de votre application qui est également un utilisateur d'Amazon Quick Sight et qui a accès à la session de console Amazon Quick Sight. 

Enfin, pour obtenir une URL signée pour la session de console, appelez `get-session-embed-url` à partir du serveur d’applications. Cela renvoie l’URL de session de console intégrable. L'exemple suivant montre comment obtenir l'URL d'une session de console intégrée à l'aide d'un appel côté serveur pour les utilisateurs authentifiés par le biais de l'authentification unique (IAM AWS Managed Microsoft AD 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
```

Pour de plus amples informations sur l’utilisation de cette opération, veuillez consulter [https://docs.aws.amazon.com/quicksight/latest/APIReference/API_GetSessionEmbedUrl.html](https://docs.aws.amazon.com/quicksight/latest/APIReference/API_GetSessionEmbedUrl.html). Vous pouvez utiliser cette opération et d’autres opérations d’API dans votre propre code. 

------

# Étape 3 : Intégrer l’URL de la session de console
<a name="embedded-analytics-full-console-for-authenticated-users-get-step-3"></a>

**Important**  
Amazon Quick Sight propose des nouveautés en APIs matière d'intégration des analyses : `GenerateEmbedUrlForAnonymousUser` et`GenerateEmbedUrlForRegisteredUser`.  
Vous pouvez toujours utiliser `GetDashboardEmbedUrl` et `GetSessionEmbedUrl` APIs pour intégrer des tableaux de bord et la console Amazon Quick Sight, mais ils ne contiennent pas les dernières fonctionnalités d'intégration. Pour découvrir l'expérience up-to-date d'intégration la plus récente, consultez la section [Intégration des analyses Amazon Quick Sight dans vos applications](https://docs.aws.amazon.com/quicksight/latest/user/embedding-overview.html).

Dans la section suivante, vous découvrirez comment utiliser le [SDK d'intégration Amazon Quick Sight (JavaScript) pour intégrer](https://www.npmjs.com/package/amazon-quicksight-embedding-sdk) l'URL de session de console de l'étape 3 dans la page de votre site Web ou de votre application. Le kit SDK vous permet d’effectuer les opérations suivantes : 
+ Placer la session de console sur une page HTML.
+ Transmettre les paramètres à la session de console.
+ Gérer les états d’erreurs avec des messages personnalisés pour votre application.

Appelez l’opération d’API `GetSessionEmbedUrl` pour obtenir l’URL que vous pouvez intégrer dans votre application. Cette URL est valable pendant 5 minutes et la session qui en résulte est valide pendant 10 heures. L’opération d’API fournit l’URL avec un `auth_code` qui permet une session à connexion unique. 

Voici un exemple de réponse de `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"
}
```

Intégrez cette session de console à votre page Web à l'aide du [SDK Amazon Quick Sight Embedding](https://www.npmjs.com/package/amazon-quicksight-embedding-sdk) ou en ajoutant cette URL dans un iframe. Si vous définissez une hauteur et une largeur fixes (en pixels), Amazon Quick Sight les utilise et ne modifie pas votre visuel lorsque votre fenêtre est redimensionnée. Si vous définissez un pourcentage relatif de hauteur et de largeur, Amazon Quick Sight fournit une mise en page réactive qui est modifiée en fonction de l'évolution de la taille de votre fenêtre. En utilisant le SDK Amazon Quick Sight Embedding, vous pouvez également contrôler les paramètres au sein de la session de console et recevoir des rappels en termes de fin de chargement de page et d'erreurs. 

L’exemple suivant montre comment utiliser l’URL générée. Ce code est généré sur votre serveur d’applications.

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

Pour que cet exemple fonctionne, assurez-vous d'utiliser le SDK Amazon Quick Sight Embedding pour charger la session de console intégrée sur votre site Web à l'aide de. JavaScript Pour obtenir votre copie, effectuez l’une des actions suivantes :
+ Téléchargez le SDK d'[intégration Amazon Quick Sight](https://github.com/awslabs/amazon-quicksight-embedding-sdk#step-3-create-the-quicksight-session-object) depuis. GitHub Ce référentiel est géré par un groupe de développeurs Amazon Quick Sight.
+ Téléchargez la dernière version du SDK d'intégration sur. [https://www.npmjs.com/package/amazon-quicksight-embedding-sdk](https://www.npmjs.com/package/amazon-quicksight-embedding-sdk)
+ Si vous utilisez `npm` for JavaScript dependencies, téléchargez-le et installez-le en exécutant la commande suivante.

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