本文属于机器翻译版本。若本译文内容与英语原文存在差异，则一律以英文原文为准。

# 将 Amazon Quick Sight 仪表板嵌入亚马逊快速视图 API
<a name="embedding-dashboards"></a>

使用以下主题了解如何使用 Amazon Quick Sight API 嵌入控制面板。

**Topics**
+ [

# 为注册用户嵌入 Amazon 快速浏览控制面板
](embedded-analytics-dashboards-for-authenticated-users.md)
+ [

# 为匿名（未注册）用户嵌入 Amazon Quick Sight 控制面板
](embedded-analytics-dashboards-for-everyone.md)
+ [

# 在嵌入式控制面板中启用执行摘要
](embedded-analytics-genbi-executive-summaries-dashboard.md)

# 为注册用户嵌入 Amazon 快速浏览控制面板
<a name="embedded-analytics-dashboards-for-authenticated-users"></a>

**重要**  
Amazon Quick Sight 推出了用于嵌入分析的新 API 操作：`GenerateEmbedUrlForAnonymousUser`和`GenerateEmbedUrlForRegisteredUser`。  
您仍然可以使用`GetDashboardEmbedUrl`和 `GetSessionEmbedUrl` API 操作来嵌入仪表板和 Amazon Quick Sight 控制台，但它们不包含最新的嵌入功能。有关使用旧 API 操作进行嵌入的更多信息，请参阅[使用GetDashboardEmbedURL和 GetSessionEmbedURL API 操作嵌入分析](https://docs.amazonaws.cn/quicksight/latest/user/embedded-analytics-deprecated.html)。


|  | 
| --- |
|  适用于：企业版  | 


|  | 
| --- |
|    目标受众：Amazon Quick 开发者  | 

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

**Topics**
+ [

## 步骤 1：设置权限
](#embedded-dashboards-for-authenticated-users-step-1)
+ [

## 步骤 2：生成附带身份验证代码的 URL
](#embedded-dashboards-for-authenticated-users-step-2)
+ [

## 步骤 3：嵌入控制面板 URL
](#embedded-dashboards-for-authenticated-users-step-3)

## 步骤 1：设置权限
<a name="embedded-dashboards-for-authenticated-users-step-1"></a>

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

每个访问控制面板的用户都扮演一个角色，授予他们 Amazon Quick Sight 访问控制面板的权限和权限。要实现这一点，请在您的中创建一个 IAM 角色 Amazon Web Services 账户。将一个 IAM 策略与该角色相关联，以便为担任该角色的任何用户提供权限。IAM 角色需要提供权限才能检索特定用户池 URLs 的嵌入内容。借助通配符 *\$1*，您可以授予为特定命名空间中的所有用户部分用户生成 URL 的权限。为此，请添加 `quicksight:GenerateEmbedUrlForRegisteredUser`。

您可以在 IAM 策略中创建一个条件，限制开发人员可以在 `GenerateEmbedUrlForRegisteredUser` API 操作的 `AllowedDomains` 参数中列出的域。`AllowedDomains` 参数是可选参数。作为开发者，它允许您选择覆盖在 “**管理 Amazon Quick Sight**” 菜单中配置的静态域。您最多可以列出三个可以访问生成的 URL 的域或子域。然后，此 URL 将嵌入您创建的网站。只有参数中列出的域才能访问嵌入式视觉对象。如果没有此条件，则可以在 `AllowedDomains` 参数中列出互联网上的任何域。

要限制开发人员可用于此参数的域，请在 IAM 策略中添加一个 `AllowedEmbeddingDomains` 条件。有关该`AllowedDomains`参数的更多信息，请参阅 *Amazon Quick Sight API 参考[GenerateEmbedUrlForRegisteredUser](https://docs.amazonaws.cn//quicksight/latest/APIReference/API_GenerateEmbedUrlForRegisteredUser.html)*中的。

**IAM 条件运算符的安全最佳实践**  
配置不当的 IAM 条件运算符可能会允许未经授权地通过 URL 变体访问您的嵌入式 Quick 资源。在您的 IAM 策略中使用`quicksight:AllowedEmbeddingDomains`条件密钥时，请使用条件运算符，允许特定域名或拒绝所有未特别允许的域。有关 IAM 条件运算符的更多信息，请参阅 [IAM 用户指南中的 IAM JSON 策略元素：条件运算符](https://docs.amazonaws.cn/IAM/latest/UserGuide/reference_policies_elements_condition_operators.html)。  
许多不同的网址变体可以指向同一个资源。例如，以下 URLs 所有内容都解析为相同的内容：  
`https://example.com`
`https://example.com/`
`https://Example.com`
如果您的策略使用的运算符不考虑这些 URL 变体，则攻击者可以通过提供等效的 URL 变体来绕过您的限制。  
您必须验证您的 IAM 策略是否使用了适当的条件运算符来防止绕过漏洞，并确保只有您的目标域才能访问您的嵌入式资源。

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

此外，如果您要创建将成为 Amazon Quick Sight 读者的首次用户，请务必在策略中添加`quicksight:RegisterUser`权限。

以下示例策略为即将成为 Amazon Quick Sight 读者的首次用户提供了检索嵌入网址的权限。

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

------
#### [ 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"
        }
    ]
}
```

------

有关 OpenId Connect 或 SAML 身份验证的信任策略的更多信息，请参阅 *IAM 用户指南* 的以下部分：
+ [创建用于 Web 联合身份验证或 OpenID Connect 联合身份验证的角色（控制台）](https://docs.amazonaws.cn/IAM/latest/UserGuide/id_roles_create_for-idp_oidc.html)
+ [创建用于 SAML 2.0 联合身份验证的角色（控制台）](https://docs.amazonaws.cn/IAM/latest/UserGuide/id_roles_create_for-idp_saml.html)

## 步骤 2：生成附带身份验证代码的 URL
<a name="embedded-dashboards-for-authenticated-users-step-2"></a>

在下节中，您可以了解如何对用户进行身份验证，并获取应用程序服务器上的可嵌入控制面板 URL。如果您计划为 IAM 或 Amazon Quick Sight 身份类型嵌入控制面板，请与用户共享控制面板。

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

执行这些步骤可确保在 Amazon Quick Sight 中对控制面板的每个查看者进行唯一配置。它还实施每个用户的设置，例如，行级别安全性和参数的动态默认值。

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

### 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 Amazon 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, // Amazon 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 Amazon = 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: Amazon 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>

以下示例显示了可以在应用服务器上用来生成嵌入式仪表板的 URL 的 JavaScript (Node.js)。您可以在网站或应用程序中使用该 URL 以显示控制面板。

**Example**  

```
const Amazon = 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>

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

**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);
                }
            }
        }
    }
