为注册用户嵌入 Amazon QuickSight 控制台的完整功能 - Amazon QuickSight
步骤 1：设置权限步骤 2：生成 URL步骤 3：嵌入 URL

为注册用户嵌入 Amazon QuickSight 控制台的完整功能

重要

Amazon QuickSight 推出了用于嵌入分析的新 API 操作：GenerateEmbedUrlForAnonymousUser 和 GenerateEmbedUrlForRegisteredUser。

您仍然可以使用 GetDashboardEmbedUrl 和 GetSessionEmbedUrl API 操作来嵌入控制面板和 QuickSight 控制台，但其不包含最新的嵌入功能。有关使用旧 API 操作进行嵌入的更多信息，请参阅 使用 GetDashboardEmbedURL 和 GetSessionEmbedURL API 操作嵌入分析。

 适用于：企业版 
   目标受众：Amazon QuickSight 开发人员 

用上企业版后，除了提供只读控制面板，您还可以在自定义品牌创作门户中提供 Amazon QuickSight 控制台体验。您可以使用这种方法允许用户创建数据来源、数据集和分析。在同一个界面中，用户可以创建、发布和查看控制面板。如果您想限制其中的一些权限，也可以这样做。

通过嵌入式控制台访问 QuickSight 的用户需要属于作者或管理员安全组。读者没有足够的访问权限来使用 QuickSight 控制台进行创作，无论其是嵌入式还是 AWS Management Console 的一部分。不过，作者和管理员仍然可以访问嵌入式控制面板。如果您想限制某些创作功能的权限，可以通过 UpdateUser API 操作向用户添加自定义权限配置文件。使用 RegisterUser API 操作添加附带自定义权限配置文件的新用户。有关详细信息，请参阅以下章节：

在以下各节中，您可以了解有关如何为注册用户设置嵌入式 Amazon QuickSight 控制面板的详细信息。

步骤 1：设置权限

在下节中，您可以了解如何设置后端应用程序或 Web 服务器的权限。该任务需要具有 IAM 的管理访问权限。

访问 QuickSight 的每个用户代入一个角色，该角色向其授予 Amazon QuickSight 访问权限和控制台会话权限。要实现该目的，请在您的亚马逊云科技账户中创建一个 IAM 角色。将一个 IAM policy 与该角色相关联，以便为担任该角色的任何用户提供权限。请添加 quicksight:RegisterUser 权限，确保读者能以只读方式访问 QuickSight，并且无法访问其余数据或创建功能。IAM 角色还需要提供检索控制台会话 URL 的权限。为此，请添加 quicksight:GenerateEmbedUrlForRegisteredUser。

您可以在 IAM policy 中创建一个条件，限制开发人员可以在 GenerateEmbedUrlForAnonymousUser API 操作的 AllowedDomains 参数中列出的域。AllowedDomains 参数是可选参数。该参数允许您以开发人员身份覆盖在管理 QuickSight菜单中配置的静态域。您最多可以列出三个可以访问生成的 URL 的域或子域。然后，此 URL 将嵌入您创建的网站。只有参数中列出的域才能访问嵌入式控制面板。如果没有此条件，则可以在 AllowedDomains 参数中列出互联网上的任何域。

以下示例策略提供了这些权限。

{
    "Version": "2012-10-17",
    "Statement": [
        {
            "Action": "quicksight:RegisterUser",
            "Resource": "*",
            "Effect": "Allow"
        },
        {
            "Effect": "Allow",
            "Action": [
              "quicksight:GenerateEmbedUrlForRegisteredUser"
            ],
            "Resource": [
                "arn:partition:quicksight:region:accountId:user/namespace/userName"
            ],
            "Condition": {
                "ForAllValues:StringEquals": {
                    "quicksight:AllowedEmbeddingDomains": [
                        "https://my.static.domain1.com",
                        "https://*.my.static.domain2.com"
                ]
            }
        }
        }
    ]
}

以下示例策略提供了检索控制台会话 URL 的权限。如果您在用户访问嵌入式会话之前创建用户，则可以使用不具有 quicksight:RegisterUser 的策略。

{
    "Version": "2012-10-17",
    "Statement": [
        {
            "Effect": "Allow",
            "Action": [
              "quicksight:GenerateEmbedUrlForRegisteredUser"
            ],
            "Resource": [
                "arn:partition:quicksight:region:accountId:user/namespace/userName"
            ],
            "Condition": {
                "ForAllValues:StringEquals": {
                    "quicksight:AllowedEmbeddingDomains": [
                        "https://my.static.domain1.com",
                        "https://*.my.static.domain2.com"
                ]
            }
        }
        }
    ]
}

最后，您应用程序的 IAM 身份必须具有关联的信任策略，才允许访问您刚创建的角色。这意味着，在用户访问您的应用程序时，您的应用程序可以代表用户代入该角色，并在 QuickSight 中预置用户。下面演示了一个示例信任策略。

{
    "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"
        }
    ]
}

有关 OpenId Connect 或 SAML 身份验证的信任策略的更多信息，请参阅 IAM 用户指南 的以下部分：

步骤 2：生成附带身份验证代码的 URL

在下节中，您可以了解如何对用户进行身份验证，并获取应用程序服务器上的可嵌入控制台会话 URL。

用户访问您的应用程序时，该应用程序代表用户代入 IAM 角色。然后，其会将用户添加到 QuickSight 中（如果该用户尚不存在）。接下来，其会将标识符作为唯一角色会话 ID 进行传递。

执行上述步骤可确保在 QuickSight 中唯一地预置每个控制台会话查看者。它还实施每个用户的设置，例如，行级别安全性和参数的动态默认值。

以下示例展示了代表用户执行 IAM 身份验证。此代码在您的应用程序服务器上运行。

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();
    }
}
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);
                }
            });
        }
    });
}
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)

以下示例演示了可以在应用服务器上使用以生成嵌入式控制台会话 URL 的 JavaScript（Node.js）。您可以在网站或应用程序中使用该 URL 来显示控制台会话。

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);
});
// 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'
    }

以下示例演示了可以在应用服务器上使用以生成嵌入式控制台会话 URL 的 .NET/C# 代码。您可以在网站或应用程序中使用该 URL 来显示控制台。

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 Security Token Service (AWS STS) API 操作之一：

  • AssumeRole – 在使用 IAM 身份代入角色时使用此操作。

  • AssumeRoleWithWebIdentity – 在使用 Web 身份提供者对用户进行身份验证时使用此操作。

  • AssumeRoleWithSaml – 在使用 SAML 对用户进行身份验证时使用此操作。

以下示例显示了用于设置 IAM 角色的 CLI 命令。该角色需要为 quicksight:GenerateEmbedUrlForRegisteredUser 启用权限。如果您在用户首次打开 QuickSight 时采用即时方法添加用户，则该角色还需要为 quicksight:RegisterUser 启用权限。

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

assume-role 操作返回三个输出参数：访问密钥、私有密钥和会话令牌。

注意

如果在调用 AssumeRole 操作时遇到 ExpiredToken 错误，可能是因为之前的 SESSION TOKEN 仍在环境变量中。通过设置以下变量可以解决这一问题：

  • AWS_ACCESS_KEY_ID

  • AWS_SECRET_ACCESS_KEY

  • AWS_SESSION_TOKEN

以下示例说明了如何在 CLI 中设置这三个参数。如果使用的是 Microsoft Windows 计算机，请使用 set 而非 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"

如果运行这些命令，则会将访问您的网站的用户的角色会话 ID 设置为 embedding_quicksight_console_session_role/john.doe@example.com。角色会话 ID 由 role-arn 中的角色名称和 role-session-name 值组成。每个用户使用唯一的角色会话 ID 可以确保为每个用户设置相应的权限。此外，它还能避免任何用户访问限制。节流是一项安全功能，可防止同一用户从多个位置访问 QuickSight。

角色会话 ID 还会在 QuickSight 中变为用户名。您可以使用该模式在 QuickSight 中提前预置用户，或者在用户首次访问控制台会话时进行预置。

以下示例显示了可用于预置用户的 CLI 命令。有关 RegisterUser、DescribeUser 和其他 QuickSight API 操作的更多信息，请参阅 QuickSight API Reference。

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

如果用户通过 Microsoft AD 进行身份验证，则无需使用 RegisterUser 进行设置。他们应在首次访问 QuickSight 时自动订阅。对于 Microsoft AD 用户，您可以使用 DescribeUser 获取用户 ARN。

用户首次访问 QuickSight 时，您也可以将该用户添加到相应的组中。以下示例显示了将用户添加到组的 CLI 命令。

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

您的应用程序现在有一个用户，该用户也是 QuickSight 用户，且有权访问 QuickSight 控制台会话。

最后，要获取控制台会话的签名 URL，请从应用程序服务器中调用 generate-embed-url-for-registered-user。此操作会返回可嵌入控制台会话 URL。以下示例演示了如何使用服务器端调用为通过 AWS Managed Microsoft AD 或单点登录（IAM Identity Center）进行身份验证的用户生成嵌入式控制台会话的 URL。

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"}

有关使用此操作的更多信息，请参阅 GenerateEmbedUrlForRegisteredUser。您可以在自己的代码中使用该 API 操作和其他操作。

步骤 3：嵌入控制台会话 URL

在下节中，您可以了解如何使用 Amazon QuickSight Embedding SDK（JavaScript）将步骤 3 中的控制台会话 URL 嵌入网站或应用程序页面。通过使用该开发工具包，您可以执行以下操作：

  • 将控制台会话置于 HTML 页面上。

  • 将参数传入控制台会话。

  • 使用为应用程序自定义的消息处理错误状态。

调用 GenerateEmbedUrlForRegisteredUser API 操作生成可嵌入应用的 URL。该 URL 的有效时间为 5 分钟，生成的会话有效时间为 10 个小时。该 API 操作为 URL 提供 auth_code 以启用单点登录会话。

下面显示了 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"
}

通过使用 QuickSight Embedding SDK 或将该 URL 添加到 iframe 中，将该控制台会话嵌入网页。如果设置了固定高度和宽度数字（以像素为单位），QuickSight 将使用这些数字，并且在调整窗口大小时不会更改视觉对象。如果设置了相对百分比高度和宽度，QuickSight 将提供随窗口大小变化而修改的响应式布局。通过使用 Amazon QuickSight Embedding SDK，您还可以控制控制台会话中的参数，并在页面加载完成和出现错误时收到回调。

要托管嵌入式控制面板的域必须位于允许列表（为您的 Amazon QuickSight 订阅批准的域的列表）中。这一要求可阻止未经批准的域托管嵌入式控制面板，从而保护您的数据。有关为嵌入式控制台添加域的更多信息，请参阅 允许在运行时使用 QuickSight API 列出域。

以下示例演示了如何使用生成的 URL。此代码在您的应用程序服务器上生成。

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

要让此示例起作用，请确保使用 Amazon QuickSight Embedding SDK 在网站上用 JavaScript 加载嵌入式控制台会话。要获取副本，请执行下列操作之一：