```

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

要代入该角色，请选择以下 Amazon Security Token Service (Amazon STS) API 操作之一：
+ [AssumeRole](https://docs.amazonaws.cn/STS/latest/APIReference/API_AssumeRole.html)— 当您使用 IAM 身份代入角色时，请使用此操作。
+ [AssumeRoleWithWebIdentity](https://docs.amazonaws.cn/STS/latest/APIReference/API_AssumeRoleWithWebIdentity.html)— 当您使用 Web 身份提供商对用户进行身份验证时，请使用此操作。
+ [AssumeRoleWithSaml](https://docs.amazonaws.cn/STS/latest/APIReference/API_AssumeRoleWithSAML.html)— 当您使用 SAML 对用户进行身份验证时，请使用此操作。

以下示例显示了用于设置 IAM 角色的 CLI 命令。该角色需要为 `quicksight:GenerateEmbedUrlForRegisteredUser` 启用权限。如果您采用一种在用户首次打开仪表板时添加用户的 just-in-time方法，则该角色还需要为其启用权限`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\$1ACCESS\$1KEY\$1ID* 
*AWS\$1SECRET\$1访问密钥* 
*AWS\$1SESSION\$1代币* 

以下示例说明了如何在 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_dashboard_role/john.doe@example.com`。角色会话 ID 由 `role-arn` 中的角色名称和 `role-session-name` 值组成。每个用户使用唯一的角色会话 ID 可以确保为每个用户设置相应的权限。此外，它还能避免任何用户访问限制。*限制*是一项安全功能，可防止同一个用户从多个位置访问 Amazon Quick Sight。

角色会话 ID 也将成为 Amazon Quick Sight 中的用户名。您可以使用此模式提前在 Amazon Quick Sight 中配置用户，或者在他们首次访问控制面板时对其进行配置。

以下示例显示了可用于预置用户的 CLI 命令。有关[RegisterUser[DescribeUser](https://docs.amazonaws.cn/quicksight/latest/APIReference/API_DescribeUser.html)](https://docs.amazonaws.cn/quicksight/latest/APIReference/API_RegisterUser.html)、和其他 Amazon Quick Sight API 操作的更多信息，请参阅[亚马逊 Quick Sight API 参考](https://docs.amazonaws.cn/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
```

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

用户首次访问 Amazon Quick Sight 时，您也可以将该用户添加到与之共享控制面板的群组中。以下示例显示了将用户添加到组的 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"
```

现在，您的应用程序的用户也是 Amazon Quick Sight 的用户，并且可以访问控制面板。

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

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

有关使用此操作的更多信息，请参阅 [https://docs.amazonaws.cn/quicksight/latest/APIReference/API_GenerateEmbedUrlForRegisteredUser.html](https://docs.amazonaws.cn/quicksight/latest/APIReference/API_GenerateEmbedUrlForRegisteredUser.html)。您可以在自己的代码中使用该 API 操作和其他操作。

## 步骤 3：嵌入控制面板 URL
<a name="embedded-dashboards-for-authenticated-users-step-3"></a>

在下一节中，您可以了解如何使用 [Amazon Quick Sight Embedging SDK](https://www.npmjs.com/package/amazon-quicksight-embedding-sdk) (JavaScript) 将第 3 步中的控制面板网址嵌入到您的网站或应用程序页面中。通过使用该开发工具包，您可以执行以下操作：
+ 将控制面板放在 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/embed/12345/dashboards/67890..",
        "RequestId": "7bee030e-f191-45c4-97fe-d9faf0e03713"
    }
```

使用 [Amazon Quick Sight Embedding SDK 或将此 URL 添加到 iframe 中，将此控制面板嵌](https://www.npmjs.com/package/amazon-quicksight-embedding-sdk)入到您的网页中。如果您设置了固定的高度和宽度数字（以像素为单位），Amazon Quick Sight 会使用这些数字，并且不会在窗口大小调整时更改视觉效果。如果您设置相对的百分比高度和宽度，Amazon Quick Sight 会提供响应式布局，该布局会随着窗口大小的变化而进行修改。通过使用 Amazon Quick Sight Embedding SDK，您还可以控制控制面板中的参数并接收有关页面加载完成和错误的回调。

要托管嵌入式控制面板的域必须位于*允许列表*（为您的 Quick 订阅批准的域的列表）中。这一要求可阻止未经批准的域托管嵌入式控制面板，从而保护您的数据。有关为嵌入式控制面板添加域名的更多信息，请参阅[允许使用 Amazon Quick Sight API 在运行时列出域名](https://docs.amazonaws.cn/quicksight/latest/user/embedding-run-time.html)。

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

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

要使此示例起作用，请务必使用 Amazon Quick Sight Embedding SDK 将嵌入式控制面板加载到您的网站上 JavaScript。要获取副本，请执行下列操作之一：
+ 从 GitHub中下载 [Amazon Quick Sight 嵌入软件开发工具包](https://github.com/awslabs/amazon-quicksight-embedding-sdk#step-3-create-the-quicksight-session-object) 该存储库由一组 Amazon Quick Sight 开发人员维护。
+ 从下载最新的嵌入式 SDK 版本[https://www.npmjs.com/package/amazon-quicksight-embedding-sdk](https://www.npmjs.com/package/amazon-quicksight-embedding-sdk)。
+ 如果您使用`npm` JavaScript 依赖关系，请通过运行以下命令下载并安装它。

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

# 为匿名（未注册）用户嵌入 Amazon Quick Sight 控制面板
<a name="embedded-analytics-dashboards-for-everyone"></a>

**重要**  
Amazon Quick Sight 推出了用于嵌入分析的新 API 操作：`GenerateEmbedUrlForAnonymousUser`和`GenerateEmbedUrlForRegisteredUser`。  
您仍然可以使用`GetDashboardEmbedUrl`和 `GetSessionEmbedUrl` API 操作来嵌入仪表板和 Amazon Quick Sight 控制台，但它们不包含最新的嵌入功能。有关使用旧 API 操作进行嵌入的更多信息，请参阅[使用GetDashboardEmbedURL和 GetSessionEmbedURL API 操作嵌入分析](https://docs.amazonaws.cn/quicksight/latest/user/embedded-analytics-deprecated.html)。


|  | 
| --- |
|  适用于：企业版  | 


|  | 
| --- |
|    目标受众：Amazon Quick 开发者  | 

在以下各节中，您可以找到有关如何为匿名（未注册）用户设置嵌入式 Amazon Quick Sight 控制面板的详细信息。

**Topics**
+ [

## 步骤 1：设置权限
](#embedded-analytics-dashboards-with-anonymous-users-step-1)
+ [

## 步骤 2：生成附带身份验证代码的 URL
](#embedded-analytics-dashboards-with-anonymous-users-step-2)
+ [

## 步骤 3：嵌入控制面板 URL
](#embedded-analytics-dashboards-with-anonymous-users-step-3)

## 步骤 1：设置权限
<a name="embedded-analytics-dashboards-with-anonymous-users-step-1"></a>


|  | 
| --- |
|  适用于：企业版  | 


|  | 
| --- |
|    目标受众：Amazon Quick 开发者  | 

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

每个访问控制面板的用户都扮演一个角色，授予他们 Amazon Quick Sight 访问控制面板的权限和权限。要实现这一点，请在您的中创建一个 IAM 角色 Amazon Web Services 账户。将一个 IAM 策略与该角色相关联，以便为担任该角色的任何用户提供权限。

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

要限制开发人员可用于此参数的域，请在 IAM 策略中添加一个 `AllowedEmbeddingDomains` 条件。有关该`AllowedDomains`参数的更多信息，请参阅 *Amazon Quick Sight API 参考[GenerateEmbedUrlForAnonymousUser](https://docs.amazonaws.cn//quicksight/latest/APIReference/API_GenerateEmbedUrlForAnonymousUser.html)*中的。

**IAM 条件运算符的安全最佳实践**  
配置不当的 IAM 条件运算符可能会允许未经授权地通过 URL 变体访问您的嵌入式 Quick 资源。在您的 IAM 策略中使用`quicksight:AllowedEmbeddingDomains`条件密钥时，请使用条件运算符，允许特定域名或拒绝所有未特别允许的域。有关 IAM 条件运算符的更多信息，请参阅 [IAM 用户指南中的 IAM JSON 策略元素：条件运算符](https://docs.amazonaws.cn/IAM/latest/UserGuide/reference_policies_elements_condition_operators.html)。  
许多不同的网址变体可以指向同一个资源。例如，以下 URLs 所有内容都解析为相同的内容：  
`https://example.com`
`https://example.com/`
`https://Example.com`
如果您的策略使用不考虑这些 URL 变体的运算符，则攻击者可以通过提供等效的 URL 变体来绕过您的限制。  
您必须验证您的 IAM 策略是否使用了适当的条件运算符来防止绕过漏洞，并确保只有您的目标域才能访问您的嵌入式资源。

以下示例策略提供了可用于 `GenerateEmbedUrlForAnonymousUser` 的这些权限。要让这种方法发挥作用，您的 Amazon Web Services 账户还需要会话包或会话容量定价。否则，当用户尝试访问控制面板时，会返回 `UnsupportedPricingPlanException` 错误。

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

------
#### [ 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"
    }
]
}
```

------

有关信任策略的更多信息，请参阅《IAM 用户指南》**中的 [IAM 临时安全凭证](https://docs.amazonaws.cn/IAM/latest/UserGuide/id_credentials_temp.html)。

## 步骤 2：生成附带身份验证代码的 URL
<a name="embedded-analytics-dashboards-with-anonymous-users-step-2"></a>


|  | 
| --- |
|  适用于：企业版  | 


|  | 
| --- |
|    目标受众：Amazon Quick 开发者  | 

在下节中，您可以了解如何代表匿名访问者进行身份验证，并获取应用程序服务器上的可嵌入控制面板 URL。

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

以下示例展示了代表用户执行 IAM 身份验证。将标识符作为唯一角色会话 ID 进行传递。此代码在您的应用程序服务器上运行。

### 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 Amazon 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 Amazon 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 Amazon = require('aws-sdk');

function generateEmbedUrlForAnonymousUser(
accountId, // YOUR Amazon 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>

以下示例显示了可以在应用服务器上用来生成嵌入式仪表板的 URL 的 JavaScript (Node.js)。您可以在网站或应用程序中使用该 URL 以显示控制面板。

**Example**  

```
const Amazon = 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>

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

**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);
    }
```

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

要代入该角色，请选择以下 Amazon Security Token Service (Amazon STS) API 操作之一：
+ [AssumeRole](https://docs.amazonaws.cn/STS/latest/APIReference/API_AssumeRole.html)— 当您使用 IAM 身份代入角色时，请使用此操作。
+ [AssumeRoleWithWebIdentity](https://docs.amazonaws.cn/STS/latest/APIReference/API_AssumeRoleWithWebIdentity.html)— 当您使用 Web 身份提供商对用户进行身份验证时，请使用此操作。
+ [AssumeRoleWithSaml](https://docs.amazonaws.cn/STS/latest/APIReference/API_AssumeRoleWithSAML.html)— 当您使用安全断言标记语言 (SAML) 对用户进行身份验证时，请使用此操作。

以下示例显示了用于设置 IAM 角色的 CLI 命令。该角色需要为 `quicksight:GenerateEmbedUrlForAnonymousUser` 启用权限。

```
aws sts assume-role \
    --role-arn "arn:aws:iam::11112222333:role/QuickSightEmbeddingAnonymousPolicy" \
    --role-session-name anonymous caller
```

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

**注意**  
如果在调用 `AssumeRole` 操作时遇到 `ExpiredToken` 错误，可能是因为之前的 `SESSION TOKEN` 仍在环境变量中。通过设置以下变量可以解决这一问题：  
*AWS\$1ACCESS\$1KEY\$1ID* 
*AWS\$1SECRET\$1访问密钥* 
*AWS\$1SESSION\$1代币* 

以下示例说明了如何在 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_dashboard_role/QuickSightEmbeddingAnonymousPolicy`。角色会话 ID 由 `role-arn` 中的角色名称和 `role-session-name` 值组成。每个用户使用唯一的角色会话 ID 可以确保为每个访问用户设置相应的权限。其还能让每个会话保持独立性和独特性。如果您使用一组 Web 服务器（例如用于负载平衡），并且会话重新连接到其他服务器，则会开始新的会话。

要获取控制面板的签名 URL，请从应用程序服务器中调用 `generate-embed-url-for-anynymous-user`。这会返回可嵌入的控制面板 URL。以下示例演示了如何使用服务器端调用为匿名访问您 Web 门户或应用程序的用户生成嵌入式控制面板的 URL。

```
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}}'
```

有关使用此操作的更多信息，请参阅 [https://docs.amazonaws.cn/quicksight/latest/APIReference/API_GenerateEmbedUrlForAnonymousUser.html](https://docs.amazonaws.cn/quicksight/latest/APIReference/API_GenerateEmbedUrlForAnonymousUser.html)。您可以在自己的代码中使用该 API 操作和其他操作。

## 步骤 3：嵌入控制面板 URL
<a name="embedded-analytics-dashboards-with-anonymous-users-step-3"></a>


|  | 
| --- |
|  适用于：企业版  | 


|  | 
| --- |
|    目标受众：Amazon Quick 开发者  | 

在下一节中，您可以了解如何使用 [Amazon Quick Sight Embedging SDK](https://www.npmjs.com/package/amazon-quicksight-embedding-sdk) (JavaScript) 将第 2 步中的控制面板网址嵌入到您的网站或应用程序页面中。通过使用该开发工具包，您可以执行以下操作：
+ 将控制面板放在 HTML 页面上。
+ 将参数传递到控制面板。
+ 使用为应用程序自定义的消息处理错误状态。

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

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

使用 [Amazon Quick Sight Embedding SDK 或将此 URL 添加到 iframe 中，将此控制面板嵌](https://www.npmjs.com/package/amazon-quicksight-embedding-sdk)入到您的网页中。如果您设置了固定的高度和宽度数字（以像素为单位），Amazon Quick Sight 会使用这些数字，并且不会随着窗口大小调整而改变视觉效果。如果您设置相对的百分比高度和宽度，Amazon Quick Sight 会提供响应式布局，该布局会随着窗口大小的变化而进行修改。通过使用 Amazon Quick Sight Embedding SDK，您还可以控制控制面板中的参数并接收有关页面加载完成和错误的回调。

要托管嵌入式控制面板的域必须位于*允许列表*（为您的 Quick 订阅批准的域的列表）中。这一要求可阻止未经批准的域托管嵌入式控制面板，从而保护您的数据。有关为嵌入式控制面板添加域名的更多信息，请参阅[允许使用 Amazon Quick Sight API 在运行时列出域名](https://docs.amazonaws.cn/quicksight/latest/user/embedding-run-time.html)。

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

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

要使此示例起作用，请务必使用 Amazon Quick Sight Embedding SDK 将嵌入式控制面板加载到您的网站上 JavaScript。要获取副本，请执行下列操作之一：
+ 从 GitHub中下载 [Amazon Quick Sight 嵌入软件开发工具包](https://github.com/awslabs/amazon-quicksight-embedding-sdk#step-3-create-the-quicksight-session-object) 该存储库由一组 Amazon Quick Sight 开发人员维护。
+ 从中下载最新的 Amazon Quick Sight Embedgin [https://www.npmjs.com/package/amazon-quicksight-embedding-sdk](https://www.npmjs.com/package/amazon-quicksight-embedding-sdk)g S
+ 如果您使用`npm` JavaScript 依赖关系，请通过运行以下命令下载并安装它。

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

# 在嵌入式控制面板中启用执行摘要
<a name="embedded-analytics-genbi-executive-summaries-dashboard"></a>


|  | 
| --- |
|  适用于：企业版  | 


|  | 
| --- |
|    目标受众：Amazon Quick 开发者  | 

您可以在嵌入式控制面板中启用执行摘要。启用后，注册用户可以生成执行摘要，摘要提供 Amazon Quick Sight 为控制面板生成的所有见解的摘要。执行摘要使读者更容易找到有关控制面板的关键见解和信息。有关用户如何生成控制面板执行摘要的更多信息，请参阅生成 [Amazon Quick Sight 控制面板的执行摘要](https://docs.amazonaws.cn/quicksight/latest/user/use-executive-summaries.html)。

**注意**  
执行摘要仅在注册用户的嵌入式控制面板中可用，并且无法在匿名或未注册用户的嵌入式控制面板中启用。

**为注册用户启用嵌入式控制面板中的执行摘要**
+ 按照[嵌入 Amazon Quick Sight 控制面板中的步骤，注册用户可以](https://docs.amazonaws.cn/quicksight/latest/user/embedded-analytics-dashboards-for-authenticated-users.html)嵌入包含以下更改的控制面板：

  1. 在步骤 2 中生成 URL 时，`Enabled: true`请在[GenerateEmbedUrlForRegisteredUser](https://docs.amazonaws.cn/quicksight/latest/APIReference/API_GenerateEmbedUrlForRegisteredUser.html)或的`ExecutiveSummary`参数中进行设置 [GenerateEmbedUrlForRegisteredUserWithIdentity](https://docs.amazonaws.cn/quicksight/latest/APIReference/API_GenerateEmbedUrlForRegisteredUserWithIdentity.html)，如以下示例所示：

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

  1. 在步骤 3 中使用 Amazon Quick Sight Embedding SDK 嵌入控制面板 URL 时`contentOptions`，请在中进行设置`executiveSummary: true`，如以下示例所示：

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