翻訳は機械翻訳により提供されています。提供された翻訳内容と英語版の間で齟齬、不一致または矛盾がある場合、英語版が優先します。

# Amazon Quick Sight APIs を使用した埋め込み
<a name="embedded-analytics-api"></a>


|  | 
| --- |
|  適用対象: Enterprise Edition  | 


|  | 
| --- |
|    対象者:  Amazon Quick デベロッパー  | 

Amazon Quick Sight APIs を使用して分析を埋め込む実際のプロセスには、いくつかのステップしかありません。

作業を開始する前に、以下の準備が整っていることを確認します。
+  AWS SDK を使用して API コールを行うアプリケーションで使用される発信者 ID に必要な IAM アクセス許可を設定します。たとえば、`quicksight:GenerateEmbedUrlForAnonymousUser` または `quicksight:GenerateEmbedUrlForRegisteredUser` アクションを許可するアクセス許可を付与します。
+ 登録済みユーザーに を埋め込むには、事前に Amazon Quick Sight アセットを共有します。新規認証ユーザーの場合、アセットへのアクセスを許可する方法を理解する必要があります。これを行う 1 つの方法は、すべてのアセットを Amazon Quick Sight フォルダに追加することです。Amazon Quick Sight API を使用する場合は、 `DescribeDashboardPermissions`および `UpdateDashboardPermissions` API オペレーションを使用します。詳細については、*Amazon Quick API リファレンス*の[DescribeDashboardPermissions](https://docs.aws.amazon.com/quicksight/latest/APIReference/API_DescribeDashboardPermissions.html)」または[UpdateDashboardPermissions](https://docs.aws.amazon.com/quicksight/latest/APIReference/API_UpdateDashboardPermissions.html)」を参照してください。名前空間またはグループ内のすべてのユーザーとダッシュボードを共有する場合は、ダッシュボードを `namespace` または `group` で共有できます。
+ ダッシュボードを埋め込む場合は、埋め込むダッシュボードの ID を持っていることを確認してください。ダッシュボード ID は、ダッシュボードの URL 内にあるコードです。ダッシュボードの URL から取得することもできます。
+ Amazon Quick Sight 管理者は、Amazon Quick Sight 分析を埋め込む予定のドメインを明示的に有効にする必要があります。これを行うには、プロファイルメニューから **Amazon Quick Sight、ドメイン、埋め込みを管理する**か、 `GenerateEmbedUrlForAnonymousUser` または `GenerateEmbedUrlForRegisteredUser` API コールの `AllowedDomains`パラメータを使用します。 ****

  このオプションは、Amazon Quick Sight 管理者にのみ表示されます。サブドメインをドメインの一部として追加することもできます。詳しくは、「[Amazon Quick API を使用して実行時にドメインの一覧表示を許可する](manage-domains.md#embedding-run-time)」を参照してください。

  許可リスト内のすべての静的ドメイン (開発、ステージング、本稼働など) は明示的に許可され、HTTPS を使用している必要があります。許可リストには最大 100 個のドメインを追加できます。Amazon Quick Sight API オペレーションを使用して、実行時にドメインを追加できます。

すべての前提条件が完了したら、Amazon Quick Sight を埋め込むには次のステップが必要です。詳細については、後で説明します。

1. 認証では、アプリケーションサーバーを使用してユーザーを認証します。サーバーでの認証後、必要な AWS SDK を使用して埋め込みダッシュボード URL を生成します。

1. ウェブポータルまたはアプリケーションに、生成された URL を使用して Amazon Quick Sight を埋め込みます。このプロセスを簡素化するために、[NPMJS](https://www.npmjs.com/package/amazon-quicksight-embedding-sdk) および [GitHub](https://github.com/awslabs/amazon-quicksight-embedding-sdk) で利用可能な Amazon Quick Sight Embedding SDK を使用できます。このカスタマイズされた JavaScript SDK は、Amazon Quick Sight をアプリケーションページに効率的に統合し、デフォルトを設定し、コントロールを接続し、コールバックを取得し、エラーを処理するのに役立つように設計されています。

 AWS CloudTrail 監査ログを使用して、埋め込みダッシュボードの数、埋め込みエクスペリエンスのユーザー、アクセス率に関する情報を取得できます。

**Topics**
+ [

# Amazon Quick Sight API を使用した Amazon Quick Sight ダッシュボードの埋め込み
](embedding-dashboards.md)
+ [

# Amazon Quick Sight APIs を使用した Amazon Quick Sight ビジュアルの埋め込み
](embedding-visuals.md)
+ [

# 登録済みユーザー向けの Amazon Quick Sight コンソールの全機能の埋め込み
](embedded-analytics-full-console-for-authenticated-users.md)
+ [

# Amazon Quick Sight Generative Q&A エクスペリエンスに Amazon Q を埋め込む
](embedding-gen-bi.md)
+ [

# Amazon Quick Sight Q 検索バーの埋め込み (クラシック)
](embedding-quicksight-q.md)
+ [

# GetDashboardEmbedURL および GetSessionEmbedURL API 操作を使用した分析の埋め込み
](embedded-analytics-deprecated.md)

# Amazon Quick Sight API を使用した Amazon Quick Sight ダッシュボードの埋め込み
<a name="embedding-dashboards"></a>

Amazon Quick Sight API を使用したダッシュボードの埋め込みについては、以下のトピックを参照してください。

**Topics**
+ [

# 登録済みユーザー向けの Amazon Quick Sight ダッシュボードの埋め込み
](embedded-analytics-dashboards-for-authenticated-users.md)
+ [

# 匿名 (未登録) ユーザー向けの Amazon Quick Sight ダッシュボードの埋め込み
](embedded-analytics-dashboards-for-everyone.md)
+ [

# 埋め込みダッシュボードでエグゼクティブサマリーを有効にする
](embedded-analytics-genbi-executive-summaries-dashboard.md)

# 登録済みユーザー向けの Amazon Quick Sight ダッシュボードの埋め込み
<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.aws.amazon.com/quicksight/latest/user/embedded-analytics-deprecated.html)」を参照してください。


|  | 
| --- |
|  適用対象: Enterprise Edition  | 


|  | 
| --- |
|    対象者:  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>

次のセクションでは、バックエンドアプリケーションまたはウェブサーバーのアクセス許可を設定する方法について説明します。このタスクには IAM への管理者アクセス権が必要です。

ダッシュボードにアクセスする各ユーザーは、Amazon Quick Sight にダッシュボードへのアクセスとアクセス許可を付与するロールを引き受けます。これを可能にするには、 で IAM ロールを作成します AWS アカウント。IAM ポリシーをロールに関連付けて、それを引き受けるすべてのユーザーにアクセス許可を付与します。IAM ロールでは、特定のユーザープールに埋め込み URL を取得するアクセス許可を提供する必要があります。ワイルドカード文字 *\$1* を使用すると、特定の名前空間のすべてのユーザー、または特定の名前空間のユーザーのサブセットに対して、URL を生成する許可を付与できます。このためには、`quicksight:GenerateEmbedUrlForRegisteredUser` を追加します。

IAM ポリシーで条件を作成し、デベロッパーが `GenerateEmbedUrlForRegisteredUser` API オペレーションの `AllowedDomains` パラメータにリストできるドメインを制限できます。`AllowedDomains` パラメータはオプションのパラメータです。これにより、**Amazon Quick Sight の管理**メニューで設定された静的ドメインを上書きするオプションが開発者として付与されます。代わりに、生成された URL にアクセスできるドメインもしくはサブドメインを、3 つまでリストアップできます。この URL は、作成した Web サイトに埋め込むことが可能です。パラメータにリストされているドメインのみが、埋め込みビジュアルにアクセスすることが可能です。この状態にしていない場合、インターネット上の任意のドメインを `AllowedDomains` パラメータにリストできてしまいます。

デベロッパーがこのパラメータで使用できるドメインを制限するには、`AllowedEmbeddingDomains` 条件を IAM ポリシーに追加します。`AllowedDomains` パラメータの詳細については、*Amazon Quick Sight API リファレンス*の[GenerateEmbedUrlForRegisteredUser](https://docs.aws.amazon.com//quicksight/latest/APIReference/API_GenerateEmbedUrlForRegisteredUser.html)」を参照してください。

**IAM 条件演算子のセキュリティのベストプラクティス**  
正しく設定されていない IAM 条件演算子は、URL のバリエーションを通じて埋め込み Quick リソースへの不正アクセスを許可できます。IAM ポリシーで `quicksight:AllowedEmbeddingDomains` 条件キーを使用する場合は、特定のドメインを許可するか、特に許可されていないすべてのドメインを拒否する条件演算子を使用します。IAM 条件演算子の詳細については、IAM [ユーザーガイドの「IAM JSON ポリシー要素: 条件演算子](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_elements_condition_operators.html)」を参照してください。  
多くの異なる URL バリエーションが同じリソースを指す場合があります。たとえば、次の URLsはすべて同じコンテンツに解決されます。  
`https://example.com`
`https://example.com/`
`https://Example.com`
ポリシーでこれらの URL バリエーションを考慮しない演算子を使用している場合、攻撃者は同等の URL バリエーションを提供することで制限を回避できます。  
IAM ポリシーが適切な条件演算子を使用してバイパスの脆弱性を防ぎ、目的のドメインのみが埋め込みリソースにアクセスできることを確認する必要があります。

次のサンプルポリシーで、これらの権限が付与されます。

さらに、Amazon Quick Sight リーダーとなる初めてユーザーを作成する場合は、ポリシーに アクセス`quicksight:RegisterUser`許可を追加してください。

次のサンプルポリシーは、Amazon Quick Sight リーダーになる初めてのユーザーの埋め込み URL を取得するアクセス許可を提供します。

最後に、作成したロールへのアクセスを許可するには、アプリケーションの IAM ID に関連付けられた信頼ポリシーが必要です。つまり、ユーザーがアプリケーションにアクセスすると、アプリケーションはユーザーに代わってロールを引き受け、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 ユーザーガイド*」の以下のセクションを参照してください。
+ [ウェブ ID または OpenID Connect フェデレーション用のロールを作成する (コンソール)](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_create_for-idp_oidc.html)
+ [SAML 2.0 フェデレーション用のロールの作成 (コンソール)](https://docs.aws.amazon.com/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 ID タイプのダッシュボードを埋め込む場合は、ダッシュボードをユーザーと共有します。

ユーザーがアプリケーションにアクセスすると、アプリケーションはユーザーに代わって 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 AWS SDK to get url for dashboard embedding.
    */
    public class GetQuicksightEmbedUrlRegisteredUserDashboardEmbedding {

        private final AmazonQuickSight quickSightClient;

        public GetQuicksightEmbedUrlRegisteredUserDashboardEmbedding() {
            this.quickSightClient = AmazonQuickSightClientBuilder
                    .standard()
                    .withRegion(Regions.US_EAST_1.getName())
                    .withCredentials(new AWSCredentialsProvider() {
                        @Override
                        public AWSCredentials getCredentials() {
                            // provide actual IAM access key and secret key here
                            return new BasicAWSCredentials("access-key", "secret-key");
                        }

                        @Override
                        public void refresh() {}
                        }
                    )
                    .build();
        }

        public String getQuicksightEmbedUrl(
                final String accountId, // AWS Account ID
                final String dashboardId, // Dashboard ID to embed
                final List<String> allowedDomains, // Runtime allowed domain for embedding
                final String userArn // Registered user arn to use for embedding. Refer to Get Embed Url section in developer portal to find out how to get user arn for a QuickSight user.
        ) throws Exception {
            final RegisteredUserEmbeddingExperienceConfiguration experienceConfiguration = new RegisteredUserEmbeddingExperienceConfiguration()
                    .withDashboard(new RegisteredUserDashboardEmbeddingConfiguration().withInitialDashboardId(dashboardId));
            final GenerateEmbedUrlForRegisteredUserRequest generateEmbedUrlForRegisteredUserRequest = new GenerateEmbedUrlForRegisteredUserRequest();
            generateEmbedUrlForRegisteredUserRequest.setAwsAccountId(accountId);
            generateEmbedUrlForRegisteredUserRequest.setUserArn(userArn);
            generateEmbedUrlForRegisteredUserRequest.setAllowedDomains(allowedDomains);
            generateEmbedUrlForRegisteredUserRequest.setExperienceConfiguration(experienceConfiguration);

            final GenerateEmbedUrlForRegisteredUserResult generateEmbedUrlForRegisteredUserResult = quickSightClient.generateEmbedUrlForRegisteredUser(generateEmbedUrlForRegisteredUserRequest);

            return generateEmbedUrlForRegisteredUserResult.getEmbedUrl();
        }
    }
```

### JavaScript
<a name="embedded-dashboards-for-authenticated-users-js"></a>

```
global.fetch = require('node-fetch');
    const AWS = require('aws-sdk');

    function generateEmbedUrlForRegisteredUser(
        accountId,
        dashboardId,
        openIdToken, // Cognito-based token
        userArn, // registered user arn
        roleArn, // IAM user role to use for embedding
        sessionName, // Session name for the roleArn assume role
        allowedDomains, // Runtime allowed domain for embedding
        getEmbedUrlCallback, // GetEmbedUrl success callback method
        errorCallback // GetEmbedUrl error callback method
        ) {
        const stsClient = new AWS.STS();
        let stsParams = {
            RoleSessionName: sessionName,
            WebIdentityToken: openIdToken,
            RoleArn: roleArn
        }

        stsClient.assumeRoleWithWebIdentity(stsParams, function(err, data) {
            if (err) {
                console.log('Error assuming role');
                console.log(err, err.stack);
                errorCallback(err);
            } else {
                const getDashboardParams = {
                    "AwsAccountId": accountId,
                    "ExperienceConfiguration": {
                        "Dashboard": {
                            "InitialDashboardId": dashboardId
                        }
                    },
                    "UserArn": userArn,
                    "AllowedDomains": allowedDomains,
                    "SessionLifetimeInMinutes": 600
                };

                const quicksightClient = new AWS.QuickSight({
                    region: process.env.AWS_REGION,
                    credentials: {
                        accessKeyId: data.Credentials.AccessKeyId,
                        secretAccessKey: data.Credentials.SecretAccessKey,
                        sessionToken: data.Credentials.SessionToken,
                        expiration: data.Credentials.Expiration
                    }
                });

                quicksightClient.generateEmbedUrlForRegisteredUser(getDashboardParams, function(err, data) {
                    if (err) {
                        console.log(err, err.stack);
                        errorCallback(err);
                    } else {
                        const result = {
                            "statusCode": 200,
                            "headers": {
                                "Access-Control-Allow-Origin": "*", // Use your website domain to secure access to GetEmbedUrl API
                                "Access-Control-Allow-Headers": "Content-Type"
                            },
                            "body": JSON.stringify(data),
                            "isBase64Encoded": false
                        }
                        getEmbedUrlCallback(result);
                    }
                });
            }
        });
    }
```

### Python3
<a name="embedded-dashboards-for-authenticated-users-py"></a>

```
import json
import boto3
from botocore.exceptions import ClientError

sts = boto3.client('sts')

# Function to generate embedded URL  
# accountId: AWS account ID
# dashboardId: Dashboard ID to embed
# userArn: arn of registered user
# allowedDomains: Runtime allowed domain for embedding
# roleArn: IAM user role to use for embedding
# sessionName: session name for the roleArn assume role
def getEmbeddingURL(accountId, dashboardId, userArn, allowedDomains, roleArn, sessionName):
    try:
        assumedRole = sts.assume_role(
            RoleArn = roleArn,
            RoleSessionName = sessionName,
        )
    except ClientError as e:
        return "Error assuming role: " + str(e)
    else: 
        assumedRoleSession = boto3.Session(
            aws_access_key_id = assumedRole['Credentials']['AccessKeyId'],
            aws_secret_access_key = assumedRole['Credentials']['SecretAccessKey'],
            aws_session_token = assumedRole['Credentials']['SessionToken'],
        )
        try:
            quicksightClient = assumedRoleSession.client('quicksight', region_name='us-west-2')
            response = quicksightClient.generate_embed_url_for_registered_user(
                AwsAccountId=accountId,
                ExperienceConfiguration = {
                    "Dashboard": {
                        "InitialDashboardId": dashboardId
                    }
                },
                UserArn = userArn,
                AllowedDomains = allowedDomains,
                SessionLifetimeInMinutes = 600
            )
            
            return {
                'statusCode': 200,
                'headers': {"Access-Control-Allow-Origin": "*", "Access-Control-Allow-Headers": "Content-Type"},
                'body': json.dumps(response),
                'isBase64Encoded':  bool('false')
            }
        except ClientError as e:
            return "Error generating embedding url: " + str(e)
```

### Node.js
<a name="embedded-dashboards-for-authenticated-users-node"></a>

次の例は、埋め込みダッシュボードの URL を生成するためにアプリケーションサーバーで使用できる JavaScript (Node.js) を示しています。ダッシュボードを表示するには、ウェブサイトまたはアプリでこの URL を使用します。

**Example**  

```
const AWS = require('aws-sdk');
    const https = require('https');

    var quicksightClient = new AWS.Service({
        apiConfig: require('./quicksight-2018-04-01.min.json'),
        region: 'us-east-1',
    });

    quicksightClient.generateEmbedUrlForRegisteredUser({
        'AwsAccountId': '111122223333',
        'ExperienceConfiguration': { 
            'Dashboard': {
                'InitialDashboardId': '1c1fe111-e2d2-3b30-44ef-a0e111111cde'
            }
        },
        'UserArn': 'REGISTERED_USER_ARN',
        'AllowedDomains': allowedDomains,
        'SessionLifetimeInMinutes': 100
    }, function(err, data) {
        console.log('Errors: ');
        console.log(err);
        console.log('Response: ');
        console.log(data);
    });
```

**Example**  

```
//The URL returned is over 900 characters. For this example, we've shortened the string for
    //readability and added ellipsis to indicate that it's incomplete.
        { 
            Status: 200,
            EmbedUrl: 'https://quicksightdomain/embed/12345/dashboards/67890...'
            RequestId: '7bee030e-f191-45c4-97fe-d9faf0e03713' 
        }
```

### .NET/C\$1
<a name="embedded-dashboards-for-authenticated-users-cs"></a>

次の例は、埋め込みダッシュボードの 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);
                }
            }
        }
    }
```

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

ロールを引き受けるには、次のいずれかの AWS Security Token Service (AWS STS) API オペレーションを選択します。
+ [AssumeRole](https://docs.aws.amazon.com/STS/latest/APIReference/API_AssumeRole.html) – ロールを引き受けるために IAM ID を使用している場合は、このオペレーションを使用します。
+ [AssumeRoleWithWebIdentity](https://docs.aws.amazon.com/STS/latest/APIReference/API_AssumeRoleWithWebIdentity.html) – ユーザーの認証にウェブ ID プロバイダーを使用している場合は、このオペレーションを使用します。
+ [AssumeRoleWithSaml](https://docs.aws.amazon.com/STS/latest/APIReference/API_AssumeRoleWithSAML.html) – ユーザーの認証に SAML を使用している場合は、このオペレーションを使用します。

次の例は、IAM ロールを設定するための CLI コマンドを示しています。ロールは、`quicksight:GenerateEmbedUrlForRegisteredUser` を有効にする許可を取得する必要があります。ユーザーがダッシュボードを初めて開いたときに、ジャストインタイム方式でユーザーを追加する場合は、ロールには `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` オペレーションは、アクセスキー、シークレットキー、およびセッショントークンの 3 つの出力パラメータを返します。

**注記**  
`AssumeRole` オペレーションを呼び出すときに `ExpiredToken` エラーが発生した場合は、以前の `SESSION TOKEN` がまだ環境変数に残っている可能性があります。以下の変数を設定することで、これをオフにします。  
*AWS\$1ACCESS\$1KEY\$1ID* 
*AWS\$1SECRET\$1ACCESS\$1KEY* 
*AWS\$1SESSION\$1TOKEN* 

次の例は、CLI でこれら 3 つのパラメータを設定する方法を示しています。Microsoft Windows マシンを使用している場合は、`export` の代わりに `set` を使用します。

```
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](https://docs.aws.amazon.com/quicksight/latest/APIReference/API_RegisterUser.html)、[DescribeUser](https://docs.aws.amazon.com/quicksight/latest/APIReference/API_DescribeUser.html)、およびその他の Amazon Quick Sight API オペレーションの詳細については、[「Amazon Quick Sight API リファレンス](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
```

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 を返します。次の例は、 AWS Managed Microsoft AD またはシングルサインオン (IAM アイデンティティセンター) で認証されたユーザーのサーバー側の呼び出しを使用して、埋め込みダッシュボードの 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.aws.amazon.com/quicksight/latest/APIReference/API_GenerateEmbedUrlForRegisteredUser.html](https://docs.aws.amazon.com/quicksight/latest/APIReference/API_GenerateEmbedUrlForRegisteredUser.html) を参照してください。これと他の API オペレーションは、独自のコードで使用できます。

## ステップ 3: ダッシュボード URL を埋め込む
<a name="embedded-dashboards-for-authenticated-users-step-3"></a>

次のセクションでは、[Amazon Quick Sight Embedding SDK](https://www.npmjs.com/package/amazon-quicksight-embedding-sdk) (JavaScript) を使用して、ステップ 3 のダッシュボード URL をウェブサイトまたはアプリケーションページに埋め込む方法について説明します。SDK を使用すると、次のことを実行できます。
+ ダッシュボードを HTML ページに配置します。
+ ダッシュボードにパラメータを渡します。
+ アプリケーションに合わせてカスタマイズされたメッセージでエラー状態を処理します。

`GenerateEmbedUrlForRegisteredUser` API オペレーションを呼び出して URL を生成し、アプリケーションに埋め込みます。この URL は 5 分間有効で、得られたセッションは最大 10 時間有効です。API オペレーションは、シングルサインオンセッションを有効にする `auth_code` の URL を提供します。

以下に、`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 を使用する](https://www.npmjs.com/package/amazon-quicksight-embedding-sdk)か、この URL を iframe に追加して、このダッシュボードをウェブページに埋め込みます。固定の高さと幅の数値 (ピクセル単位) を設定した場合、Amazon Quick Sight はそれらを使用し、ウィンドウのサイズ変更に伴ってビジュアルを変更しません。相対的な高さと幅の割合を設定すると、Amazon Quick Sight はウィンドウサイズの変化に応じて変化するレスポンシブレイアウトを提供します。Amazon Quick Sight Embedding SDK を使用すると、ダッシュボード内のパラメータを制御し、ページロードの完了とエラーの観点からコールバックを受信することもできます。

埋め込みダッシュボードをホストするドメインは、許可リスト ( Quick サブスクリプションで承認されたドメインのリスト) に登録されている必要があります。この要件は、未承認のドメインが埋め込みダッシュボードをホストしないようにすることでデータを保護します。埋め込みダッシュボードのドメインの追加の詳細については、[「Amazon Quick Sight API を使用して実行時にドメインを一覧表示するのを許可する](https://docs.aws.amazon.com/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 Embedding SDK](https://github.com/awslabs/amazon-quicksight-embedding-sdk#step-3-create-the-quicksight-session-object) をダウンロードします。このリポジトリは、Amazon Quick Sight 開発者のグループによって管理されます。
+ [https://www.npmjs.com/package/amazon-quicksight-embedding-sdk](https://www.npmjs.com/package/amazon-quicksight-embedding-sdk) から、最新の埋め込み SDK バージョンをダウンロードします。
+ JavaScript の依存関係の `npm` を使用する場合、次のコマンドを実行してダウンロードおよびインストールします。

  ```
  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.aws.amazon.com/quicksight/latest/user/embedded-analytics-deprecated.html)」を参照してください。


|  | 
| --- |
|  適用対象: Enterprise Edition  | 


|  | 
| --- |
|    対象者:  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>


|  | 
| --- |
|  適用対象: Enterprise Edition  | 


|  | 
| --- |
|    対象者:  Amazon Quick デベロッパー  | 

次のセクションでは、バックエンドアプリケーションまたはウェブサーバーのアクセス許可を設定する方法について説明します。このタスクには IAM への管理者アクセス権が必要です。

ダッシュボードにアクセスする各ユーザーは、Amazon Quick Sight にダッシュボードへのアクセスとアクセス許可を付与するロールを引き受けます。これを可能にするには、 で IAM ロールを作成します AWS アカウント。IAM ポリシーをロールに関連付けて、それを引き受けるすべてのユーザーにアクセス許可を付与します。

IAM ポリシーで条件を作成し、デベロッパーが `GenerateEmbedUrlForAnonymousUser` API オペレーションの `AllowedDomains` パラメータにリストできるドメインを制限できます。`AllowedDomains` パラメータはオプションのパラメータです。これにより、**Amazon Quick Sight の管理**メニューで設定された静的ドメインを上書きするオプションが開発者として付与されます。代わりに、生成された URL へのアクセスが可能な、ドメインもしくはサブドメインを、最大 3 つまでリストアップすることもできます。この URL は、作成した Web サイトに埋め込むことが可能です。パラメータにリストされているドメインのみが、埋め込みダッシュボードにアクセスできます。この状態にしていない場合、インターネット上の任意のドメインを `AllowedDomains` パラメータにリストできてしまいます。

デベロッパーがこのパラメータで使用できるドメインを制限するには、`AllowedEmbeddingDomains` 条件を IAM ポリシーに追加します。`AllowedDomains` パラメータの詳細については、*Amazon Quick Sight API リファレンス*の[GenerateEmbedUrlForAnonymousUser](https://docs.aws.amazon.com//quicksight/latest/APIReference/API_GenerateEmbedUrlForAnonymousUser.html)」を参照してください。

**IAM 条件演算子のセキュリティのベストプラクティス**  
正しく設定されていない IAM 条件演算子は、URL のバリエーションを通じて埋め込み Quick リソースへの不正アクセスを許可できます。IAM ポリシーで `quicksight:AllowedEmbeddingDomains` 条件キーを使用する場合は、特定のドメインを許可するか、特に許可されていないすべてのドメインを拒否する条件演算子を使用します。IAM 条件演算子の詳細については、IAM [ユーザーガイドの「IAM JSON ポリシー要素: 条件演算子](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_elements_condition_operators.html)」を参照してください。  
多くの異なる URL バリエーションが同じリソースを指す場合があります。たとえば、次の URLsはすべて同じコンテンツに解決されます。  
`https://example.com`
`https://example.com/`
`https://Example.com`
ポリシーでこれらの URL バリエーションを考慮しない演算子を使用している場合、攻撃者は同等の URL バリエーションを提供することで制限を回避できます。  
IAM ポリシーが適切な条件演算子を使用してバイパスの脆弱性を防ぎ、目的のドメインのみが埋め込みリソースにアクセスできることを確認する必要があります。

次のサンプルポリシーで、`GenerateEmbedUrlForAnonymousUser` で使用するこれらの許可が付与されます。このアプローチを機能させるには、 AWS アカウントでセッションパックまたはセッションキャパシティーの料金が必要となります。これがないと、ユーザーがダッシュボードにアクセスする際に、エラー `UnsupportedPricingPlanException` が返されます。

作成したロールへのアクセスを許可するには、アプリケーションの IAM ID に関連付けられた信頼ポリシーが必要です。つまり、ユーザーがアプリケーションにアクセスすると、アプリケーションはユーザーに代わってロールを引き受け、ダッシュボードを開きます。次の例は、サンプルの信頼ポリシーを示しています。

------
#### [ 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.aws.amazon.com/IAM/latest/UserGuide/id_credentials_temp.html)」を参照してください。

## ステップ 2: 認証コードがアタッチされた URL を生成する
<a name="embedded-analytics-dashboards-with-anonymous-users-step-2"></a>


|  | 
| --- |
|  適用対象: Enterprise Edition  | 


|  | 
| --- |
|    対象者:  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 AWS SDK to generate embed url for anonymous user.
    */
    public class GenerateEmbedUrlForAnonymousUserExample {

        private final AmazonQuickSight quickSightClient;

        public GenerateEmbedUrlForAnonymousUserExample() {
            quickSightClient = AmazonQuickSightClientBuilder
                .standard()
                .withRegion(Regions.US_EAST_1.getName())
                .withCredentials(new AWSCredentialsProvider() {
                        @Override
                        public AWSCredentials getCredentials() {
                            // provide actual IAM access key and secret key here
                            return new BasicAWSCredentials("access-key", "secret-key");
                        }

                        @Override
                        public void refresh() {
                        }
                    }
                )
                .build();
        }

        public String GenerateEmbedUrlForAnonymousUser(
            final String accountId, // YOUR AWS ACCOUNT ID
            final String initialDashboardId, // DASHBOARD ID TO WHICH THE CONSTRUCTED URL POINTS.
            final String namespace, // ANONYMOUS EMBEDDING REQUIRES SPECIFYING A VALID NAMESPACE FOR WHICH YOU WANT THE EMBEDDING URL
            final List<String> authorizedResourceArns, // DASHBOARD ARN LIST TO EMBED
            final List<String> allowedDomains, // RUNTIME ALLOWED DOMAINS FOR EMBEDDING
            final List<SessionTag> sessionTags // SESSION TAGS USED FOR ROW-LEVEL SECURITY
        ) throws Exception {
            AnonymousUserEmbeddingExperienceConfiguration experienceConfiguration = new AnonymousUserEmbeddingExperienceConfiguration();
            AnonymousUserDashboardEmbeddingConfiguration dashboardConfiguration = new AnonymousUserDashboardEmbeddingConfiguration();
            dashboardConfiguration.setInitialDashboardId(initialDashboardId);
            experienceConfiguration.setDashboard(dashboardConfiguration);

            GenerateEmbedUrlForAnonymousUserRequest generateEmbedUrlForAnonymousUserRequest = new GenerateEmbedUrlForAnonymousUserRequest()
                .withAwsAccountId(accountId)
                .withNamespace(namespace)
                .withAuthorizedResourceArns(authorizedResourceArns)
                .withExperienceConfiguration(experienceConfiguration)
                .withSessionTags(sessionTags)
                .withSessionLifetimeInMinutes(600L); // OPTIONAL: VALUE CAN BE [15-600]. DEFAULT: 600
                .withAllowedDomains(allowedDomains);

            GenerateEmbedUrlForAnonymousUserResult dashboardEmbedUrl = quickSightClient.generateEmbedUrlForAnonymousUser(generateEmbedUrlForAnonymousUserRequest);

            return dashboardEmbedUrl.getEmbedUrl();
        }

    }
```

### JavaScript
<a name="embedded-analytics-dashboards-with-anonymous-users-js"></a>

```
global.fetch = require('node-fetch');
const AWS = require('aws-sdk');

function generateEmbedUrlForAnonymousUser(
accountId, // YOUR AWS ACCOUNT ID
initialDashboardId, // DASHBOARD ID TO WHICH THE CONSTRUCTED URL POINTS
quicksightNamespace, // VALID NAMESPACE WHERE YOU WANT TO DO NOAUTH EMBEDDING
authorizedResourceArns, // DASHBOARD ARN LIST TO EMBED
allowedDomains, // RUNTIME ALLOWED DOMAINS FOR EMBEDDING
sessionTags, // SESSION TAGS USED FOR ROW-LEVEL SECURITY
generateEmbedUrlForAnonymousUserCallback, // GENERATEEMBEDURLFORANONYMOUSUSER SUCCESS CALLBACK METHOD
errorCallback // GENERATEEMBEDURLFORANONYMOUSUSER ERROR CALLBACK METHOD
) {
const experienceConfiguration = {
    "DashboardVisual": {
        "InitialDashboardVisualId": {
            "DashboardId": "dashboard_id",
            "SheetId": "sheet_id",
            "VisualId": "visual_id"
        }
    }
};

const generateEmbedUrlForAnonymousUserParams = {
    "AwsAccountId": accountId,
    "Namespace": quicksightNamespace,
    "AuthorizedResourceArns": authorizedResourceArns,
    "AllowedDomains": allowedDomains,
    "ExperienceConfiguration": experienceConfiguration,
    "SessionTags": sessionTags,
    "SessionLifetimeInMinutes": 600
};

const quicksightClient = new AWS.QuickSight({
    region: process.env.AWS_REGION,
    credentials: {
        accessKeyId: AccessKeyId,
        secretAccessKey: SecretAccessKey,
        sessionToken: SessionToken,
        expiration: Expiration
    }
});

quicksightClient.generateEmbedUrlForAnonymousUser(generateEmbedUrlForAnonymousUserParams, function(err, data) {
    if (err) {
        console.log(err, err.stack);
        errorCallback(err);
    } else {
        const result = {
            "statusCode": 200,
            "headers": {
                "Access-Control-Allow-Origin": "*", // USE YOUR WEBSITE DOMAIN TO SECURE ACCESS TO THIS API
                "Access-Control-Allow-Headers": "Content-Type"
            },
            "body": JSON.stringify(data),
            "isBase64Encoded": false
        }
        generateEmbedUrlForAnonymousUserCallback(result);
    }
});
}
```

### Python3
<a name="embedded-analytics-dashboards-with-anonymous-users-py"></a>

```
import json
import boto3
from botocore.exceptions import ClientError
import time

# Create QuickSight and STS clients
quicksightClient = boto3.client('quicksight',region_name='us-west-2')
sts = boto3.client('sts')

# Function to generate embedded URL for anonymous user
# accountId: YOUR AWS ACCOUNT ID
# quicksightNamespace: VALID NAMESPACE WHERE YOU WANT TO DO NOAUTH EMBEDDING
# authorizedResourceArns: DASHBOARD ARN LIST TO EMBED
# allowedDomains: RUNTIME ALLOWED DOMAINS FOR EMBEDDING
# dashboardId: DASHBOARD ID TO WHICH THE CONSTRUCTED URL POINTS
# sessionTags: SESSION TAGS USED FOR ROW-LEVEL SECURITY
def generateEmbedUrlForAnonymousUser(accountId, quicksightNamespace, authorizedResourceArns, allowedDomains, dashboardId, sessionTags):
try:
    response = quicksightClient.generate_embed_url_for_anonymous_user(
        AwsAccountId = accountId,
        Namespace = quicksightNamespace,
        AuthorizedResourceArns = authorizedResourceArns,
        AllowedDomains = allowedDomains,
            ExperienceConfiguration = {
                "Dashboard": {
                    "InitialDashboardId": dashboardId
                }
            },
        SessionTags = sessionTags,
        SessionLifetimeInMinutes = 600
    )
        
    return {
        'statusCode': 200,
        'headers': {"Access-Control-Allow-Origin": "*", "Access-Control-Allow-Headers": "Content-Type"},
        'body': json.dumps(response),
        'isBase64Encoded':  bool('false')
    }
except ClientError as e:
    print(e)
    return "Error generating embeddedURL: " + str(e)
```

### Node.js
<a name="embedded-analytics-dashboards-with-anonymous-users-node"></a>

次の例は、埋め込みダッシュボードの URL を生成するためにアプリケーションサーバーで使用できる JavaScript (Node.js) を示しています。ダッシュボードを表示するには、ウェブサイトまたはアプリでこの URL を使用します。

**Example**  

```
const AWS = require('aws-sdk');
    const https = require('https');

    var quicksightClient = new AWS.Service({
        apiConfig: require('./quicksight-2018-04-01.min.json'),
        region: 'us-east-1',
    });

    quicksightClient.generateEmbedUrlForAnonymousUser({
        'AwsAccountId': '111122223333',
        'Namespace' : 'default',
        'AuthorizedResourceArns': authorizedResourceArns,
        'AllowedDomains': allowedDomains,
        'ExperienceConfiguration': experienceConfiguration,
        'SessionTags': sessionTags,
        'SessionLifetimeInMinutes': 600

    }, function(err, data) {
        console.log('Errors: ');
        console.log(err);
        console.log('Response: ');
        console.log(data);
    });
```

**Example**  

```
//The URL returned is over 900 characters. For this example, we've shortened the string for
    //readability and added ellipsis to indicate that it's incomplete.
        { 
            Status: 200,
            EmbedUrl: 'https://quicksightdomain/embed/12345/dashboards/67890..',
            RequestId: '7bee030e-f191-45c4-97fe-d9faf0e03713' 
        }
```

### .NET/C\$1
<a name="embedded-analytics-dashboards-with-anonymous-users-cs"></a>

次の例は、埋め込みダッシュボードの 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);
    }
```

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

ロールを引き受けるには、次のいずれかの AWS Security Token Service (AWS STS) API オペレーションを選択します。
+ [AssumeRole](https://docs.aws.amazon.com/STS/latest/APIReference/API_AssumeRole.html) – ロールを引き受けるために IAM ID を使用している場合は、このオペレーションを使用します。
+ [AssumeRoleWithWebIdentity](https://docs.aws.amazon.com/STS/latest/APIReference/API_AssumeRoleWithWebIdentity.html) – ユーザーの認証にウェブ ID プロバイダーを使用している場合は、このオペレーションを使用します。
+ [AssumeRoleWithSaml](https://docs.aws.amazon.com/STS/latest/APIReference/API_AssumeRoleWithSAML.html) – ユーザーの認証に Security Assertion Markup Language (SAML) を使用している場合は、このオペレーションを使用します。

次の例は、IAM ロールを設定するための CLI コマンドを示しています。ロールは、`quicksight:GenerateEmbedUrlForAnonymousUser` を有効にする許可を取得する必要があります。

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

`assume-role` オペレーションは、アクセスキー、シークレットキー、およびセッショントークンの 3 つの出力パラメータを返します。

**注記**  
`AssumeRole` オペレーションを呼び出すときに `ExpiredToken` エラーが発生した場合は、以前の `SESSION TOKEN` がまだ環境変数に残っている可能性があります。以下の変数を設定することで、これをオフにします。  
*AWS\$1ACCESS\$1KEY\$1ID* 
*AWS\$1SECRET\$1ACCESS\$1KEY* 
*AWS\$1SESSION\$1TOKEN* 

次の例は、CLI でこれら 3 つのパラメータを設定する方法を示しています。Microsoft Windows マシンを使用している場合は、`export` の代わりに `set` を使用します。

```
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 を使用すると、各訪問ユーザーに適切なアクセス許可が設定されます。また、各セッションを別個に保ちます。ロードバランシングなどのウェブサーバーの配列を使用していて、セッションが別のサーバーに再接続されると、新しいセッションが開始されます。

ダッシュボードの署名付き URL を取得するには、アプリケーションサーバーから `generate-embed-url-for-anynymous-user` を呼び出します。これは埋め込み可能なダッシュボードの URL を返します。次の例は、ウェブポータルまたはアプリケーションに匿名で訪問するユーザーのサーバーサイド呼び出しを使用して、埋め込みダッシュボードの 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.aws.amazon.com/quicksight/latest/APIReference/API_GenerateEmbedUrlForAnonymousUser.html](https://docs.aws.amazon.com/quicksight/latest/APIReference/API_GenerateEmbedUrlForAnonymousUser.html) を参照してください。これと他の API オペレーションは、独自のコードで使用できます。

## ステップ 3: ダッシュボード URL を埋め込む
<a name="embedded-analytics-dashboards-with-anonymous-users-step-3"></a>


|  | 
| --- |
|  適用対象: Enterprise Edition  | 


|  | 
| --- |
|    対象者:  Amazon Quick デベロッパー  | 

次のセクションでは、[Amazon Quick Sight Embedding SDK](https://www.npmjs.com/package/amazon-quicksight-embedding-sdk) (JavaScript) を使用して、ステップ 2 のダッシュボード URL をウェブサイトまたはアプリケーションページに埋め込む方法について説明します。SDK を使用すると、次のことを実行できます。
+ ダッシュボードを HTML ページに配置します。
+ ダッシュボードにパラメータを渡します。
+ アプリケーションに合わせてカスタマイズされたメッセージでエラー状態を処理します。

`GenerateEmbedUrlForAnynymousUser` API オペレーションを呼び出して URL を生成し、アプリケーションに埋め込みます。この URL は 5 分間有効で、得られたセッションは 10 時間有効です。API オペレーションは、シングルサインオンセッションを有効にする `auth_code` の URL を提供します。

以下に、`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 を使用する](https://www.npmjs.com/package/amazon-quicksight-embedding-sdk)か、この URL を iframe に追加して、このダッシュボードをウェブページに埋め込みます。固定の高さと幅の数値 (ピクセル単位) を設定した場合、Amazon Quick Sight はそれらを使用し、ウィンドウのサイズ変更に伴ってビジュアルを変更しません。相対的な高さと幅の割合を設定すると、Amazon Quick Sight はウィンドウサイズの変化に応じて変化するレスポンシブレイアウトを提供します。Amazon Quick Sight Embedding SDK を使用すると、ダッシュボード内のパラメータを制御し、ページロードの完了とエラーの観点からコールバックを受信することもできます。

埋め込みダッシュボードをホストするドメインは、許可リスト ( Quick サブスクリプションで承認されたドメインのリスト) に登録されている必要があります。この要件は、未承認のドメインが埋め込みダッシュボードをホストしないようにすることでデータを保護します。埋め込みダッシュボードのドメインの追加の詳細については、[「Amazon Quick Sight API を使用して実行時にドメインを一覧表示するの](https://docs.aws.amazon.com/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 Embedding SDK](https://github.com/awslabs/amazon-quicksight-embedding-sdk#step-3-create-the-quicksight-session-object) をダウンロードします。このリポジトリは、Amazon Quick Sight 開発者のグループによって管理されます。
+ [https://www.npmjs.com/package/amazon-quicksight-embedding-sdk](https://www.npmjs.com/package/amazon-quicksight-embedding-sdk) から最新の Amazon Quick Sight Embedding SDK バージョンをダウンロードします。
+ JavaScript の依存関係の `npm` を使用する場合、次のコマンドを実行してダウンロードおよびインストールします。

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

# 埋め込みダッシュボードでエグゼクティブサマリーを有効にする
<a name="embedded-analytics-genbi-executive-summaries-dashboard"></a>


|  | 
| --- |
|  適用対象: Enterprise Edition  | 


|  | 
| --- |
|    対象者:  Amazon Quick デベロッパー  | 

埋め込みダッシュボードでエグゼクティブサマリーを有効にすることができます。有効にすると、登録されたユーザーは、Amazon Quick Sight がダッシュボードに対して生成したすべてのインサイトの概要を提供するエグゼクティブサマリーを生成できます。エグゼクティブサマリーを使用すると、ユーザーはダッシュボードに関する重要なインサイトや情報を簡単に見つけることができます。ユーザーがダッシュボードのエグゼクティブサマリーを生成する方法の詳細については、[「Amazon Quick Sight ダッシュボードのエグゼクティブサマリーを生成する](https://docs.aws.amazon.com/quicksight/latest/user/use-executive-summaries.html)」を参照してください。

**注記**  
エグゼクティブサマリーは、登録済みユーザーの埋め込みダッシュボードでのみ使用でき、匿名ユーザーまたは未登録ユーザーの埋め込みダッシュボードで有効にすることはできません。

**登録済みユーザーの埋め込みダッシュボードでエグゼクティブサマリーを有効にするには**
+ [登録済みユーザーが以下の変更を加えてダッシュボードを埋め込むには、「Amazon Quick Sight](https://docs.aws.amazon.com/quicksight/latest/user/embedded-analytics-dashboards-for-authenticated-users.html) ダッシュボードを埋め込む」のステップに従います。

  1. ステップ 2 で URL を生成するときに、次の例に示すように [GenerateEmbedUrlForRegisteredUser](https://docs.aws.amazon.com/quicksight/latest/APIReference/API_GenerateEmbedUrlForRegisteredUser.html) または [GenerateEmbedUrlForRegisteredUserWithIdentity](https://docs.aws.amazon.com/quicksight/latest/APIReference/API_GenerateEmbedUrlForRegisteredUserWithIdentity.html) の `ExecutiveSummary` パラメータに `Enabled: true` を設定します。

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

# Amazon Quick Sight APIs を使用した Amazon Quick Sight ビジュアルの埋め込み
<a name="embedding-visuals"></a>

Amazon Quick Sight API を使用して、公開されたダッシュボードの一部である個々のビジュアルをアプリケーションに埋め込むことができます。

**Topics**
+ [

# 登録済みユーザー向けの Amazon Quick Sight ビジュアルの埋め込み
](embedded-analytics-visuals-for-authenticated-users.md)
+ [

# 匿名 (未登録) ユーザー向けの Amazon Quick Sight ビジュアルの埋め込み
](embedded-analytics-visuals-for-everyone.md)

# 登録済みユーザー向けの Amazon Quick Sight ビジュアルの埋め込み
<a name="embedded-analytics-visuals-for-authenticated-users"></a>


|  | 
| --- |
|  適用対象: Enterprise Edition  | 


|  | 
| --- |
|    対象者:  Amazon Quick デベロッパー  | 

以下のセクションでは、Amazon Quick Sight の登録済みユーザー向けに埋め込み Amazon Quick Sight ビジュアルを設定する方法について詳しく説明します。

**Topics**
+ [

## ステップ 1: 許可をセットアップする
](#embedded-visuals-for-authenticated-users-step-1)
+ [

## ステップ 2: 認証コードがアタッチされた URL を生成する
](#embedded-visuals-for-authenticated-users-step-2)
+ [

## ステップ 3: ヴィジュアルの URL を埋め込む
](#embedded-visuals-for-authenticated-users-step-3)

## ステップ 1: 許可をセットアップする
<a name="embedded-visuals-for-authenticated-users-step-1"></a>

次のセクションでは、バックエンドアプリケーションまたはウェブサーバーのアクセス許可を設定する方法について説明します。このタスクには IAM への管理者アクセス権が必要です。

ビジュアルにアクセスする各ユーザーは、Amazon Quick Sight にビジュアルへのアクセスとアクセス許可を付与するロールを引き受けます。これを可能にするには、 で IAM ロールを作成します AWS アカウント。IAM ポリシーをロールに関連付けて、それを引き受けるすべてのユーザーにアクセス許可を付与します。IAM ロールでは、特定のユーザープールに埋め込み URL を取得するアクセス許可を提供する必要があります。ワイルドカード文字 *\$1* を使用すると、特定の名前空間のすべてのユーザー、または特定の名前空間のユーザーのサブセットに対して、URL を生成する許可を付与できます。このためには、`quicksight:GenerateEmbedUrlForRegisteredUser` を追加します。

IAM ポリシーで条件を作成し、デベロッパーが `GenerateEmbedUrlForAnonymousUser` API オペレーションの `AllowedDomains` パラメータにリストできるドメインを制限できます。`AllowedDomains` パラメータはオプションのパラメータです。これにより、**Amazon Quick Sight の管理**メニューで設定された静的ドメインを上書きするオプションが開発者として付与されます。代わりに、生成された URL へのアクセスが可能な、ドメインもしくはサブドメインを、最大 3 つまでリストアップすることもできます。この URL は、作成した Web サイトに埋め込むことが可能です。パラメータにリストされているドメインのみが、埋め込みダッシュボードにアクセスできます。この状態にしていない場合、インターネット上の任意のドメインを `AllowedDomains` パラメータにリストできてしまいます。

デベロッパーがこのパラメータで使用できるドメインを制限するには、`AllowedEmbeddingDomains` 条件を IAM ポリシーに追加します。`AllowedDomains` パラメータの詳細については、*Amazon Quick Sight API リファレンス*の[GenerateEmbedUrlForRegisteredUser](https://docs.aws.amazon.com//quicksight/latest/APIReference/API_GenerateEmbedUrlForRegisteredUser.html)」を参照してください。

**IAM 条件演算子のセキュリティのベストプラクティス**  
正しく設定されていない IAM 条件演算子は、URL のバリエーションを通じて埋め込み Quick リソースへの不正アクセスを許可できます。IAM ポリシーで `quicksight:AllowedEmbeddingDomains` 条件キーを使用する場合は、特定のドメインを許可するか、特に許可されていないすべてのドメインを拒否する条件演算子を使用します。IAM 条件演算子の詳細については、IAM [ユーザーガイドの「IAM JSON ポリシー要素: 条件演算子](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_elements_condition_operators.html)」を参照してください。  
多くの異なる URL バリエーションが同じリソースを指す場合があります。たとえば、次の URLsはすべて同じコンテンツに解決されます。  
`https://example.com`
`https://example.com/`
`https://Example.com`
ポリシーでこれらの URL バリエーションを考慮しない演算子を使用している場合、攻撃者は同等の URL バリエーションを提供することで制限を回避できます。  
IAM ポリシーが適切な条件演算子を使用してバイパスの脆弱性を防ぎ、目的のドメインのみが埋め込みリソースにアクセスできることを確認する必要があります。

次のサンプルポリシーで、これらの権限が付与されます。

さらに、Amazon Quick Sight リーダーとなる初めてユーザーを作成する場合は、ポリシーに アクセス`quicksight:RegisterUser`許可を追加してください。

次のサンプルポリシーは、Amazon Quick Sight リーダーになる初めてのユーザーの埋め込み URL を取得するアクセス許可を提供します。

最後に、作成したロールへのアクセスを許可するには、アプリケーションの IAM ID に関連付けられた信頼ポリシーが必要です。つまり、ユーザーがアプリケーションにアクセスすると、アプリケーションはユーザーに代わってロールを引き受け、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 ユーザーガイド*」の以下のセクションを参照してください。
+ [ウェブ ID または OpenID Connect フェデレーション用のロールを作成する (コンソール)](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_create_for-idp_oidc.html)
+ [SAML 2.0 フェデレーション用のロールの作成 (コンソール)](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_create_for-idp_saml.html)

## ステップ 2: 認証コードがアタッチされた URL を生成する
<a name="embedded-visuals-for-authenticated-users-step-2"></a>

次のセクションでは、Amazon Quick Sight ユーザーを認証し、アプリケーションサーバーに埋め込み可能なビジュアル URL を取得する方法について説明します。IAM または Amazon Quick Sight ID タイプのビジュアルを埋め込む場合は、Amazon Quick Sight ユーザーとビジュアルを共有します。

Amazon Quick Sight ユーザーがアプリにアクセスすると、アプリは Amazon Quick Sight ユーザーに代わって IAM ロールを引き受けます。次に、Amazon Quick Sight ユーザーが存在しない場合、そのユーザーを Amazon Quick Sight に追加します。次に、アプリケーションが一意のロールセッション ID として識別子を渡します。

説明されているステップを実行すると、ビジュアルの各ビューワーが Amazon Quick Sight で一意にプロビジョニングされます。行レベルのセキュリティやパラメータの動的デフォルトなど、ユーザーごとの設定も強制されます。

次の例では、Amazon Quick Sight ユーザーに代わって IAM 認証を実行します。このコードはアプリケーションサーバー上で実行されます。

### Java
<a name="embedded-visuals-for-authenticated-users-java"></a>

```
import com.amazonaws.auth.AWSCredentials;
import com.amazonaws.auth.BasicAWSCredentials;
import com.amazonaws.auth.AWSCredentialsProvider;
import com.amazonaws.regions.Regions;
import com.amazonaws.services.quicksight.AmazonQuickSight;
import com.amazonaws.services.quicksight.AmazonQuickSightClientBuilder;
import com.amazonaws.services.quicksight.model.DashboardVisualId;
import com.amazonaws.services.quicksight.model.GenerateEmbedUrlForRegisteredUserRequest;
import com.amazonaws.services.quicksight.model.GenerateEmbedUrlForRegisteredUserResult;
import com.amazonaws.services.quicksight.model.RegisteredUserDashboardVisualEmbeddingConfiguration;
import com.amazonaws.services.quicksight.model.RegisteredUserEmbeddingExperienceConfiguration;

import java.util.List;

/**
 * Class to call QuickSight AWS SDK to get url for Visual embedding.
 */
public class GenerateEmbedUrlForRegisteredUserTest {

    private final AmazonQuickSight quickSightClient;

    public GenerateEmbedUrlForRegisteredUserTest() {
        this.quickSightClient = AmazonQuickSightClientBuilder
            .standard()
            .withRegion(Regions.US_EAST_1.getName())
            .withCredentials(new AWSCredentialsProvider() {
                    @Override
                    public AWSCredentials getCredentials() {
                        // provide actual IAM access key and secret key here
                        return new BasicAWSCredentials("access-key", "secret-key");
                    }

                    @Override
                    public void refresh() {                        
                    }
                }
            )
            .build();
    }

    public String getEmbedUrl(
            final String accountId, // AWS Account ID
            final String dashboardId, // Dashboard ID of the dashboard to embed
            final String sheetId, // Sheet ID of the sheet to embed
            final String visualId, // Visual ID of the visual to embed
            final List<String> allowedDomains, // Runtime allowed domains for embedding
            final String userArn // Registered user arn of the user that you want to provide embedded visual. Refer to Get Embed Url section in developer portal to find out how to get user arn for a QuickSight user.
    ) throws Exception {
        final DashboardVisualId dashboardVisual = new DashboardVisualId()
            .withDashboardId(dashboardId)
            .withSheetId(sheetId)
            .withVisualId(visualId);
        final RegisteredUserDashboardVisualEmbeddingConfiguration registeredUserDashboardVisualEmbeddingConfiguration
            = new RegisteredUserDashboardVisualEmbeddingConfiguration()
                .withInitialDashboardVisualId(dashboardVisual);
        final RegisteredUserEmbeddingExperienceConfiguration registeredUserEmbeddingExperienceConfiguration
            = new RegisteredUserEmbeddingExperienceConfiguration()
                .withDashboardVisual(registeredUserDashboardVisualEmbeddingConfiguration);
        final GenerateEmbedUrlForRegisteredUserRequest generateEmbedUrlForRegisteredUserRequest
            = new GenerateEmbedUrlForRegisteredUserRequest()
                .withAwsAccountId(accountId)
                .withUserArn(userArn)
                .withExperienceConfiguration(registeredUserEmbeddingExperienceConfiguration)
                .withAllowedDomains(allowedDomains);

        final GenerateEmbedUrlForRegisteredUserResult generateEmbedUrlForRegisteredUserResult = quickSightClient.generateEmbedUrlForRegisteredUser(generateEmbedUrlForRegisteredUserRequest);

        return generateEmbedUrlForRegisteredUserResult.getEmbedUrl();
    }
}
```

### JavaScript
<a name="embedded-visuals-for-authenticated-users-js"></a>

```
global.fetch = require('node-fetch');
const AWS = require('aws-sdk');

function generateEmbedUrlForRegisteredUser(
    accountId, // Your AWS account ID
    dashboardId, // Dashboard ID to which the constructed URL points
    sheetId, // Sheet ID to which the constructed URL points
    visualId, // Visual ID to which the constructed URL points
    openIdToken, // Cognito-based token
    userArn, // registered user arn
    roleArn, // IAM user role to use for embedding
    sessionName, // Session name for the roleArn assume role
    allowedDomains, // Runtime allowed domain for embedding
    getEmbedUrlCallback, // GetEmbedUrl success callback method
    errorCallback // GetEmbedUrl error callback method
    ) {
    const stsClient = new AWS.STS();
    let stsParams = {
        RoleSessionName: sessionName,
        WebIdentityToken: openIdToken,
        RoleArn: roleArn
    }

    stsClient.assumeRoleWithWebIdentity(stsParams, function(err, data) {
        if (err) {
            console.log('Error assuming role');
            console.log(err, err.stack);
            errorCallback(err);
        } else {
            const getDashboardParams = {
                "AwsAccountId": accountId,
                "ExperienceConfiguration": {
                    "DashboardVisual": {
                        "InitialDashboardVisualId": {
                            "DashboardId": dashboardId,
                            "SheetId": sheetId,
                            "VisualId": visualId
                        }
                    }
                },
                "UserArn": userArn,
                "AllowedDomains": allowedDomains,
                "SessionLifetimeInMinutes": 600
            };

            const quicksightGetDashboard = new AWS.QuickSight({
                region: process.env.AWS_REGION,
                credentials: {
                    accessKeyId: data.Credentials.AccessKeyId,
                    secretAccessKey: data.Credentials.SecretAccessKey,
                    sessionToken: data.Credentials.SessionToken,
                    expiration: data.Credentials.Expiration
                }
            });

            quicksightGetDashboard.generateEmbedUrlForRegisteredUser(getDashboardParams, function(err, data) {
                if (err) {
                    console.log(err, err.stack);
                    errorCallback(err);
                } else {
                    const result = {
                        "statusCode": 200,
                        "headers": {
                            "Access-Control-Allow-Origin": "*", // Use your website domain to secure access to GetEmbedUrl API
                            "Access-Control-Allow-Headers": "Content-Type"
                        },
                        "body": JSON.stringify(data),
                        "isBase64Encoded": false
                    }
                    getEmbedUrlCallback(result);
                }
            });
        }
    });
}
```

### Python3
<a name="embedded-visuals-for-authenticated-users-py"></a>

```
import json
import boto3
from botocore.exceptions import ClientError

sts = boto3.client('sts')

# Function to generate embedded URL  
# accountId: AWS account ID
# dashboardId: Dashboard ID to embed
# sheetId: SHEET ID to embed from the dashboard 
# visualId: Id for the Visual you want to embedded from the dashboard sheet. 
# userArn: arn of registered user
# allowedDomains: Runtime allowed domain for embedding
# roleArn: IAM user role to use for embedding
# sessionName: session name for the roleArn assume role
def getEmbeddingURL(accountId, dashboardId, sheetId, visualId, userArn, allowedDomains, roleArn, sessionName):
    try:
        assumedRole = sts.assume_role(
            RoleArn = roleArn,
            RoleSessionName = sessionName,
        )
    except ClientError as e:
        return "Error assuming role: " + str(e)
    else: 
        assumedRoleSession = boto3.Session(
            aws_access_key_id = assumedRole['Credentials']['AccessKeyId'],
            aws_secret_access_key = assumedRole['Credentials']['SecretAccessKey'],
            aws_session_token = assumedRole['Credentials']['SessionToken'],
        )
        try:
            quicksightClient = assumedRoleSession.client('quicksight', region_name='us-west-2')
            response = quicksightClient.generate_embed_url_for_registered_user(
                AwsAccountId=accountId,
                ExperienceConfiguration = {
                    'DashboardVisual': {
                        'InitialDashboardVisualId': {
                            'DashboardId': dashboardId,
                            'SheetId': sheetId,
                            'VisualId': visualId
                        }
                    },
                },
                UserArn = userArn,
                AllowedDomains = allowedDomains,
                SessionLifetimeInMinutes = 600
            )
            
            return {
                'statusCode': 200,
                'headers': {"Access-Control-Allow-Origin": "*", "Access-Control-Allow-Headers": "Content-Type"},
                'body': json.dumps(response),
                'isBase64Encoded':  bool('false')
            }
        except ClientError as e:
            return "Error generating embedding url: " + str(e)
```

### Node.js
<a name="embedded-visuals-for-authenticated-users-node"></a>

次の例は、埋め込みダッシュボードの URL を生成するためにアプリケーションサーバーで使用できる JavaScript (Node.js) を示しています。ダッシュボードを表示するには、ウェブサイトまたはアプリでこの URL を使用します。

**Example**  

```
const AWS = require('aws-sdk');
const https = require('https');

var quicksightClient = new AWS.Service({
    apiConfig: require('./quicksight-2018-04-01.min.json'),
    region: 'us-east-1',
});

quicksightClient.generateEmbedUrlForRegisteredUser({
    'AwsAccountId': '111122223333',
    'ExperienceConfiguration': { 
        'DashboardVisual': {
            'InitialDashboardVisualId': {
                'DashboardId': 'dashboard_id',
                'SheetId': 'sheet_id',
                'VisualId': 'visual_id'
            }
        }
    },
    'UserArn': 'REGISTERED_USER_ARN',
    'AllowedDomains': allowedDomains,
    'SessionLifetimeInMinutes': 100
}, function(err, data) {
    console.log('Errors: ');
    console.log(err);
    console.log('Response: ');
    console.log(data);
});
```

**Example**  

```
//The URL returned is over 900 characters. For this example, we've shortened the string for
//readability and added ellipsis to indicate that it's incomplete.
    {
        "Status": "200",
        "EmbedUrl": "https://quicksightdomain/embed/12345/dashboards/67890/sheets/12345/visuals/67890...",
        "RequestId": "7bee030e-f191-45c4-97fe-d9faf0e03713"
    }
```

### .NET/C\$1
<a name="embedded-visuals-for-authenticated-users-cs"></a>

次の例は、埋め込みダッシュボードの 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
            {
                DashboardVisualId dashboardVisual = new DashboardVisualId
                {
                    DashboardId = "dashboard_id",
                    SheetId = "sheet_id",
                    VisualId = "visual_id"
                };

                RegisteredUserDashboardVisualEmbeddingConfiguration registeredUserDashboardVisualEmbeddingConfiguration
                    = new RegisteredUserDashboardVisualEmbeddingConfiguration
                    {
                        InitialDashboardVisualId = dashboardVisual                        
                    };               
                    
                RegisteredUserEmbeddingExperienceConfiguration registeredUserEmbeddingExperienceConfiguration
                    = new RegisteredUserEmbeddingExperienceConfiguration
                    {
                        DashboardVisual = registeredUserDashboardVisualEmbeddingConfiguration
                    };
                    
                Console.WriteLine(
                    quicksightClient.GenerateEmbedUrlForRegisteredUserAsync(new GenerateEmbedUrlForRegisteredUserRequest
                    {
                        AwsAccountId = "111122223333",
                        ExperienceConfiguration = registeredUserEmbeddingExperienceConfiguration,
                        UserArn = "REGISTERED_USER_ARN",
                        AllowedDomains = allowedDomains,
                        SessionLifetimeInMinutes = 100
                    }).Result.EmbedUrl
                );
            } catch (Exception ex) {
                Console.WriteLine(ex.Message);
            }
        }
    }
}
```

### AWS CLI
<a name="embedded-visuals-for-authenticated-users-cli"></a>

ロールを引き受けるには、次のいずれかの AWS Security Token Service (AWS STS) API オペレーションを選択します。
+ [AssumeRole](https://docs.aws.amazon.com/STS/latest/APIReference/API_AssumeRole.html) – ロールを引き受けるために IAM ID を使用している場合は、このオペレーションを使用します。
+ [AssumeRoleWithWebIdentity](https://docs.aws.amazon.com/STS/latest/APIReference/API_AssumeRoleWithWebIdentity.html) – ユーザーの認証にウェブ ID プロバイダーを使用している場合は、このオペレーションを使用します。
+ [AssumeRoleWithSaml](https://docs.aws.amazon.com/STS/latest/APIReference/API_AssumeRoleWithSAML.html) – ユーザーの認証に SAML を使用している場合は、このオペレーションを使用します。

次の例は、IAM ロールを設定するための CLI コマンドを示しています。ロールは、`quicksight:GenerateEmbedUrlForRegisteredUser` を有効にする許可を取得する必要があります。ユーザーがダッシュボードを初めて開いたときに、ジャストインタイム方式でユーザーを追加する場合は、ロールには `quicksight:RegisterUser` を有効にするアクセス許可も必要です。

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

`assume-role` オペレーションは、アクセスキー、シークレットキー、およびセッショントークンの 3 つの出力パラメータを返します。

**注記**  
`AssumeRole` オペレーションを呼び出すときに `ExpiredToken` エラーが発生した場合は、以前の `SESSION TOKEN` がまだ環境変数に残っている可能性があります。以下の変数を設定することで、これをオフにします。  
*AWS\$1ACCESS\$1KEY\$1ID* 
*AWS\$1SECRET\$1ACCESS\$1KEY* 
*AWS\$1SESSION\$1TOKEN* 

次の例は、CLI でこれら 3 つのパラメータを設定する方法を示しています。Microsoft Windows マシンを使用している場合は、`export` の代わりに `set` を使用します。

```
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_visual_role/john.doe@example.com` に設定されます。ロールセッション ID は、`role-arn` の役割名と `role-session-name` 値で構成されています。各ユーザーに一意のロールセッション ID を使用すると、各ユーザーに適切なアクセス許可が設定されます。また、ユーザーアクセスのスロットリングが防止されます。*スロットリング*は、同じユーザーが複数の場所から Amazon Quick Sight にアクセスできないようにするセキュリティ機能です。

ロールセッション ID も Amazon Quick Sight のユーザー名になります。このパターンを使用して、Amazon Quick Sight でユーザーを事前にプロビジョニングしたり、ダッシュボードに初めてアクセスしたときにプロビジョニングしたりできます。

次の例は、ユーザーをプロビジョニングするために使用できる CLI コマンドを示しています。[RegisterUser](https://docs.aws.amazon.com/quicksight/latest/APIReference/API_RegisterUser.html)、[DescribeUser](https://docs.aws.amazon.com/quicksight/latest/APIReference/API_DescribeUser.html)、およびその他の Amazon Quick Sight API オペレーションの詳細については、[「Amazon Quick Sight API リファレンス](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_visual_role" \
    --user-role READER \
    --user-name jhnd \
    --session-name "john.doe@example.com" \
    --email john.doe@example.com \
    --region us-east-1 \
    --custom-permissions-name TeamA1
```

ユーザーが 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_visual_role/john.doe@example.com"
```

これで、Amazon Quick Sight のユーザーでもあり、ビジュアルにアクセスできるアプリのユーザーができました。

最後に、ビジュアルの署名付き 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 \
    --session-lifetime-in-minutes 600 \
    --user-arn arn:aws:quicksight:us-east-1:111122223333:user/default/embedding_quicksight_visual_role/embeddingsession \
    --allowed-domains '["domain1","domain2"]' \
    --experience-configuration 'DashboardVisual={InitialDashboardVisualId={DashboardId=dashboard_id,SheetId=sheet_id,VisualId=visual_id}}'
```

このオペレーションの使用に関する詳細については、[https://docs.aws.amazon.com/quicksight/latest/APIReference/API_GenerateEmbedUrlForRegisteredUser.html](https://docs.aws.amazon.com/quicksight/latest/APIReference/API_GenerateEmbedUrlForRegisteredUser.html) を参照してください。これと他の API オペレーションは、独自のコードで使用できます。

## ステップ 3: ヴィジュアルの URL を埋め込む
<a name="embedded-visuals-for-authenticated-users-step-3"></a>

次のセクションでは、[Amazon Quick Sight Embedding SDK](https://www.npmjs.com/package/amazon-quicksight-embedding-sdk) (JavaScript) を使用して、ステップ 3 のビジュアル URL をウェブサイトまたはアプリケーションページに埋め込む方法について説明します。この SDK を使用することで、以下を実行できます。
+ HTML ページにビジュアルを配置します。
+ このビジュアルにパラメータを渡します。
+ アプリケーションに合わせてカスタマイズされたメッセージでエラー状態を処理します。

`GenerateEmbedUrlForRegisteredUser` API オペレーションを呼び出して URL を生成し、アプリケーションに埋め込みます。この URL は 5 分間有効で、得られたセッションは最大 10 時間有効です。API オペレーションは、シングルサインオンセッションを有効にする `auth_code` の URL を提供します。

以下に、`generate-embed-url-for-registered-user` からのレスポンスの例を示します。この例`quicksightdomain`の は、Amazon Quick Sight アカウントへのアクセスに使用する 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://quicksightdomain/embed/12345/dashboards/67890/sheets/12345/visuals/67890...",
        "RequestId": "7bee030e-f191-45c4-97fe-d9faf0e03713"
    }
```

[Amazon Quick Sight Embedding SDK を使用する](https://www.npmjs.com/package/amazon-quicksight-embedding-sdk)か、この URL を iframe に追加して、このビジュアルをウェブページに埋め込みます。固定の高さと幅の数値 (ピクセル単位) を設定した場合、Amazon Quick Sight はそれらを使用し、ウィンドウのサイズ変更に伴ってビジュアルを変更しません。相対的な高さと幅の割合を設定すると、Amazon Quick Sight はウィンドウサイズの変化に応じて変化するレスポンシブレイアウトを提供します。Amazon Quick Sight Embedding SDK を使用すると、ビジュアル内のパラメータを制御し、ページロードの完了とエラーの観点からコールバックを受信することもできます。

埋め込みビジュアルとダッシュボードをホストするドメインは、 Quick サブスクリプション用に承認されたドメインのリストである*許可*リストに含まれている必要があります。この要件は、未承認のドメインが埋め込みのビジュアルおよびダッシュボードをホストしないようにすることで、データを保護します。埋め込みビジュアルとダッシュボードのドメインの追加の詳細については、[「Amazon Quick Sight API を使用して実行時にドメインを一覧表示するの](https://docs.aws.amazon.com/quicksight/latest/user/embedding-run-time.html)を許可する」を参照してください。

次の例は生成された URL の使用方法を示しています。このコードはアプリケーションサーバー上で生成されます。

### SDK 2.0
<a name="embedded-visuals-for-authenticated-users-sdkv2"></a>

```
<!DOCTYPE html>
<html>

    <head>
        <title>Visual Embedding Example</title>
        <script src="https://unpkg.com/amazon-quicksight-embedding-sdk@2.0.0/dist/quicksight-embedding-js-sdk.min.js"></script>
        <script type="text/javascript">
            const embedVisual = async() => {    
                const {
                    createEmbeddingContext,
                } = QuickSightEmbedding;

                const embeddingContext = await createEmbeddingContext({
                    onChange: (changeEvent, metadata) => {
                        console.log('Context received a change', changeEvent, metadata);
                    },
                });

                const frameOptions = {
                    url: "<YOUR_EMBED_URL>", // replace this value with the url generated via embedding API
                    container: '#experience-container',
                    height: "700px",
                    width: "1000px",
                    onChange: (changeEvent, metadata) => {
                        switch (changeEvent.eventName) {
                            case 'FRAME_MOUNTED': {
                                console.log("Do something when the experience frame is mounted.");
                                break;
                            }
                            case 'FRAME_LOADED': {
                                console.log("Do something when the experience frame is loaded.");
                                break;
                            }
                        }
                    },
                };

                const contentOptions = {
                    parameters: [
                        {
                            Name: 'country',
                            Values: ['United States'],
                        },
                        {
                            Name: 'states',
                            Values: [
                                'California',
                                'Washington'
                            ]
                        }
                    ],
                    locale: "en-US",
                    onMessage: async (messageEvent, experienceMetadata) => {
                        switch (messageEvent.eventName) {
                            case 'CONTENT_LOADED': {
                                console.log("All visuals are loaded. The title of the document:", messageEvent.message.title);
                                break;
                            }
                            case 'ERROR_OCCURRED': {
                                console.log("Error occurred while rendering the experience. Error code:", messageEvent.message.errorCode);
                                break;
                            }
                            case 'PARAMETERS_CHANGED': {
                                console.log("Parameters changed. Changed parameters:", messageEvent.message.changedParameters);
                                break;
                            }
                            case 'SIZE_CHANGED': {
                                console.log("Size changed. New dimensions:", messageEvent.message);
                                break;
                            }
                        }
                    },
                };
                const embeddedVisualExperience = await embeddingContext.embedVisual(frameOptions, contentOptions);

                const selectCountryElement = document.getElementById('country');
                selectCountryElement.addEventListener('change', (event) => {
                    embeddedVisualExperience.setParameters([
                        {
                            Name: 'country',
                            Values: event.target.value
                        }
                    ]);
                });
            };
        </script>
    </head>

    <body onload="embedVisual()">
        <span>
            <label for="country">Country</label>
            <select id="country" name="country">
                <option value="United States">United States</option>
                <option value="Mexico">Mexico</option>
                <option value="Canada">Canada</option>
            </select>
        </span>
        <div id="experience-container"></div>
    </body>

</html>
```

### SDK 1.0
<a name="embedded-visuals-for-authenticated-users-sdkv1"></a>

```
<!DOCTYPE html>
<html>

    <head>
        <title>Visual Embedding Example</title>
        <!-- You can download the latest QuickSight embedding SDK version from https://www.npmjs.com/package/amazon-quicksight-embedding-sdk -->
        <!-- Or you can do "npm install amazon-quicksight-embedding-sdk", if you use npm for javascript dependencies -->
        <script src="./quicksight-embedding-js-sdk.min.js"></script>
        <script type="text/javascript">
            let embeddedVisualExperience;
            function onVisualLoad(payload) {
                console.log("Do something when the visual is fully loaded.");
            }

            function onError(payload) {
                console.log("Do something when the visual fails loading");
            }

            function embedVisual() {
                const containerDiv = document.getElementById("embeddingContainer");
                const options = {
                    url: "<YOUR_EMBED_URL>", // replace this value with the url generated via embedding API
                    container: containerDiv,
                    parameters: {
                        country: "United States"
                    },
                    height: "700px",
                    width: "1000px",
                    locale: "en-US"
                };
                embeddedVisualExperience = QuickSightEmbedding.embedVisual(options);
                embeddedVisualExperience.on("error", onError);
                embeddedVisualExperience.on("load", onVisualLoad);
            }

            function onCountryChange(obj) {
                embeddedVisualExperience.setParameters({country: obj.value});
            }
        </script>
    </head>

    <body onload="embedVisual()">
        <span>
            <label for="country">Country</label>
            <select id="country" name="country" onchange="onCountryChange(this)">
                <option value="United States">United States</option>
                <option value="Mexico">Mexico</option>
                <option value="Canada">Canada</option>
            </select>
        </span>
        <div id="embeddingContainer"></div>
    </body>

</html>
```

この例では、Amazon Quick Sight Embedding SDK を使用して、JavaScript を使用してウェブサイトに埋め込みビジュアルをロードします。コピーを取得するには、次のいずれかを実行します。
+ GitHub [から Amazon Quick Sight Embedding SDK](https://github.com/awslabs/amazon-quicksight-embedding-sdk#step-3-create-the-quicksight-session-object) をダウンロードします。このリポジトリは、Amazon Quick Sight 開発者のグループによって管理されます。
+ [https://www.npmjs.com/package/amazon-quicksight-embedding-sdk](https://www.npmjs.com/package/amazon-quicksight-embedding-sdk) から、最新の埋め込み SDK バージョンをダウンロードします。
+ JavaScript の依存関係の `npm` を使用する場合、次のコマンドを実行してダウンロードおよびインストールします。

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

# 匿名 (未登録) ユーザー向けの Amazon Quick Sight ビジュアルの埋め込み
<a name="embedded-analytics-visuals-for-everyone"></a>


|  | 
| --- |
|  適用対象: Enterprise Edition  | 


|  | 
| --- |
|    対象者:  Amazon Quick デベロッパー  | 

以下のセクションでは、匿名 (未登録) ユーザー向けに埋め込み Amazon Quick Sight ビジュアルを設定する方法について詳しく説明します。

**Topics**
+ [

## ステップ 1: 許可をセットアップする
](#embedded-analytics-visuals-with-anonymous-users-step-1)
+ [

## ステップ 2: 認証コードがアタッチされた URL を生成する
](#embedded-analytics-visuals-with-anonymous-users-step-2)
+ [

## ステップ 3: ヴィジュアルの URL を埋め込む
](#embedded-analytics-visuals-with-anonymous-users-step-3)

## ステップ 1: 許可をセットアップする
<a name="embedded-analytics-visuals-with-anonymous-users-step-1"></a>


|  | 
| --- |
|  適用対象: Enterprise Edition  | 


|  | 
| --- |
|    対象者:  Amazon Quick デベロッパー  | 

次のセクションでは、バックエンドアプリケーションまたはウェブサーバーのアクセス許可を設定する方法について説明します。このタスクには IAM への管理者アクセス権が必要です。

ビジュアルにアクセスする各ユーザーは、Amazon Quick Sight にビジュアルへのアクセスとアクセス許可を付与するロールを引き受けます。これを可能にするには、 で IAM ロールを作成します AWS アカウント。IAM ポリシーをロールに関連付けて、それを引き受けるすべてのユーザーにアクセス許可を付与します。

IAM ポリシーで条件を作成し、デベロッパーが `GenerateEmbedUrlForAnonymousUser` API オペレーションの `AllowedDomains` パラメータにリストできるドメインを制限できます。`AllowedDomains` パラメータはオプションのパラメータです。これにより、**Amazon Quick Sight の管理**メニューで設定された静的ドメインを上書きするオプションが開発者として付与されます。代わりに、生成された URL へのアクセスが可能な、ドメインもしくはサブドメインを、最大 3 つまでリストアップすることもできます。この URL は、作成した Web サイトに埋め込むことが可能です。パラメータにリストされているドメインのみが、埋め込みダッシュボードにアクセスできます。この状態にしていない場合、インターネット上の任意のドメインを `AllowedDomains` パラメータにリストできてしまいます。

デベロッパーがこのパラメータで使用できるドメインを制限するには、`AllowedEmbeddingDomains` 条件を IAM ポリシーに追加します。`AllowedDomains` パラメータの詳細については、*Amazon Quick Sight API リファレンス*の[GenerateEmbedUrlForAnonymousUser](https://docs.aws.amazon.com//quicksight/latest/APIReference/API_GenerateEmbedUrlForAnonymousUser.html)」を参照してください。

**IAM 条件演算子のセキュリティのベストプラクティス**  
正しく設定されていない IAM 条件演算子は、URL のバリエーションを通じて埋め込み Quick リソースへの不正アクセスを許可できます。IAM ポリシーで `quicksight:AllowedEmbeddingDomains` 条件キーを使用する場合は、特定のドメインを許可するか、特に許可されていないすべてのドメインを拒否する条件演算子を使用します。IAM 条件演算子の詳細については、IAM [ユーザーガイドの「IAM JSON ポリシー要素: 条件演算子](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_elements_condition_operators.html)」を参照してください。  
多くの異なる URL バリエーションが同じリソースを指す場合があります。たとえば、次の URLsはすべて同じコンテンツに解決されます。  
`https://example.com`
`https://example.com/`
`https://Example.com`
ポリシーでこれらの URL バリエーションを考慮しない演算子を使用している場合、攻撃者は同等の URL バリエーションを提供することで制限を回避できます。  
IAM ポリシーが適切な条件演算子を使用してバイパスの脆弱性を防ぎ、目的のドメインのみが埋め込みリソースにアクセスできることを確認する必要があります。

作成したロールへのアクセスを許可するには、アプリケーションの IAM ID に関連付けられた信頼ポリシーが必要です。つまり、ユーザーがアプリケーションにアクセスすると、アプリケーションはユーザーに代わってビジュアルを開くためのロールを引き受けます。次の例は、サンプルの信頼ポリシーを示しています。

------
#### [ 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.aws.amazon.com/IAM/latest/UserGuide/id_credentials_temp.html)」を参照してください。

## ステップ 2: 認証コードがアタッチされた URL を生成する
<a name="embedded-analytics-visuals-with-anonymous-users-step-2"></a>


|  | 
| --- |
|  適用対象: Enterprise Edition  | 


|  | 
| --- |
|    対象者:  Amazon Quick デベロッパー  | 

以下のセクションで、匿名の訪問者に代わって認証を行う方法と、アプリケーションサーバーから埋め込みビジュアルの URL を取得する方法について説明します。

ユーザーがアプリケーションにアクセスすると、アプリケーションはユーザーに代わって IAM ロールを引き受けます。次に、そのユーザーがまだ存在しない場合、Amazon Quick Sight にユーザーを追加します。次に、一意のロールセッション ID として識別子を渡します。

次の例では、ユーザーに代わって IAM 認証を実行します。一意のロールセッション ID として識別子を渡します。このコードはアプリケーションサーバー上で実行されます。

### Java
<a name="embedded-analytics-visuals-with-anonymous-users-java"></a>

```
import com.amazonaws.auth.AWSCredentials;
import com.amazonaws.auth.BasicAWSCredentials;
import com.amazonaws.auth.AWSCredentialsProvider;
import com.amazonaws.regions.Regions;
import com.amazonaws.services.quicksight.AmazonQuickSight;
import com.amazonaws.services.quicksight.AmazonQuickSightClientBuilder;
import com.amazonaws.services.quicksight.model.AnonymousUserDashboardVisualEmbeddingConfiguration;
import com.amazonaws.services.quicksight.model.AnonymousUserEmbeddingExperienceConfiguration;
import com.amazonaws.services.quicksight.model.DashboardVisualId;
import com.amazonaws.services.quicksight.model.GenerateEmbedUrlForAnonymousUserRequest;
import com.amazonaws.services.quicksight.model.GenerateEmbedUrlForAnonymousUserResult;
import com.amazonaws.services.quicksight.model.SessionTag;

import java.util.List;

/**
 * Class to call QuickSight AWS SDK to get url for Visual embedding.
 */
public class GenerateEmbedUrlForAnonymousUserTest {
    private final AmazonQuickSight quickSightClient;

    public GenerateEmbedUrlForAnonymousUserTest() {
        this.quickSightClient = AmazonQuickSightClientBuilder
            .standard()
            .withRegion(Regions.US_EAST_1.getName())
            .withCredentials(new AWSCredentialsProvider() {
                    @Override
                    public AWSCredentials getCredentials() {
                        // provide actual IAM access key and secret key here
                        return new BasicAWSCredentials("access-key", "secret-key");
                    }

                    @Override
                    public void refresh() {                           
                    }
                }
            )
            .build();
    }

    public String getEmbedUrl(
            final String accountId, // AWS Account ID
            final String namespace, // Anonymous embedding required specifying a valid namespace for which you want the enbedding URL
            final List<String> authorizedResourceArns, // Dashboard arn list of dashboard visuals to embed
            final String dashboardId, // Dashboard ID of the dashboard to embed
            final String sheetId, // Sheet ID of the sheet to embed
            final String visualId, // Visual ID of the visual to embed
            final List<String> allowedDomains, // Runtime allowed domains for embedding
            final List<SessionTag> sessionTags // Session tags used for row-level security
    ) throws Exception {
        final DashboardVisualId dashboardVisual = new DashboardVisualId()
            .withDashboardId(dashboardId)
            .withSheetId(sheetId)
            .withVisualId(visualId);
        final AnonymousUserDashboardVisualEmbeddingConfiguration anonymousUserDashboardVisualEmbeddingConfiguration
            = new AnonymousUserDashboardVisualEmbeddingConfiguration()
                .withInitialDashboardVisualId(dashboardVisual);
        final AnonymousUserEmbeddingExperienceConfiguration anonymousUserEmbeddingExperienceConfiguration
            = new AnonymousUserEmbeddingExperienceConfiguration()
                .withDashboardVisual(anonymousUserDashboardVisualEmbeddingConfiguration);
        final GenerateEmbedUrlForAnonymousUserRequest generateEmbedUrlForAnonymousUserRequest
            = new GenerateEmbedUrlForAnonymousUserRequest()
                .withAwsAccountId(accountId)
                .withNamespace(namespace)
                // authorizedResourceArns should contain ARN of dashboard used below in ExperienceConfiguration
                .withAuthorizedResourceArns(authorizedResourceArns)
                .withExperienceConfiguration(anonymousUserEmbeddingExperienceConfiguration)
                .withAllowedDomains(allowedDomains)
                .withSessionTags(sessionTags)
                .withSessionLifetimeInMinutes(600L);

        final GenerateEmbedUrlForAnonymousUserResult generateEmbedUrlForAnonymousUserResult
            = quickSightClient.generateEmbedUrlForAnonymousUser(generateEmbedUrlForAnonymousUserRequest);

        return generateEmbedUrlForAnonymousUserResult.getEmbedUrl();
    }
}
```

### JavaScript
<a name="embedded-analytics-visuals-with-anonymous-users-js"></a>

```
global.fetch = require('node-fetch');
const AWS = require('aws-sdk');

function generateEmbedUrlForAnonymousUser(
    accountId, // Your AWS account ID
    dashboardId, // Dashboard ID to which the constructed url points
    sheetId, // Sheet ID to which the constructed url points
    visualId, // Visual ID to which the constructed url points
    quicksightNamespace, // valid namespace where you want to do embedding
    authorizedResourceArns, // dashboard arn list of dashboard visuals to embed
    allowedDomains, // runtime allowed domains for embedding
    sessionTags, // session tags used for row-level security
    generateEmbedUrlForAnonymousUserCallback, // success callback method
    errorCallback // error callback method
    ) {
    const experienceConfiguration = {
        "DashboardVisual": {
            "InitialDashboardVisualId": {
                "DashboardId": dashboardId,
                "SheetId": sheetId,
                "VisualId": visualId
            }
        }
    };
    
    const generateEmbedUrlForAnonymousUserParams = {
        "AwsAccountId": accountId,
        "Namespace": quicksightNamespace,
        // authorizedResourceArns should contain ARN of dashboard used below in ExperienceConfiguration
        "AuthorizedResourceArns": authorizedResourceArns,
        "AllowedDomains": allowedDomains,
        "ExperienceConfiguration": experienceConfiguration,
        "SessionTags": sessionTags,
        "SessionLifetimeInMinutes": 600
    };

    const quicksightClient = new AWS.QuickSight({
        region: process.env.AWS_REGION,
        credentials: {
            accessKeyId: AccessKeyId,
            secretAccessKey: SecretAccessKey,
            sessionToken: SessionToken,
            expiration: Expiration
        }
    });

    quicksightClient.generateEmbedUrlForAnonymousUser(generateEmbedUrlForAnonymousUserParams, function(err, data) {
        if (err) {
            console.log(err, err.stack);
            errorCallback(err);
        } else {
            const result = {
                "statusCode": 200,
                "headers": {
                    "Access-Control-Allow-Origin": "*", // USE YOUR WEBSITE DOMAIN TO SECURE ACCESS TO THIS API
                    "Access-Control-Allow-Headers": "Content-Type"
                },
                "body": JSON.stringify(data),
                "isBase64Encoded": false
            }
            generateEmbedUrlForAnonymousUserCallback(result);
        }
    });
}
```

### Python3
<a name="embedded-analytics-visuals-with-anonymous-users-py"></a>

```
import json
import boto3
from botocore.exceptions import ClientError
import time

# Create QuickSight and STS clients
quicksightClient = boto3.client('quicksight',region_name='us-west-2')
sts = boto3.client('sts')

# Function to generate embedded URL for anonymous user
# accountId: YOUR AWS ACCOUNT ID
# quicksightNamespace: VALID NAMESPACE WHERE YOU WANT TO DO NOAUTH EMBEDDING
# authorizedResourceArns: DASHBOARD ARN LIST TO EMBED
# allowedDomains: RUNTIME ALLOWED DOMAINS FOR EMBEDDING
# experienceConfiguration: DASHBOARD ID, SHEET ID and VISUAL ID TO WHICH THE CONSTRUCTED URL POINTS
# Example experienceConfig -> 'DashboardVisual': {
#     'InitialDashboardVisualId': {
#         'DashboardId': 'dashboardId',
#         'SheetId': 'sheetId',
#         'VisualId': 'visualId'
#     }
# },
# sessionTags: SESSION TAGS USED FOR ROW-LEVEL SECURITY
def generateEmbedUrlForAnonymousUser(accountId, quicksightNamespace, authorizedResourceArns, allowedDomains, experienceConfiguration, sessionTags):
    try:
        response = quicksightClient.generate_embed_url_for_anonymous_user(
            AwsAccountId = accountId,
            Namespace = quicksightNamespace,
            AuthorizedResourceArns = authorizedResourceArns,
            AllowedDomains = allowedDomains,
            ExperienceConfiguration = experienceConfiguration,
            SessionTags = sessionTags,
            SessionLifetimeInMinutes = 600
        )
            
        return {
            'statusCode': 200,
            'headers': {"Access-Control-Allow-Origin": "*", "Access-Control-Allow-Headers": "Content-Type"},
            'body': json.dumps(response),
            'isBase64Encoded':  bool('false')
        }
    except ClientError as e:
        print(e)
        return "Error generating embeddedURL: " + str(e)
```

### Node.js
<a name="embedded-analytics-visuals-with-anonymous-users-node"></a>

次の例は、埋め込みダッシュボードの URL を生成するためにアプリケーションサーバーで使用できる JavaScript (Node.js) を示しています。ダッシュボードを表示するには、ウェブサイトまたはアプリでこの URL を使用します。

**Example**  

```
const AWS = require('aws-sdk');
const https = require('https');

var quicksightClient = new AWS.Service({
    apiConfig: require('./quicksight-2018-04-01.min.json'),
    region: 'us-east-1',
});

quicksightClient.generateEmbedUrlForAnonymousUser({
    'AwsAccountId': '111122223333',
    'Namespace' : 'default',
    // authorizedResourceArns should contain ARN of dashboard used below in ExperienceConfiguration
    'AuthorizedResourceArns': authorizedResourceArns,
    'ExperienceConfiguration': { 
        'DashboardVisual': {
            'InitialDashboardVisualId': {
                'DashboardId': 'dashboard_id',
                'SheetId': 'sheet_id',
                'VisualId': 'visual_id'
            }
        }
    },
    'AllowedDomains': allowedDomains,    
    'SessionTags': sessionTags,
    'SessionLifetimeInMinutes': 600

}, function(err, data) {
    console.log('Errors: ');
    console.log(err);
    console.log('Response: ');
    console.log(data);
});
```

**Example**  

```
//The URL returned is over 900 characters. For this example, we've shortened the string for
//readability and added ellipsis to indicate that it's incomplete.
    {
        "Status": "200",
        "EmbedUrl": "https://quicksightdomain/embed/12345/dashboards/67890/sheets/12345/visuals/67890...",
        "RequestId": "7bee030e-f191-45c4-97fe-d9faf0e03713"
    }
```

### .NET/C\$1
<a name="embedded-analytics-visuals-with-anonymous-users-cs"></a>

次の例は、埋め込みダッシュボードの URL を生成するためにアプリケーションサーバーで使用できる .NET/C\$1 コードを示しています。ダッシュボードを表示するには、ウェブサイトまたはアプリでこの URL を使用します。

**Example**  

```
using System;
using Amazon.QuickSight;
using Amazon.QuickSight.Model;

namespace GenerateDashboardEmbedUrlForAnonymousUser
{
    class Program
    {
        static void Main(string[] args)
        {
            var quicksightClient = new AmazonQuickSightClient(
                AccessKey,
                SecretAccessKey,
                SessionToken,
                Amazon.RegionEndpoint.USEast1);
            try
            {
                DashboardVisualId dashboardVisual = new DashboardVisualId
                {
                    DashboardId = "dashboard_id",
                    SheetId = "sheet_id",
                    VisualId = "visual_id"
                };

                AnonymousUserDashboardVisualEmbeddingConfiguration anonymousUserDashboardVisualEmbeddingConfiguration
                    = new AnonymousUserDashboardVisualEmbeddingConfiguration
                    {
                        InitialDashboardVisualId = dashboardVisual                        
                    };               
                    
                AnonymousUserEmbeddingExperienceConfiguration anonymousUserEmbeddingExperienceConfiguration
                    = new AnonymousUserEmbeddingExperienceConfiguration
                    {
                        DashboardVisual = anonymousUserDashboardVisualEmbeddingConfiguration
                    }; 
                    
                Console.WriteLine(
                    quicksightClient.GenerateEmbedUrlForAnonymousUserAsync(new GenerateEmbedUrlForAnonymousUserRequest
                    {
                        AwsAccountId = "111222333444",
                        Namespace = default,
                        // authorizedResourceArns should contain ARN of dashboard used below in ExperienceConfiguration
                        AuthorizedResourceArns = { "dashboard_id" },
                        ExperienceConfiguration = anonymousUserEmbeddingExperienceConfiguration,
                        SessionTags = sessionTags,
                        SessionLifetimeInMinutes = 600,
                    }).Result.EmbedUrl
                );
            } catch (Exception ex) {
                Console.WriteLine(ex.Message);
            }
        }
    }
}
```

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

ロールを引き受けるには、次のいずれかの AWS Security Token Service (AWS STS) API オペレーションを選択します。
+ [AssumeRole](https://docs.aws.amazon.com/STS/latest/APIReference/API_AssumeRole.html) – ロールを引き受けるために IAM ID を使用している場合は、このオペレーションを使用します。
+ [AssumeRoleWithWebIdentity](https://docs.aws.amazon.com/STS/latest/APIReference/API_AssumeRoleWithWebIdentity.html) – ユーザーの認証にウェブ ID プロバイダーを使用している場合は、このオペレーションを使用します。
+ [AssumeRoleWithSaml](https://docs.aws.amazon.com/STS/latest/APIReference/API_AssumeRoleWithSAML.html) – ユーザーの認証に Security Assertion Markup Language (SAML) を使用している場合は、このオペレーションを使用します。

次の例は、IAM ロールを設定するための CLI コマンドを示しています。ロールは、`quicksight:GenerateEmbedUrlForAnonymousUser` を有効にする許可を取得する必要があります。

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

`assume-role` オペレーションは、アクセスキー、シークレットキー、およびセッショントークンの 3 つの出力パラメータを返します。

**注記**  
`AssumeRole` オペレーションを呼び出すときに `ExpiredToken` エラーが発生した場合は、以前の `SESSION TOKEN` がまだ環境変数に残っている可能性があります。以下の変数を設定することで、これをオフにします。  
*AWS\$1ACCESS\$1KEY\$1ID* 
*AWS\$1SECRET\$1ACCESS\$1KEY* 
*AWS\$1SESSION\$1TOKEN* 

次の例は、CLI でこれら 3 つのパラメータを設定する方法を示しています。Microsoft Windows マシンを使用している場合は、`export` の代わりに `set` を使用します。

```
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_visual_role/QuickSightEmbeddingAnonymousPolicy` に設定されます。ロールセッション ID は、`role-arn` の役割名と `role-session-name` 値で構成されています。各ユーザーに一意のロールセッション ID を使用すると、各訪問ユーザーに適切なアクセス許可が設定されます。また、各セッションを別個に保ちます。ロードバランシングなどのウェブサーバーの配列を使用していて、セッションが別のサーバーに再接続されると、新しいセッションが開始されます。

ビジュアルの署名付き URL を取得するには、アプリケーションサーバーから `generate-embed-url-for-anynymous-user` を呼び出します。これは埋め込み可能なヴィジュアルの URL を返します。次の例で、ウェブポータルまたはアプリケーションに匿名で訪問するユーザーのサーバー側呼び出しを使用して、埋め込みビジュアルの 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.aws.amazon.com/quicksight/latest/APIReference/API_GenerateEmbedUrlForAnonymousUser.html](https://docs.aws.amazon.com/quicksight/latest/APIReference/API_GenerateEmbedUrlForAnonymousUser.html) を参照してください。これと他の API オペレーションは、独自のコードで使用できます。

## ステップ 3: ヴィジュアルの URL を埋め込む
<a name="embedded-analytics-visuals-with-anonymous-users-step-3"></a>


|  | 
| --- |
|  適用対象: Enterprise Edition  | 


|  | 
| --- |
|    対象者:  Amazon Quick デベロッパー  | 

次のセクションでは、[Amazon Quick Sight Embedding SDK](https://www.npmjs.com/package/amazon-quicksight-embedding-sdk) (JavaScript) を使用して、ステップ 2 のビジュアル URL をウェブサイトまたはアプリケーションページに埋め込む方法について説明します。この SDK を使用することで、以下を実行できます。
+ HTML ページにビジュアルを配置します。
+ このビジュアルにパラメータを渡します。
+ アプリケーションに合わせてカスタマイズされたメッセージでエラー状態を処理します。

`GenerateEmbedUrlForAnonymousUser` API オペレーションを呼び出して URL を生成し、アプリケーションに埋め込みます。この URL は 5 分間有効で、得られたセッションは 10 時間有効です。API オペレーションは、シングルサインオンセッションを有効にする、認可 (auth) コード付きの URL を提供します。

以下に、`generate-embed-url-for-anonymous-user` からのレスポンスの例を示します。この例`quicksightdomain`の は、Amazon Quick Sight アカウントへのアクセスに使用する 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://quicksightdomain/embed/12345/dashboards/67890/sheets/12345/visuals/67890...",
        "RequestId": "7bee030e-f191-45c4-97fe-d9faf0e03713"
    }
```

Amazon Quick Sight [Embedding SDK を使用する](https://www.npmjs.com/package/amazon-quicksight-embedding-sdk)か、この URL を iframe に追加して、このビジュアルをウェブページに埋め込みます。固定の高さと幅の数値 (ピクセル単位) を設定した場合、Amazon Quick Sight はそれらを使用し、ウィンドウのサイズ変更に伴ってビジュアルを変更しません。相対的な高さと幅の割合を設定すると、Amazon Quick Sight はウィンドウサイズの変化に応じて変化するレスポンシブレイアウトを提供します。Amazon Quick Sight Embedding SDK を使用すると、ビジュアル内のパラメータを制御し、ビジュアルロードの完了とエラーの観点からコールバックを受信することもできます。

埋め込みビジュアルをホストするドメインは、許可リスト ( Quick サブスクリプションで承認されたドメインのリスト) に登録されている必要があります。この要件は、未承認のドメインが埋め込みのビジュアルおよびダッシュボードをホストしないようにすることで、データを保護します。埋め込みビジュアルとダッシュボードのドメインの追加の詳細については、[「Amazon Quick Sight API を使用して実行時にドメインを一覧表示するの](https://docs.aws.amazon.com/quicksight/latest/user/embedding-run-time.html)を許可する」を参照してください。

次の例は生成された URL の使用方法を示しています。このコードはアプリケーションサーバーにあります。

### SDK 2.0
<a name="embedded-analytics-visuals-with-anonymous-users-sdkv2"></a>

```
<!DOCTYPE html>
<html>

    <head>
        <title>Visual Embedding Example</title>
        <script src="https://unpkg.com/amazon-quicksight-embedding-sdk@2.0.0/dist/quicksight-embedding-js-sdk.min.js"></script>
        <script type="text/javascript">
            const embedVisual = async() => {    
                const {
                    createEmbeddingContext,
                } = QuickSightEmbedding;

                const embeddingContext = await createEmbeddingContext({
                    onChange: (changeEvent, metadata) => {
                        console.log('Context received a change', changeEvent, metadata);
                    },
                });

                const frameOptions = {
                    url: "<YOUR_EMBED_URL>", // replace this value with the url generated via embedding API
                    container: '#experience-container',
                    height: "700px",
                    width: "1000px",
                    onChange: (changeEvent, metadata) => {
                        switch (changeEvent.eventName) {
                            case 'FRAME_MOUNTED': {
                                console.log("Do something when the experience frame is mounted.");
                                break;
                            }
                            case 'FRAME_LOADED': {
                                console.log("Do something when the experience frame is loaded.");
                                break;
                            }
                        }
                    },
                };

                const contentOptions = {
                    parameters: [
                        {
                            Name: 'country',
                            Values: ['United States'],
                        },
                        {
                            Name: 'states',
                            Values: [
                                'California',
                                'Washington'
                            ]
                        }
                    ],
                    locale: "en-US",
                    onMessage: async (messageEvent, experienceMetadata) => {
                        switch (messageEvent.eventName) {
                            case 'CONTENT_LOADED': {
                                console.log("All visuals are loaded. The title of the document:", messageEvent.message.title);
                                break;
                            }
                            case 'ERROR_OCCURRED': {
                                console.log("Error occurred while rendering the experience. Error code:", messageEvent.message.errorCode);
                                break;
                            }
                            case 'PARAMETERS_CHANGED': {
                                console.log("Parameters changed. Changed parameters:", messageEvent.message.changedParameters);
                                break;
                            }
                            case 'SIZE_CHANGED': {
                                console.log("Size changed. New dimensions:", messageEvent.message);
                                break;
                            }
                        }
                    },
                };
                const embeddedVisualExperience = await embeddingContext.embedVisual(frameOptions, contentOptions);

                const selectCountryElement = document.getElementById('country');
                selectCountryElement.addEventListener('change', (event) => {
                    embeddedVisualExperience.setParameters([
                        {
                            Name: 'country',
                            Values: event.target.value
                        }
                    ]);
                });
            };
        </script>
    </head>

    <body onload="embedVisual()">
        <span>
            <label for="country">Country</label>
            <select id="country" name="country">
                <option value="United States">United States</option>
                <option value="Mexico">Mexico</option>
                <option value="Canada">Canada</option>
            </select>
        </span>
        <div id="experience-container"></div>
    </body>

</html>
```

### SDK 1.0
<a name="embedded-analytics-visuals-with-anonymous-users-sdkv1"></a>

```
<!DOCTYPE html>
<html>

    <head>
        <title>Visual Embedding Example</title>
        <!-- You can download the latest QuickSight embedding SDK version from https://www.npmjs.com/package/amazon-quicksight-embedding-sdk -->
        <!-- Or you can do "npm install amazon-quicksight-embedding-sdk", if you use npm for javascript dependencies -->
        <script src="./quicksight-embedding-js-sdk.min.js"></script>
        <script type="text/javascript">
            let embeddedVisualExperience;
            function onVisualLoad(payload) {
                console.log("Do something when the visual is fully loaded.");
            }

            function onError(payload) {
                console.log("Do something when the visual fails loading");
            }

            function embedVisual() {
                const containerDiv = document.getElementById("embeddingContainer");
                const options = {
                    url: "<YOUR_EMBED_URL>", // replace this value with the url generated via embedding API
                    container: containerDiv,
                    parameters: {
                        country: "United States"
                    },
                    height: "700px",
                    width: "1000px",
                    locale: "en-US"
                };
                embeddedVisualExperience = QuickSightEmbedding.embedVisual(options);
                embeddedVisualExperience.on("error", onError);
                embeddedVisualExperience.on("load", onVisualLoad);
            }

            function onCountryChange(obj) {
                embeddedVisualExperience.setParameters({country: obj.value});
            }
        </script>
    </head>

    <body onload="embedVisual()">
        <span>
            <label for="country">Country</label>
            <select id="country" name="country" onchange="onCountryChange(this)">
                <option value="United States">United States</option>
                <option value="Mexico">Mexico</option>
                <option value="Canada">Canada</option>
            </select>
        </span>
        <div id="embeddingContainer"></div>
    </body>

</html>
```

この例では、Amazon Quick Sight Embedding SDK を使用して、JavaScript を使用してウェブサイトに埋め込みビジュアルをロードします。コピーを取得するには、次のいずれかを実行します。
+ GitHub [から Amazon Quick Sight Embedding SDK](https://github.com/awslabs/amazon-quicksight-embedding-sdk#step-3-create-the-quicksight-session-object) をダウンロードします。このリポジトリは、Amazon Quick Sight 開発者のグループによって管理されます。
+ [https://www.npmjs.com/package/amazon-quicksight-embedding-sdk](https://www.npmjs.com/package/amazon-quicksight-embedding-sdk) から最新の QuickSight Embedding SDK バージョンをダウンロードします。
+ JavaScript の依存関係の `npm` を使用する場合、次のコマンドを実行してダウンロードおよびインストールします。

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

# 登録済みユーザー向けの Amazon Quick Sight コンソールの全機能の埋め込み
<a name="embedded-analytics-full-console-for-authenticated-users"></a>

**重要**  
Amazon Quick Sight には、分析を埋め込むための新しい API オペレーション `GenerateEmbedUrlForAnonymousUser`と があります`GenerateEmbedUrlForRegisteredUser`。  
`GetDashboardEmbedUrl` および `GetSessionEmbedUrl` API オペレーションを使用してダッシュボードと Amazon Quick Sight コンソールを埋め込むことはできますが、最新の埋め込み機能は含まれていません。古い API オペレーションを使用した埋め込みの詳細については、「 [GetDashboardEmbedURLおよび GetSessionEmbedURL API オペレーションを使用した分析の埋め込み](https://docs.aws.amazon.com/quicksight/latest/user/embedded-analytics-deprecated.html)」を参照してください。


|  | 
| --- |
|  適用対象: Enterprise Edition  | 


|  | 
| --- |
|    対象者:  Amazon Quick デベロッパー  | 

Enterprise Edition では、読み取り専用ダッシュボードを提供するだけでなく、カスタムブランドのオーサリングポータルで Amazon Quick Sight コンソールエクスペリエンスを提供することもできます。この方法を使用すると、ユーザーはデータソース、データセット、分析を作成できます。ユーザーは同じインターフェイスで、ダッシュボードを作成、公開、表示できます。これらの許可の一部を制限することもできます。

埋め込みコンソールから Amazon Quick Sight にアクセスするユーザーは、作成者または管理者のセキュリティコホートに属している必要があります。リーダーは、埋め込みか の一部かにかかわらず、Amazon Quick Sight コンソールを使用して作成するための十分なアクセス権がありません AWS マネジメントコンソール。ただし、作成者と管理者は埋め込みダッシュボードにアクセスできます。アクセス許可を一部の作成機能に制限する場合は、[UpdateUser](https://docs.aws.amazon.com/quicksight/latest/APIReference/API_UpdateUser.html) API オペレーションを使用して、ユーザーにカスタムアクセス許可プロファイルを追加します。[RegisterUser](https://docs.aws.amazon.com/quicksight/latest/APIReference/API_RegisterUser.html) API オペレーションを使用して、カスタムアクセス許可プロファイルをアタッチした新規ユーザーを追加します。詳細については、次のセクションを参照してください。
+ カスタムコンソールのアクセス許可を定義してカスタムロールを作成する方法については、[「Amazon Quick Sight コンソールへのアクセスのカスタマイズ](https://docs.aws.amazon.com/quicksight/latest/user/customizing-permissions-to-the-quicksight-console.html)」を参照してください。
+ 名前空間を使用してマルチテナンシーユーザー、グループ、Amazon Quick Sight アセットを分離する方法については、[「Amazon Quick Sight 名前空間](https://docs.aws.amazon.com/quicksight/latest/APIReference/controlling-access.html#namespaces.html)」を参照してください。
+ 埋め込み Amazon Quick Sight コンソールに独自のブランドを追加する方法については、[「Amazon Quick Sight でのテーマの使用](https://docs.aws.amazon.com/quicksight/latest/user/themes-in-quicksight.html)」および[QuickSight テーマ API オペレーション](https://docs.aws.amazon.com/quicksight/latest/APIReference/qs-assets.html#themes)」を参照してください。

以下のセクションでは、登録済みユーザーの埋め込み Amazon Quick Sight ダッシュボードを設定する方法について詳しく説明します。

**Topics**
+ [

## ステップ 1: 許可をセットアップする
](#embedded-analytics-full-console-for-authenticated-users-step-1)
+ [

## ステップ 2: 認証コードがアタッチされた URL を生成する
](#embedded-analytics-full-console-for-authenticated-users-step-2)
+ [

## ステップ 3: コンソールセッション URL を埋め込む
](#embedded-analytics-full-console-for-authenticated-users-step-3)
+ [

# 登録済みユーザーの埋め込みコンソールで Generative BI 機能を有効にする
](embedding-consoles-genbi.md)

## ステップ 1: 許可をセットアップする
<a name="embedded-analytics-full-console-for-authenticated-users-step-1"></a>

次のセクションでは、バックエンドアプリケーションまたはウェブサーバーのアクセス許可を設定する方法について説明します。このタスクには IAM への管理者アクセス権が必要です。

Amazon Quick Sight にアクセスする各ユーザーは、コンソールセッションへのアクセスとアクセス許可を Amazon Quick Sight に付与するロールを引き受けます。これを可能にするには、 AWS アカウントに IAM ロールを作成します。IAM ポリシーをロールに関連付けて、それを引き受けるすべてのユーザーにアクセス許可を付与します。アクセス`quicksight:RegisterUser`許可を追加して、閲覧者が Amazon Quick Sight に読み取り専用でアクセスでき、他のデータや作成機能にアクセスできないようにします。IAM ロールは、コンソールセッションの URL を取得する許可も付与する必要があります。このためには、`quicksight:GenerateEmbedUrlForRegisteredUser` を追加します。

IAM ポリシーで条件を作成し、デベロッパーが `GenerateEmbedUrlForAnonymousUser` API オペレーションの `AllowedDomains` パラメータにリストできるドメインを制限できます。`AllowedDomains` パラメータはオプションのパラメータです。これにより、**Amazon Quick Sight の管理**メニューで設定された静的ドメインを上書きするオプションが開発者として付与されます。代わりに、生成された URL へのアクセスが可能な、ドメインもしくはサブドメインを、最大 3 つまでリストアップすることもできます。この URL は、作成した Web サイトに埋め込むことが可能です。パラメータにリストされているドメインのみが、埋め込みダッシュボードにアクセスできます。この状態にしていない場合、インターネット上の任意のドメインを `AllowedDomains` パラメータにリストできてしまいます。

**IAM 条件演算子のセキュリティのベストプラクティス**  
正しく設定されていない IAM 条件演算子は、URL のバリエーションを通じて埋め込み Quick リソースへの不正アクセスを許可できます。IAM ポリシーで `quicksight:AllowedEmbeddingDomains` 条件キーを使用する場合は、特定のドメインを許可するか、特に許可されていないすべてのドメインを拒否する条件演算子を使用します。IAM 条件演算子の詳細については、IAM [ユーザーガイドの「IAM JSON ポリシー要素: 条件演算子](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_elements_condition_operators.html)」を参照してください。  
多くの異なる URL バリエーションが同じリソースを指す場合があります。たとえば、次の URLsはすべて同じコンテンツに解決されます。  
`https://example.com`
`https://example.com/`
`https://Example.com`
ポリシーでこれらの URL バリエーションを考慮しない演算子を使用している場合、攻撃者は同等の URL バリエーションを提供することで制限を回避できます。  
IAM ポリシーが適切な条件演算子を使用してバイパスの脆弱性を防ぎ、目的のドメインのみが埋め込みリソースにアクセスできることを確認する必要があります。

次のサンプルポリシーで、これらの権限が付与されます。

次のサンプルポリシーで、コンソールセッションの URL を取得する許可が付与されます。ユーザーが埋め込みセッションにアクセスする前にユーザーを作成する場合は、`quicksight:RegisterUser` なしでポリシーを使用できます。

最後に、作成したロールへのアクセスを許可するには、アプリケーションの IAM ID に関連付けられた信頼ポリシーが必要です。つまり、ユーザーがアプリケーションにアクセスすると、アプリケーションはユーザーに代わってロールを引き受け、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 ユーザーガイド*」の以下のセクションを参照してください。
+ [ウェブ ID または OpenID Connect フェデレーション用のロールを作成する (コンソール)](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_create_for-idp_oidc.html)
+ [SAML 2.0 フェデレーション用のロールの作成 (コンソール)](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_create_for-idp_saml.html)

## ステップ 2: 認証コードがアタッチされた URL を生成する
<a name="embedded-analytics-full-console-for-authenticated-users-step-2"></a>

次のセクションでは、ユーザーの認証方法とアプリケーションサーバー上の埋め込みコンソールセッションの URL の取得方法について説明します。

ユーザーがアプリケーションにアクセスすると、アプリケーションはユーザーに代わって IAM ロールを引き受けます。次に、そのユーザーがまだ存在しない場合、そのユーザーを Amazon Quick Sight に追加します。次に、アプリケーションが一意のロールセッション ID として識別子を渡します。

前述のステップを実行すると、コンソールセッションの各ビューワーが Amazon Quick Sight で一意にプロビジョニングされます。行レベルのセキュリティやパラメータの動的デフォルトなど、ユーザーごとの設定も強制されます。

次の例では、ユーザーに代わって IAM 認証を実行します。このコードはアプリケーションサーバー上で実行されます。

### Java
<a name="embedded-analytics-full-console-for-authenticated-users-java"></a>

```
import com.amazonaws.auth.AWSCredentials;
import com.amazonaws.auth.BasicAWSCredentials;
import com.amazonaws.auth.AWSCredentialsProvider;
import com.amazonaws.regions.Regions;
import com.amazonaws.services.quicksight.AmazonQuickSight;
import com.amazonaws.services.quicksight.AmazonQuickSightClientBuilder;
import com.amazonaws.services.quicksight.model.GenerateEmbedUrlForRegisteredUserRequest;
import com.amazonaws.services.quicksight.model.GenerateEmbedUrlForRegisteredUserResult;
import com.amazonaws.services.quicksight.model.RegisteredUserEmbeddingExperienceConfiguration;
import com.amazonaws.services.quicksight.model.RegisteredUserQuickSightConsoleEmbeddingConfiguration;

/**
 * Class to call QuickSight AWS SDK to get url for QuickSight console embedding.
 */
public class GetQuicksightEmbedUrlRegisteredUserQSConsoleEmbedding {

    private final AmazonQuickSight quickSightClient;

    public GetQuicksightEmbedUrlRegisteredUserQSConsoleEmbedding() {
        this.quickSightClient = AmazonQuickSightClientBuilder
                .standard()
                .withRegion(Regions.US_EAST_1.getName())
                .withCredentials(new AWSCredentialsProvider() {
                        @Override
                        public AWSCredentials getCredentials() {
                            // provide actual IAM access key and secret key here
                            return new BasicAWSCredentials("access-key", "secret-key");
                        }

                         @Override
                        public void refresh() {                           
                        }
                    }
                )
                .build();
    }

    public String getQuicksightEmbedUrl(
            final String accountId,
            final String userArn, // Registered user arn to use for embedding. Refer to Get Embed Url section in developer portal to find out how to get user arn for a QuickSight user.
            final List<String> allowedDomains, // Runtime allowed domain for embedding
            final String initialPath
    ) throws Exception {
        final RegisteredUserEmbeddingExperienceConfiguration experienceConfiguration = new RegisteredUserEmbeddingExperienceConfiguration()
                .withQuickSightConsole(new RegisteredUserQuickSightConsoleEmbeddingConfiguration().withInitialPath(initialPath));
        final GenerateEmbedUrlForRegisteredUserRequest generateEmbedUrlForRegisteredUserRequest = new GenerateEmbedUrlForRegisteredUserRequest();
        generateEmbedUrlForRegisteredUserRequest.setAwsAccountId(accountId);
        generateEmbedUrlForRegisteredUserRequest.setUserArn(userArn);
        generateEmbedUrlForRegisteredUserRequest.setAllowedDomains(allowedDomains);
        generateEmbedUrlForRegisteredUserRequest.setExperienceConfiguration(experienceConfiguration);

        final GenerateEmbedUrlForRegisteredUserResult generateEmbedUrlForRegisteredUserResult = quickSightClient.generateEmbedUrlForRegisteredUser(generateEmbedUrlForRegisteredUserRequest);

        return generateEmbedUrlForRegisteredUserResult.getEmbedUrl();
    }
}
```

### JavaScript
<a name="embedded-analytics-full-console-for-authenticated-users-js"></a>

```
global.fetch = require('node-fetch');
const AWS = require('aws-sdk');

function generateEmbedUrlForRegisteredUser(
    accountId,
    dashboardId,
    openIdToken, // Cognito-based token
    userArn, // registered user arn
    roleArn, // IAM user role to use for embedding
    sessionName, // Session name for the roleArn assume role
    allowedDomains, // Runtime allowed domain for embedding
    getEmbedUrlCallback, // GetEmbedUrl success callback method
    errorCallback // GetEmbedUrl error callback method
    ) {
    const stsClient = new AWS.STS();
    let stsParams = {
        RoleSessionName: sessionName,
        WebIdentityToken: openIdToken,
        RoleArn: roleArn
    }

    stsClient.assumeRoleWithWebIdentity(stsParams, function(err, data) {
        if (err) {
            console.log('Error assuming role');
            console.log(err, err.stack);
            errorCallback(err);
        } else {
            const getDashboardParams = {
                "AwsAccountId": accountId,
                "ExperienceConfiguration": {
                    "QuickSightConsole": {
                        "InitialPath": '/start'
                    }
                },
                "UserArn": userArn,
                "AllowedDomains": allowedDomains,
                "SessionLifetimeInMinutes": 600
            };

            const quicksightGetDashboard = new AWS.QuickSight({
                region: process.env.AWS_REGION,
                credentials: {
                    accessKeyId: data.Credentials.AccessKeyId,
                    secretAccessKey: data.Credentials.SecretAccessKey,
                    sessionToken: data.Credentials.SessionToken,
                    expiration: data.Credentials.Expiration
                }
            });

            quicksightGetDashboard.generateEmbedUrlForRegisteredUser(getDashboardParams, function(err, data) {
                if (err) {
                    console.log(err, err.stack);
                    errorCallback(err);
                } else {
                    const result = {
                        "statusCode": 200,
                        "headers": {
                            "Access-Control-Allow-Origin": "*", // Use your website domain to secure access to GetEmbedUrl API
                            "Access-Control-Allow-Headers": "Content-Type"
                        },
                        "body": JSON.stringify(data),
                        "isBase64Encoded": false
                    }
                    getEmbedUrlCallback(result);
                }
            });
        }
    });
}
```

### Python3
<a name="embedded-analytics-full-console-for-authenticated-users-py"></a>

```
import json
import boto3
from botocore.exceptions import ClientError

# Create QuickSight and STS clients
qs = boto3.client('quicksight', region_name='us-east-1')
sts = boto3.client('sts')

# Function to generate embedded URL  
# accountId: AWS account ID
# userArn: arn of registered user
# allowedDomains: Runtime allowed domain for embedding
# roleArn: IAM user role to use for embedding
# sessionName: session name for the roleArn assume role
def generateEmbeddingURL(accountId, userArn, allowedDomains, roleArn, sessionName):
    try:
        assumedRole = sts.assume_role(
            RoleArn = roleArn,
            RoleSessionName = sessionName,
        )
    except ClientError as e:
        return "Error assuming role: " + str(e)
    else: 
        assumedRoleSession = boto3.Session(
            aws_access_key_id = assumedRole['Credentials']['AccessKeyId'],
            aws_secret_access_key = assumedRole['Credentials']['SecretAccessKey'],
            aws_session_token = assumedRole['Credentials']['SessionToken'],
        )
        try:
            quickSightClient = assumedRoleSession.client('quicksight', region_name='us-east-1')
            
            experienceConfiguration = {
                "QuickSightConsole": {
                    "InitialPath": "/start"
                }
            }
            response = quickSightClient.generate_embed_url_for_registered_user(
                 AwsAccountId = accountId,
                 ExperienceConfiguration = experienceConfiguration,
                 UserArn = userArn,
                 AllowedDomains = allowedDomains,
                 SessionLifetimeInMinutes = 600
            )
            
            return {
                'statusCode': 200,
                'headers': {"Access-Control-Allow-Origin": "*", "Access-Control-Allow-Headers": "Content-Type"},
                'body': json.dumps(response),
                'isBase64Encoded':  bool('false')
            }
        except ClientError as e:
            return "Error generating embedding url: " + str(e)
```

### Node.js
<a name="embedded-analytics-full-console-for-authenticated-users-node"></a>

次の例は、埋め込みコンソールセッションの URL を生成するためにアプリケーションサーバーで使用する JavaScript (Node.js) を示しています。コンソールセッションを表示するには、ウェブサイトまたはアプリケーションでこの URL を使用します。

**Example**  

```
const AWS = require('aws-sdk');
const https = require('https');

var quicksightClient = new AWS.Service({
    apiConfig: require('./quicksight-2018-04-01.min.json'),
    region: 'us-east-1',
});

quicksightClient.generateEmbedUrlForRegisteredUser({
    'AwsAccountId': '111122223333',
    'ExperienceConfiguration': {
        'QuickSightConsole': {
            'InitialPath': '/start'
        }
    },
    'UserArn': 'REGISTERED_USER_ARN',
    'AllowedDomains': allowedDomains,
    'SessionLifetimeInMinutes': 100
}, function(err, data) {
    console.log('Errors: ');
    console.log(err);
    console.log('Response: ');
    console.log(data);
});
```

**Example**  

```
// The URL returned is over 900 characters. For this example, we've shortened the string for
// readability and added ellipsis to indicate that it's incomplete.
    {
        Status: 200,
        EmbedUrl: 'https://quicksightdomain/embed/12345/dashboards/67890..,
        RequestId: '7bee030e-f191-45c4-97fe-d9faf0e03713'
    }
```

### .NET/C\$1
<a name="embedded-analytics-full-console-for-authenticated-users-cs"></a>

次の例は、埋め込みコンソールセッションの 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
            {
                RegisteredUserQuickSightConsoleEmbeddingConfiguration registeredUserQuickSightConsoleEmbeddingConfiguration
                    = new RegisteredUserQuickSightConsoleEmbeddingConfiguration
                    {
                        InitialPath = "/start"
                    };
                RegisteredUserEmbeddingExperienceConfiguration registeredUserEmbeddingExperienceConfiguration
                    = new RegisteredUserEmbeddingExperienceConfiguration
                    {
                        QuickSightConsole = registeredUserQuickSightConsoleEmbeddingConfiguration
                    };
                
                Console.WriteLine(
                    quicksightClient.GenerateEmbedUrlForRegisteredUserAsync(new GenerateEmbedUrlForRegisteredUserRequest
                    {
                        AwsAccountId = "111122223333",
                        ExperienceConfiguration = registeredUserEmbeddingExperienceConfiguration,
                        UserArn = "REGISTERED_USER_ARN",
                        AllowedDomains = allowedDomains,
                        SessionLifetimeInMinutes = 100
                    }).Result.EmbedUrl
                );
            } catch (Exception ex) {
                Console.WriteLine(ex.Message);
            }
        }
    }
}
```

### AWS CLI
<a name="embedded-analytics-full-console-for-authenticated-users-cli"></a>

ロールを引き受けるには、次のいずれかの AWS Security Token Service (AWS STS) API オペレーションを選択します。
+ [AssumeRole](https://docs.aws.amazon.com/STS/latest/APIReference/API_AssumeRole.html) – ロールを引き受けるために IAM ID を使用している場合は、このオペレーションを使用します。
+ [AssumeRoleWithWebIdentity](https://docs.aws.amazon.com/STS/latest/APIReference/API_AssumeRoleWithWebIdentity.html) – ユーザーの認証にウェブ ID プロバイダーを使用している場合は、このオペレーションを使用します。
+ [AssumeRoleWithSaml](https://docs.aws.amazon.com/STS/latest/APIReference/API_AssumeRoleWithSAML.html) – ユーザーの認証に SAML を使用している場合は、このオペレーションを使用します。

次の例は、IAM ロールを設定するための CLI コマンドを示しています。ロールでは、`quicksight:GenerateEmbedUrlForRegisteredUser` に対する許可が有効化されている必要があります。ユーザーが最初に Amazon Quick Sight を開いたときに、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` オペレーションは、アクセスキー、シークレットキー、およびセッショントークンの 3 つの出力パラメータを返します。

**注記**  
`AssumeRole` オペレーションを呼び出すときに `ExpiredToken` エラーが発生した場合は、以前の `SESSION TOKEN` がまだ環境変数に残っている可能性があります。以下の変数を設定することで、これをオフにします。  
*AWS\$1ACCESS\$1KEY\$1ID* 
*AWS\$1SECRET\$1ACCESS\$1KEY* 
*AWS\$1SESSION\$1TOKEN* 

次の例は、CLI でこれら 3 つのパラメータを設定する方法を示しています。Microsoft Windows マシンを使用している場合は、`export` の代わりに `set` を使用します。

```
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 を使用すると、各ユーザーに適切なアクセス許可が設定されます。また、ユーザーアクセスのスロットリングが防止されます。スロットリングは、同じユーザーが複数の場所から Amazon Quick Sight にアクセスできないようにするセキュリティ機能です。

ロールセッション ID も Amazon Quick Sight のユーザー名になります。このパターンを使用して、Amazon Quick Sight でユーザーを事前にプロビジョニングしたり、コンソールセッションに初めてアクセスしたときにユーザーをプロビジョニングしたりできます。

次の例は、ユーザーをプロビジョニングするために使用できる CLI コマンドを示しています。[RegisterUser](https://docs.aws.amazon.com/quicksight/latest/APIReference/API_RegisterUser.html)、[DescribeUser](https://docs.aws.amazon.com/quicksight/latest/APIReference/API_DescribeUser.html)、およびその他の Amazon Quick Sight API オペレーションの詳細については、[「Amazon Quick Sight API リファレンス](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
```

ユーザーが 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 のユーザーでもあり、Amazon Quick Sight コンソールセッションにアクセスできるアプリのユーザーができました。

最後に、コンソールセッションの署名付き 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"}
```

このオペレーションの使用に関する詳細については、[https://docs.aws.amazon.com/quicksight/latest/APIReference/API_GenerateEmbedUrlForRegisteredUser.html](https://docs.aws.amazon.com/quicksight/latest/APIReference/API_GenerateEmbedUrlForRegisteredUser.html) を参照してください。これと他の API オペレーションは、独自のコードで使用できます。

## ステップ 3: コンソールセッション URL を埋め込む
<a name="embedded-analytics-full-console-for-authenticated-users-step-3"></a>

次のセクションでは、[Amazon Quick Sight Embedding SDK](https://www.npmjs.com/package/amazon-quicksight-embedding-sdk) (JavaScript) を使用して、ステップ 3 のコンソールセッション URL をウェブサイトまたはアプリケーションページに埋め込む方法について説明します。この SDK を使用することで、以下を実行できます。
+ コンソールセッションを HTML ページに配置します。
+ コンソールセッションにパラメータを渡します。
+ アプリケーションに合わせてカスタマイズされたメッセージでエラー状態を処理します。

`GenerateEmbedUrlForRegisteredUser` API オペレーションを呼び出して URL を生成し、アプリケーションに埋め込みます。この URL は 5 分間有効で、得られたセッションは最大 10 時間有効です。API オペレーションは、シングルサインオンセッションを有効にする `auth_code` の URL を提供します。

以下に、`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"
}
```

Amazon Quick Sight [Embedding SDK を使用する](https://www.npmjs.com/package/amazon-quicksight-embedding-sdk)か、この URL を iframe に追加して、このコンソールセッションをウェブページに埋め込みます。固定の高さと幅の数値 (ピクセル単位) を設定した場合、Amazon Quick Sight はそれらを使用し、ウィンドウのサイズ変更に伴ってビジュアルを変更しません。相対的な高さと幅の割合を設定すると、Amazon Quick Sight はウィンドウサイズの変化に応じて変化するレスポンシブレイアウトを提供します。Amazon Quick Sight Embedding SDK を使用すると、コンソールセッション内のパラメータを制御し、ページロードの完了とエラーの観点からコールバックを受信することもできます。

埋め込みダッシュボードをホストするドメインは、 Quick サブスクリプション用に承認されたドメインのリストである*許可*リストに含まれている必要があります。この要件は、未承認のドメインが埋め込みダッシュボードをホストしないようにすることでデータを保護します。埋め込みコンソールのドメインの追加の詳細については、[「Amazon Quick Sight API を使用して実行時にドメインを一覧表示するの](https://docs.aws.amazon.com/quicksight/latest/user/embedding-run-time.html)を許可する」を参照してください。

次の例は生成された URL の使用方法を示しています。このコードはアプリケーションサーバー上で生成されます。

### SDK 2.0
<a name="embedded-analytics-full-console-for-authenticated-users-sdkv2"></a>

```
<!DOCTYPE html>
<html>

    <head>
        <title>Console Embedding Example</title>
        <script src="https://unpkg.com/amazon-quicksight-embedding-sdk@2.0.0/dist/quicksight-embedding-js-sdk.min.js"></script>
        <script type="text/javascript">
            const embedSession = async() => {    
                const {
                    createEmbeddingContext,
                } = QuickSightEmbedding;

                const embeddingContext = await createEmbeddingContext({
                    onChange: (changeEvent, metadata) => {
                        console.log('Context received a change', changeEvent, metadata);
                    },
                });

                const frameOptions = {
                    url: "<YOUR_EMBED_URL>", // replace this value with the url generated via embedding API
                    container: '#experience-container',
                    height: "700px",
                    width: "1000px",
                    onChange: (changeEvent, metadata) => {
                        switch (changeEvent.eventName) {
                            case 'FRAME_MOUNTED': {
                                console.log("Do something when the experience frame is mounted.");
                                break;
                            }
                            case 'FRAME_LOADED': {
                                console.log("Do something when the experience frame is loaded.");
                                break;
                            }
                        }
                    },
                };

                const contentOptions = {
                    onMessage: async (messageEvent, experienceMetadata) => {
                        switch (messageEvent.eventName) {
                            case 'ERROR_OCCURRED': {
                                console.log("Do something when the embedded experience fails loading.");
                                break;
                            }
                        }
                    }
                };
                const embeddedConsoleExperience = await embeddingContext.embedConsole(frameOptions, contentOptions);
            };
        </script>
    </head>

    <body onload="embedSession()">
        <div id="experience-container"></div>
    </body>

</html>
```

### SDK 1.0
<a name="embedded-analytics-full-console-for-authenticated-users-sdkv1"></a>

```
<!DOCTYPE html>
<html>

    <head>
        <title>QuickSight Console Embedding</title>
        <script src="https://unpkg.com/amazon-quicksight-embedding-sdk@1.0.15/dist/quicksight-embedding-js-sdk.min.js"></script>
        <script type="text/javascript">
            var session

            function onError(payload) {
                console.log("Do something when the session fails loading");
            }

            function embedSession() {
                var containerDiv = document.getElementById("embeddingContainer");
                var options = {
                    // replace this dummy url with the one generated via embedding API
                    url: "https://us-east-1.quicksight.aws.amazon.com/sn/dashboards/dashboardId?isauthcode=true&identityprovider=quicksight&code=authcode", // replace this dummy url with the one generated via embedding API
                    container: containerDiv,
                    parameters: {
                        country: "United States"
                    },
                    scrolling: "no",
                    height: "700px",
                    width: "1000px",
                    locale: "en-US",
                    footerPaddingEnabled: true,
                    defaultEmbeddingVisualType: "TABLE", // this option only applies to QuickSight console embedding and is not used for dashboard embedding
                };
                session = QuickSightEmbedding.embedSession(options);
                session.on("error", onError);
            }

            function onCountryChange(obj) {
                session.setParameters({country: obj.value});
            }
        </script>
    </head>

    <body onload="embedSession()">
        <span>
            <label for="country">Country</label>
            <select id="country" name="country" onchange="onCountryChange(this)">
                <option value="United States">United States</option>
                <option value="Mexico">Mexico</option>
                <option value="Canada">Canada</option>
            </select>
        </span>
        <div id="embeddingContainer"></div>
    </body>

</html>
```

この例では、Amazon Quick Sight Embedding SDK を使用して、JavaScript を使用してウェブサイトに埋め込みコンソールセッションをロードします。コピーを取得するには、次のいずれかを実行します。
+ GitHub [から Amazon Quick Sight Embedding SDK](https://github.com/awslabs/amazon-quicksight-embedding-sdk#step-3-create-the-quicksight-session-object) をダウンロードします。このリポジトリは、Amazon Quick Sight 開発者のグループによって管理されます。
+ [https://www.npmjs.com/package/amazon-quicksight-embedding-sdk](https://www.npmjs.com/package/amazon-quicksight-embedding-sdk) から、最新の埋め込み SDK バージョンをダウンロードします。
+ JavaScript の依存関係の `npm` を使用する場合、次のコマンドを実行してダウンロードおよびインストールします。

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

# 登録済みユーザーの埋め込みコンソールで Generative BI 機能を有効にする
<a name="embedding-consoles-genbi"></a>


|  | 
| --- |
|  適用対象: Enterprise Edition  | 


|  | 
| --- |
|    対象者:  Amazon Quick デベロッパー  | 

埋め込みコンソールで次の Generative BI 機能を有効にすることができます。
+ エグゼクティブサマリー: 有効にすると、登録済みの Author Pro および Reader Pro ユーザーは、ダッシュボードで主要なインサイトを簡単に検出するために Amazon Quick Sight が生成したすべてのインサイトの概要を提供するエグゼクティブサマリーを生成できます。
+ オーサリング: 有効にすると、Author Pro ユーザーは Generative BI を使用して計算フィールドを構築し、ビジュアルを構築と改良を行うことができます。
+ Q&A: 有効にすると、Author Pro および Reader Pro ユーザーは AI を活用した Q&A を使用して、データに関連する質問の提案と回答の両方を行うことができます。
+ データストーリー: 有効にすると、Author Pro および Reader Pro ユーザーは詳細を提供して、データストーリーの最初のドラフトをすばやく生成できます。

**登録済みユーザーの埋め込みコンソールで Generative BI 機能を有効にするには**
+ [登録済みユーザーが以下の変更を加えてコンソールを埋め込むには、「Amazon Quick Sight コンソールの全機能を](https://docs.aws.amazon.com/quicksight/latest/user/embedded-analytics-full-console-for-authenticated-users.html)埋め込む」のステップに従います。

  1. ステップ 2 で URL を生成するときに、次の例に示すように [GenerateEmbedUrlForRegisteredUser](https://docs.aws.amazon.com/quicksight/latest/APIReference/API_GenerateEmbedUrlForRegisteredUser.html) または [GenerateEmbedUrlForRegisteredUserWithIdentity](https://docs.aws.amazon.com/quicksight/latest/APIReference/API_GenerateEmbedUrlForRegisteredUserWithIdentity.html) で、有効にする各機能の `FeatureConfigurations` パラメータに `Enabled: true` を設定します。設定が指定しない場合、機能はデフォルトで無効になります。

     ```
     ExperienceConfiguration: {
             QuickSightConsole: {
                 InitialPath: "initial_path",
                 AmazonQInQuickSight: {
                     FeatureConfigurations: { 
                         COMMENT: Enable executive summaries
                         ExecutiveSummary: {
                             Enabled: true
                         },
                         COMMENT: Enable Generative BI authoring
                         GenerativeAuthoring: {
                             Enabled: true
                         },
                         COMMENT: Enable Q&A
                         DataQnA: {
                             Enabled: true
                         },
                         COMMENT: Enable data stories
                         DataStories: {
                             Enabled: true
                         }       
                     }
                 }
             }
         }
     }
     ```

  1. ステップ 3 で Amazon Quick Sight Embedding SDK を使用してコンソール URL を埋め込む場合は、次の例の値を必要に応じて設定します。設定が指定しない場合、機能はデフォルトで無効になります。
**注記**  
データストーリーを有効にする SDK オプションはありません。前のステップで示したように API でデータストーリーが有効になっている場合、登録済みユーザーはデータストーリーを使用できます。

     ```
     const contentOptions = {
         toolbarOptions: {
             executiveSummary: true, // Enable executive summaries
             buildVisual: true, // Enable Generative BI authoring
             dataQnA: true // Enable Q&A
         }
     };
     ```

# Amazon Quick Sight Generative Q&A エクスペリエンスに Amazon Q を埋め込む
<a name="embedding-gen-bi"></a>


|  | 
| --- |
|    対象者:  Amazon Quick デベロッパー  | 

以下のセクションでは、LLM を搭載した拡張 NLQ 機能を使用する組み込みの Generative Q&A エクスペリエンスをセットアップする方法について説明します。Generative Q&A エクスペリエンスは、埋め込み Q 検索バーの推奨置き換えであり、ユーザーに更新された BI エクスペリエンスを提供します。

**Topics**
+ [

## 登録済みユーザー向けの Amazon Quick Sight Generative Q&A エクスペリエンスへの Amazon Q の埋め込み
](#embedded-analytics-gen-bi-authenticated-users)
+ [

## 匿名 (未登録) ユーザー向けのクイック生成 Q&A エクスペリエンスに Amazon Q を埋め込む
](#embedded-analytics-gen-bi-anonymous-users)

## 登録済みユーザー向けの Amazon Quick Sight Generative Q&A エクスペリエンスへの Amazon Q の埋め込み
<a name="embedded-analytics-gen-bi-authenticated-users"></a>

以下のセクションでは、Amazon Quick Sight の登録ユーザー向けに埋め込み Generative Q&A エクスペリエンスを設定する方法について詳しく説明します。

**Topics**
+ [

### ステップ 1: 許可をセットアップする
](#embedded-analytics-gen-bi-authenticated-users-step-1)
+ [

### ステップ 2: 認証コードがアタッチされた URL を生成する
](#embedded-analytics-gen-bi-authenticated-users-step-2)
+ [

### ステップ 3: Generative Q&A エクスペリエンス URL を埋め込む
](#embedded-analytics-gen-bi-authenticated-users-step-3)
+ [

### オプションの組み込み Generative Q&A エクスペリエンス機能
](#embedded-analytics-gen-bi-authenticated-users-step-4)

### ステップ 1: 許可をセットアップする
<a name="embedded-analytics-gen-bi-authenticated-users-step-1"></a>

以下のセクションでは、Generative Q&A エクスペリエンスを埋め込むために、バックエンドアプリケーションまたはウェブサーバーのアクセス許可をセットアップする方法を説明します。このタスクには AWS Identity and Access Management 、 (IAM) への管理アクセスが必要です。

Generative Q&A エクスペリエンスにアクセスする各ユーザーは、Amazon Quick Sight のアクセスとアクセス許可を付与するロールを引き受けます。これを可能にするには、 AWS アカウントに IAM ロールを作成します。IAM ポリシーをロールに関連付けて、それを引き受けるすべてのユーザーにアクセス許可を付与します。IAM ロールでは、特定のユーザープールに埋め込み URL を取得するアクセス許可を提供する必要があります。

ワイルドカード文字 *\$1* を使用することにより、特定の名前空間内の全ユーザーに URL を生成する許可を付与できます。または、特定の名前空間内のユーザーのサブセットに URL を生成する許可を付与することもできます。このためには、`quicksight:GenerateEmbedUrlForRegisteredUser` を追加します。

IAM ポリシーで条件を作成し、デベロッパーが `GenerateEmbedUrlForRegisteredUser` API オペレーションの `AllowedDomains` パラメータにリストできるドメインを制限できます。`AllowedDomains` パラメータはオプションのパラメータです。Amazon **Quick Sight の管理**メニューで設定された静的ドメインを上書きし、代わりに生成された URL にアクセスできる最大 3 つのドメインまたはサブドメインを一覧表示するオプションをデベロッパーに付与します。そして、この URL はデベロッパーのウェブサイトに埋め込むことができます。パラメータにリストされているドメインのみが、埋め込み Generative Q&A エクスペリエンスにアクセスすることが可能です。すなわち、この条件を設定していない場合、デベロッパーはインターネット上の任意のドメインを `AllowedDomains` パラメータにリストできてしまいます。

デベロッパーがこのパラメータで使用できるドメインを制限するには、`AllowedEmbeddingDomains` 条件を IAM ポリシーに追加します。`AllowedDomains` パラメータの詳細については、*Amazon Quick Sight API リファレンス*の[GenerateEmbedUrlForRegisteredUser](https://docs.aws.amazon.com//quicksight/latest/APIReference/API_GenerateEmbedUrlForRegisteredUser.html)」を参照してください。

**IAM 条件演算子のセキュリティのベストプラクティス**  
正しく設定されていない IAM 条件演算子は、URL のバリエーションを通じて埋め込み Quick リソースへの不正アクセスを許可できます。IAM ポリシーで `quicksight:AllowedEmbeddingDomains` 条件キーを使用する場合は、特定のドメインを許可するか、特に許可されていないすべてのドメインを拒否する条件演算子を使用します。IAM 条件演算子の詳細については、IAM [ユーザーガイドの「IAM JSON ポリシー要素: 条件演算子](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_elements_condition_operators.html)」を参照してください。  
多くの異なる URL バリエーションが同じリソースを指す場合があります。たとえば、次の URLsはすべて同じコンテンツに解決されます。  
`https://example.com`
`https://example.com/`
`https://Example.com`
ポリシーでこれらの URL バリエーションを考慮しない演算子を使用している場合、攻撃者は同等の URL バリエーションを提供することで制限を回避できます。  
IAM ポリシーが適切な条件演算子を使用してバイパスの脆弱性を防ぎ、目的のドメインのみが埋め込みリソースにアクセスできることを確認する必要があります。

次のサンプルポリシーで、これらの権限が付与されます。

また、Amazon Quick Sight リーダーとなる初めてのユーザーを作成する場合は、ポリシーに アクセス`quicksight:RegisterUser`許可を追加してください。

次のサンプルポリシーは、Amazon Quick Sight リーダーになる初めてのユーザーの埋め込み URL を取得するアクセス許可を提供します。

最後に、作成したロールへのアクセスを許可するには、アプリケーションの IAM ID に関連付けられた信頼ポリシーが必要です。つまり、ユーザーがアプリケーションにアクセスすると、アプリケーションはユーザーに代わってロールを引き受け、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 または Security Assertion Markup Language (SAML) 認証の信頼ポリシーに関する詳細については、*IAM ユーザーガイド*の以下のセクションを参照してください。
+ [ウェブ ID または OpenID Connect フェデレーション用のロールの作成 (コンソール)](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_create_for-idp_oidc.html)
+ [SAML 2.0 フェデレーション用のロールの作成 (コンソール)](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_create_for-idp_saml.html)

### ステップ 2: 認証コードがアタッチされた URL を生成する
<a name="embedded-analytics-gen-bi-authenticated-users-step-2"></a>

以下のセクションでは、ユーザーの認証方法と、アプリケーションサーバー上に埋め込むことができる Q トピック URL の取得方法を説明します。IAM または Amazon Quick Sight アイデンティティタイプの生成 Q&A エクスペリエンスを埋め込む場合は、Q トピックをユーザーと共有します。

ユーザーがアプリケーションにアクセスすると、アプリケーションはユーザーに代わって IAM ロールを引き受けます。次に、そのユーザーがまだ存在しない場合、アプリはユーザーを Amazon Quick Sight に追加します。次に、アプリケーションが一意のロールセッション ID として識別子を渡します。

説明されているステップを実行すると、Q トピックの各ビューワーが Amazon Quick Sight で一意にプロビジョニングされます。行レベルのセキュリティやパラメータの動的デフォルトなど、ユーザーごとの設定も強制されます。タグベースの行レベルセキュリティは、Q バーの匿名ユーザー埋め込みに使用できます。

次の例では、ユーザーに代わって IAM 認証を実行します。このコードはアプリケーションサーバー上で実行されます。

#### Java
<a name="embedded-analytics-gen-bi-authenticated-users-java"></a>

```
import com.amazonaws.auth.AWSCredentials;
import com.amazonaws.auth.BasicAWSCredentials;
import com.amazonaws.auth.AWSCredentialsProvider;
import com.amazonaws.regions.Regions;
import com.amazonaws.services.quicksight.AmazonQuickSight;
import com.amazonaws.services.quicksight.AmazonQuickSightClientBuilder;
import com.amazonaws.services.quicksight.model.GenerateEmbedUrlForRegisteredUserRequest;
import com.amazonaws.services.quicksight.model.GenerateEmbedUrlForRegisteredUserResult;
import com.amazonaws.services.quicksight.model.RegisteredUserEmbeddingExperienceConfiguration;
import com.amazonaws.services.quicksight.model.RegisteredUserGenerativeQnAEmbeddingConfiguration;

/**
 * Class to call QuickSight AWS SDK to get url for embedding Generative Q&A experience.
 */
public class RegisteredUserGenerativeQnAEmbeddingSample {

    private final AmazonQuickSight quickSightClient;

    public RegisteredUserGenerativeQnAEmbeddingSample() {
        this.quickSightClient = AmazonQuickSightClientBuilder
                    .standard()
                    .withRegion(Regions.US_EAST_1.getName())
                    .withCredentials(new AWS CredentialsProvider() {
                            @Override
                            public AWSCredentials getCredentials() {
                                // provide actual IAM access key and secret key here
                                return new BasicAWSCredentials("access-key", "secret-key");
                            }

                            @Override
                            public void refresh() {
                            }
                        }
                    )
                    .build();
            }

    public String getQuicksightEmbedUrl(
            final String accountId, // AWS Account ID
            final String topicId, // Topic ID to embed
            final List<String> allowedDomains, // Runtime allowed domain for embedding
            final String userArn // Registered user arn to use for embedding. Refer to Get Embed Url section in developer portal to find how to get user arn for a QuickSight user.
            ) throws Exception {

        final RegisteredUserEmbeddingExperienceConfiguration experienceConfiguration = new RegisteredUserEmbeddingExperienceConfiguration()
                .withGenerativeQnA(new RegisteredUserGenerativeQnAEmbeddingConfiguration().withInitialTopicId(topicId));
        final GenerateEmbedUrlForRegisteredUserRequest generateEmbedUrlForRegisteredUserRequest = new GenerateEmbedUrlForRegisteredUserRequest();
        generateEmbedUrlForRegisteredUserRequest.setAwsAccountId(accountId);
        generateEmbedUrlForRegisteredUserRequest.setUserArn(userArn);
        generateEmbedUrlForRegisteredUserRequest.setAllowedDomains(allowedDomains);
        generateEmbedUrlForRegisteredUserRequest.setExperienceConfiguration(experienceConfiguration);

        final GenerateEmbedUrlForRegisteredUserResult generateEmbedUrlForRegisteredUserResult = quickSightClient.generateEmbedUrlForRegisteredUser(generateEmbedUrlForRegisteredUserRequest);

        return generateEmbedUrlForRegisteredUserResult.getEmbedUrl();
    }
}
```

#### JavaScript
<a name="embedded-analytics-gen-bi-authenticated-users-js"></a>

**注記**  
埋め込み URL 生成 API は、ブラウザから直接呼び出すことはできません。代わりに Node.JS の例を参照してください。

#### Python3
<a name="embedded-analytics-gen-bi-authenticated-users-py"></a>

```
import json
import boto3
from botocore.exceptions import ClientError

sts = boto3.client('sts')

# Function to generate embedded URL  
# accountId: AWS account ID
# topicId: Topic ID to embed
# userArn: arn of registered user
# allowedDomains: Runtime allowed domain for embedding
# roleArn: IAM user role to use for embedding
# sessionName: session name for the roleArn assume role
def getEmbeddingURL(accountId, topicId, userArn, allowedDomains, roleArn, sessionName):
    try:
        assumedRole = sts.assume_role(
            RoleArn = roleArn,
            RoleSessionName = sessionName,
        )
    except ClientError as e:
        return "Error assuming role: " + str(e)
    else: 
        assumedRoleSession = boto3.Session(
            aws_access_key_id = assumedRole['Credentials']['AccessKeyId'],
            aws_secret_access_key = assumedRole['Credentials']['SecretAccessKey'],
            aws_session_token = assumedRole['Credentials']['SessionToken'],
        )
        try:
            quicksightClient = assumedRoleSession.client('quicksight', region_name='us-west-2')
            response = quicksightClient.generate_embed_url_for_registered_user(
                AwsAccountId=accountId,
                ExperienceConfiguration = {
                    'GenerativeQnA': {
                        'InitialTopicId': topicId
                    }
                },
                UserArn = userArn,
                AllowedDomains = allowedDomains,
                SessionLifetimeInMinutes = 600
            )
            
            return {
                'statusCode': 200,
                'headers': {"Access-Control-Allow-Origin": "*", "Access-Control-Allow-Headers": "Content-Type"},
                'body': json.dumps(response),
                'isBase64Encoded':  bool('false')
            }
        except ClientError as e:
            return "Error generating embedding url: " + str(e)
```

#### Node.js
<a name="embedded-analytics-gen-bi-authenticated-users-node"></a>

次の例は、埋め込みダッシュボードの URL を生成するためにアプリケーションサーバーで使用できる JavaScript (Node.js) を示しています。ダッシュボードを表示するには、ウェブサイトまたはアプリでこの URL を使用します。

**Example**  

```
const AWS = require('aws-sdk');
const https = require('https');

var quicksightClient = new AWS.Service({
    region: 'us-east-1'
});

quicksightClient.generateEmbedUrlForRegisteredUser({
    'AwsAccountId': '111122223333',
    'ExperienceConfiguration': { 
        'GenerativeQnA': {
            'InitialTopicId': 'U4zJMVZ2n2stZflc8Ou3iKySEb3BEV6f'
        }
    },
    'UserArn': 'REGISTERED_USER_ARN',
    'AllowedDomains': allowedDomains,
    'SessionLifetimeInMinutes': 100
}, function(err, data) {
    console.log('Errors: ');
    console.log(err);
    console.log('Response: ');
    console.log(data);
});
```

#### .NET/C\$1
<a name="embedded-analytics-gen-bi-authenticated-users-cs"></a>

以下は、埋め込まれた Q 検索バーの URL を生成するためにアプリケーションサーバーで使用できる .NET/C\$1 コードの例です。ウェブサイトまたはアプリケーションでこの URL を使用して、Q 検索バーを表示することができます。

**Example**  

```
using System;
using Amazon.QuickSight;
using Amazon.QuickSight.Model;

namespace GenerateGenerativeQnAEmbedUrlForRegisteredUser
{
    class Program
    {
        static void Main(string[] args)
        {
            var quicksightClient = new AmazonQuickSightClient(
                AccessKey,
                SecretAccessKey,
                SessionToken,
                Amazon.RegionEndpoint.USEast1);
            try
            {
                RegisteredUserGenerativeQnAEmbeddingConfiguration registeredUserGenerativeQnAEmbeddingConfiguration
                    = new RegisteredUserGenerativeQnAEmbeddingConfiguration
                    {
                        InitialTopicId = "U4zJMVZ2n2stZflc8Ou3iKySEb3BEV6f"
                    };
                RegisteredUserEmbeddingExperienceConfiguration registeredUserEmbeddingExperienceConfiguration
                    = new RegisteredUserEmbeddingExperienceConfiguration
                    {
                        GenerativeQnA = registeredUserGenerativeQnAEmbeddingConfiguration
                    }; 
                
                Console.WriteLine(
                    quicksightClient.GenerateEmbedUrlForRegisteredUserAsync(new GenerateEmbedUrlForRegisteredUserRequest
                    {
                        AwsAccountId = "111122223333",
                        ExperienceConfiguration = registeredUserEmbeddingExperienceConfiguration,
                        UserArn = "REGISTERED_USER_ARN",
                        AllowedDomains = allowedDomains,
                        SessionLifetimeInMinutes = 100
                    }).Result.EmbedUrl
                );
            } catch (Exception ex) {
                Console.WriteLine(ex.Message);
            }
        }
    }
}
```

#### AWS CLI
<a name="embedded-analytics-gen-bi-authenticated-users-cli"></a>

ロールを引き受けるには、次のいずれかの AWS Security Token Service (AWS STS) API オペレーションを選択します。
+ [AssumeRole](https://docs.aws.amazon.com/STS/latest/APIReference/API_AssumeRole.html) – ロールを引き受けるために IAM ID を使用している場合は、このオペレーションを使用します。
+ [AssumeRoleWithWebIdentity](https://docs.aws.amazon.com/STS/latest/APIReference/API_AssumeRoleWithWebIdentity.html) – ユーザーの認証にウェブ ID プロバイダーを使用している場合は、このオペレーションを使用します。
+ [AssumeRoleWithSAML](https://docs.aws.amazon.com/STS/latest/APIReference/API_AssumeRoleWithSAML.html) – ユーザーの認証に SAML を使用している場合は、このオペレーションを使用します。

次の例は、IAM ロールを設定するための CLI コマンドを示しています。ロールでは、`quicksight:GenerateEmbedUrlForRegisteredUser` に対する許可が有効化されている必要があります。ユーザーが Q 検索バーを使用するときにユーザーを追加するジャストインタイムアプローチを取っている場合は、ロールで `quicksight:RegisterUser` に対する許可も有効化されている必要があります。

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

`assume-role` オペレーションは、アクセスキー、シークレットキー、およびセッショントークンの 3 つの出力パラメータを返します。

**注記**  
`AssumeRole` オペレーションを呼び出すときに `ExpiredToken` エラーが発生した場合は、以前の `SESSION TOKEN` がまだ環境変数に残っている可能性があります。以下の変数を設定することで、これをオフにします。  
*AWS\$1ACCESS\$1KEY\$1ID* 
*AWS\$1SECRET\$1ACCESS\$1KEY* 
*AWS\$1SESSION\$1TOKEN* 

次の例は、CLI でこれら 3 つのパラメータを設定する方法を示しています。Microsoft Windows マシンの場合は、`export` の代わりに `set` を使用してください。

```
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_q_search_bar_role/john.doe@example.com` に設定されます。ロールセッション ID は、`role-arn` の役割名と `role-session-name` 値で構成されています。各ユーザーに一意のロールセッション ID を使用すると、各ユーザーに適切なアクセス許可が設定されます。また、ユーザーアクセスのスロットリングが防止されます。*スロットリング*は、同じユーザーが複数の場所から Amazon Quick Sight にアクセスできないようにするセキュリティ機能です。

ロールセッション ID も Amazon Quick Sight のユーザー名になります。このパターンを使用して、Amazon Quick Sight でユーザーを事前にプロビジョニングしたり、Generative Q&A エクスペリエンスに初めてアクセスしたときにユーザーをプロビジョニングしたりできます。

次の例は、ユーザーをプロビジョニングするために使用できる CLI コマンドを示しています。[RegisterUser](https://docs.aws.amazon.com/quicksight/latest/APIReference/API_RegisterUser.html)、[DescribeUser](https://docs.aws.amazon.com/quicksight/latest/APIReference/API_DescribeUser.html)、およびその他の Amazon Quick Sight API オペレーションの詳細については、[Amazon Quick Sight API リファレンス](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_q_generative_qna_role" \
    --user-role READER \
    --user-name jhnd \
    --session-name "john.doe@example.com" \
    --email john.doe@example.com \
    --region us-east-1 \
    --custom-permissions-name TeamA1
```

ユーザーが Microsoft AD を介して認証されている場合、`RegisterUser` を使用してユーザーを設定する必要はありません。代わりに、Amazon Quick Sight に初めてアクセスするときに自動的にサブスクライブする必要があります。Microsoft AD ユーザーの場合は、`DescribeUser` を使用してユーザーの Amazon リソースネーム (ARN) を取得できます。

ユーザーが Amazon Quick Sight に初めてアクセスするときに、ダッシュボードが共有されているグループにこのユーザーを追加することもできます。次の例は、ユーザーをグループに追加するための CLI コマンドを示しています。

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

これで、Amazon Quick Sight のユーザーでもあり、ダッシュボードにアクセスできるアプリのユーザーができました。

最後に、ダッシュボードの署名付き URL を取得するには、アプリケーションサーバーから `generate-embed-url-for-registered-user` を呼び出します。これは埋め込み可能なダッシュボードの URL を返します。次の例は、 AWS Managed Microsoft AD またはシングルサインオン (IAM Identity Center) で認証されたユーザーのサーバー側の呼び出しを使用して、埋め込みダッシュボードの URL を生成する方法を示しています。

```
aws quicksight generate-embed-url-for-anonymous-user \
--aws-account-id 111122223333 \
--namespace default-or-something-else \
--authorized-resource-arns '["topic-arn-topicId1","topic-arn-topicId2"]' \
--allowed-domains '["domain1","domain2"]' \
--experience-configuration 'GenerativeQnA={InitialTopicId="topicId1"}' \
--session-tags '["Key": tag-key-1,"Value": tag-value-1,{"Key": tag-key-1,"Value": tag-value-1}]' \
--session-lifetime-in-minutes 15
```

このオペレーションの使用に関する詳細については、[https://docs.aws.amazon.com/quicksight/latest/APIReference/API_GenerateEmbedUrlForRegisteredUser.html](https://docs.aws.amazon.com/quicksight/latest/APIReference/API_GenerateEmbedUrlForRegisteredUser.html) を参照してください。これと他の API オペレーションは、独自のコードで使用できます。

### ステップ 3: Generative Q&A エクスペリエンス URL を埋め込む
<a name="embedded-analytics-gen-bi-authenticated-users-step-3"></a>

以下のセクションでは、Generative Q&A エクスペリエンス URL をウェブサイトまたはアプリケーションページに埋め込む方法を説明します。これは、[Amazon Quick Sight 埋め込み SDK](https://www.npmjs.com/package/amazon-quicksight-embedding-sdk) (JavaScript) で行います。この SDK を使用することで、以下を実行できます。
+ Generative Q&A エクスペリエンスを HTML ページに配置します。
+ アプリケーションのニーズに合わせて組み込みエクスペリエンスのレイアウトと外観をカスタマイズします。
+ アプリケーションに合わせてカスタマイズされたメッセージでエラー状態を処理します。

アプリケーションに埋め込むことができる URL を生成するには、`GenerateEmbedUrlForRegisteredUser` API オペレーションを呼び出します。この URL は 5 分間有効で、得られたセッションは最大 10 時間有効です。API オペレーションは、シングルサインオンセッションを有効にする `auth_code` 値を伴う URL を提供します。

以下に、`generate-embed-url-for-registered-user` からのレスポンスの例を示します。

```
//The URL returned is over 900 characters. For this example, we've shortened the string for
//readability and added ellipsis to indicate that it's incomplete. 
{
 "Status": "200",
"EmbedUrl": "https://quicksightdomain/embedding/12345/q/search...",
"RequestId": "7bee030e-f191-45c4-97fe-d9faf0e03713"
}
```

[Amazon Quick Sight 埋め込み SDK を使用する](https://www.npmjs.com/package/amazon-quicksight-embedding-sdk)か、この URL を iframe に追加して、生成 Q&A エクスペリエンスをウェブページに埋め込みます。固定の高さと幅の数値 (ピクセル単位) を設定した場合、Amazon Quick Sight はそれらを使用し、ウィンドウのサイズ変更に伴ってビジュアルを変更しません。相対的な高さと幅の割合を設定すると、Amazon Quick Sight はウィンドウサイズの変化に応じて変化するレスポンシブレイアウトを提供します。

埋め込み Generative Q&A エクスペリエンスをホストするドメインが、Amazon Quick Sight サブスクリプションで承認されたドメインのリストである*許可*リストに含まれていることを確認します。この要件は、未承認のドメインが埋め込みダッシュボードをホストしないようにすることでデータを保護します。埋め込み Generative Q&A エクスペリエンス向けのドメインの追加に関する詳細については、「[ドメインの管理](manage-domains.md)」を参照してください。

Amazon Quick Sight Embedding SDK を使用して、埋め込み Generative Q&A エクスペリエンスのレイアウトと外観をアプリケーションに合わせてカスタマイズできます。`panelType` プロパティを使用して、アプリケーションでレンダリングするときに Generative Q&A エクスペリエンスのランディング状態を設定します。`panelType` プロパティを `'FULL'` に設定して、完全な Generative Q&A エクスペリエンスパネルをレンダリングします。このパネルは、Amazon Quick Sight コンソールでの Amazon Quick Sight ユーザーのエクスペリエンスに似ています。パネルのフレーム高さはユーザーインタラクションに基づいて変更さることはなく、 `frameOptions.height` プロパティで設定した値が尊重されます。以下の図は、`panelType` 値を `'FULL'` に設定するとレンダリングされる Generative Q&A エクスペリエンスパネルを示しています。

`panelType` プロパティを `'SEARCH_BAR'` に設定して、Generative Q&A エクスペリエンスを検索バーとしてレンダリングします。この検索バーは、アプリケーションに埋め込まれたときに Q 検索バーがレンダリングする方法に似ています。Generative Q&A 検索バーは、トピック選択オプション、質問提案リスト、回答パネル、またはピンボードを表示する大きなパネルに展開されます。

埋め込みアセットがロードされると、Generative Q&A 検索バーのデフォルトの最小高さが表示されます。`frameOptions.height` 値を `"38px"` に設定して検索バーエクスペリエンスを最適化することをお勧めします。`focusedHeight` プロパティを使用して、トピック選択ドロップダウンと質問提案リストの最適なサイズを設定します。`expandedHeight` プロパティを使用して、回答パネルとピンボードの最適なサイズを設定します。`'SEARCH_BAR'` オプションを選択した場合は、親コンテナのスタイルを位置で設定することをお勧めします。アプリケーション内の不要なコンテンツシフトを避けるには、[絶対] を選択します。以下の図は、`panelType` 値を `'SEARCH_BAR'` に設定したときにレンダリングされる生成 Q&A エクスペリエンス検索バーを示しています。

`panelType` プロパティを設定したら、Amazon Quick Sight 埋め込み SDK を使用して、生成 Q&A エクスペリエンスの次のプロパティをカスタマイズします。
+ Generative Q&A パネルのタイトル (`panelType: FULL` オプションにのみ適用されます)。
+ 検索バーのプレースホルダーテキスト。
+ トピックの選択を許可するかどうか。
+ トピック名を表示するか非表示にするか。
+ Amazon Q アイコンを表示するか非表示にするか (`panelType: FULL` オプションにのみ適用されます)。
+ ピンボードを表示するか非表示にするか。
+ ユーザーが Genertaive Q&A パネルをフルスクリーンに最大化できるかどうか。
+ Generative Q&A パネルのテーマ。カスタムテーマ ARN を SDK に渡して、フレームのコンテンツの外観を変更できます。Amazon Quick Sight スターターテーマは、埋め込み Generative BI パネルではサポートされていません。Amazon Quick Sight スターターテーマを使用するには、Amazon Quick Sight でカスタムテーマとして保存します。

Amazon Quick Sight Embedding SDK を使用すると、ページの生成 Q&A エクスペリエンスは 状態に基づいて動的にサイズ変更されます。Amazon Quick Sight Embedding SDK を使用すると、生成 Q&A エクスペリエンス内のパラメータを制御し、ページロードの完了、状態の変更、エラーに関してコールバックを受信することもできます。

次の例は生成された URL の使用方法を示しています。このコードはアプリケーションサーバー上で生成されます。

#### SDK 2.0
<a name="collapsible-gen-bi-embedding-example"></a>

```
<!DOCTYPE html>
<html>
    <head>
        <title>Generative Q&A Embedding Example</title>
        <script src="https://unpkg.com/amazon-quicksight-embedding-sdk@2.7.0/dist/quicksight-embedding-js-sdk.min.js"></script>
        <script type="text/javascript">
            const embedGenerativeQnA = async() => {    
                const {createEmbeddingContext} = QuickSightEmbedding;

                const embeddingContext = await createEmbeddingContext({
                    onChange: (changeEvent, metadata) => {
                        console.log('Context received a change', changeEvent, metadata);
                    },
                });

                const frameOptions = {
                    url: "<YOUR_EMBED_URL>", // replace this value with the url generated via embedding API
                    container: '#experience-container',
                    height: "700px",
                    width: "1000px",
                    onChange: (changeEvent, metadata) => {
                        switch (changeEvent.eventName) {
                            case 'FRAME_MOUNTED': {
                                console.log("Do something when the experience frame is mounted.");
                                break;
                            }
                            case 'FRAME_LOADED': {
                                console.log("Do something when the experience frame is loaded.");
                                break;
                            }
                        }
                    },
                };

                const contentOptions = {
                    // Optional panel settings. Default behavior is equivalent to {panelType: 'FULL'}
                    panelOptions: {
                        panelType: 'FULL',
                        title: 'custom title', // Optional
                        showQIcon: false, // Optional, Default: true
                    },
                    // Use SEARCH_BAR panel type for the landing state to be similar to embedQSearchBar
                    // with generative capability enabled topics
                    /*
                    panelOptions: {
                        panelType: 'SEARCH_BAR',
                        focusedHeight: '250px',
                        expandedHeight: '500px',
                    },
                    */
                    showTopicName: false, // Optional, Default: true
                    showPinboard: false, // Optional, Default: true
                    allowTopicSelection: false, // Optional, Default: true
                    allowFullscreen: false, // Optional, Default: true
                    searchPlaceholderText: "custom search placeholder", // Optional
                    themeOptions: { // Optional
                        themeArn: 'arn:aws:quicksight:<Region>:<AWS-Account-ID>:theme/<Theme-ID>'
                    }
                    onMessage: async (messageEvent, experienceMetadata) => {
                        switch (messageEvent.eventName) {
                            case 'Q_SEARCH_OPENED': {
                                // called when pinboard is shown / visuals are rendered
                                console.log("Do something when SEARCH_BAR type panel is expanded");
                                break;
                            }
                            case 'Q_SEARCH_FOCUSED': {
                                // called when question suggestions or topic selection dropdown are shown
                                console.log("Do something when SEARCH_BAR type panel is focused");
                                break;
                            }
                            case 'Q_SEARCH_CLOSED': {
                                // called when shrinked to initial bar height
                                console.log("Do something when SEARCH_BAR type panel is collapsed");
                                break;
                            }
                            case 'Q_PANEL_ENTERED_FULLSCREEN': {
                                console.log("Do something when panel enters full screen mode");
                                break;
                            }
                            case 'Q_PANEL_EXITED_FULLSCREEN': {
                                console.log("Do something when panel exits full screen mode");
                                break;
                            }
                            case 'CONTENT_LOADED': {
                                console.log("Do something after experience is loaded");
                                break;
                            }
                            case 'ERROR_OCCURRED': {
                                console.log("Do something when experience fails to load");
                                break;
                            }
                        }
                    }
                };
                const embeddedGenerativeQnExperience = await embeddingContext.embedGenerativeQnA(frameOptions, contentOptions);
            };
        </script>
    </head>

    <body onload="embedGenerativeQnA()">
        <div id="experience-container"></div>
    </body>

</html>
```

この例では、Amazon Quick Sight Embedding SDK を使用して、JavaScript を使用してウェブサイトに埋め込み Generative Q&A エクスペリエンスをロードしてください。コピーを取得するには、次のいずれかを実行します。
+ GitHub から [Amazon Quick Sight 埋め込み SDK](https://github.com/awslabs/amazon-quicksight-embedding-sdk#step-3-create-the-quicksight-session-object) をダウンロードします。このリポジトリは、Amazon Quick Sight 開発者のグループによって管理されます。
+ [https://www.npmjs.com/package/amazon-quicksight-embedding-sdk](https://www.npmjs.com/package/amazon-quicksight-embedding-sdk) から、最新の埋め込み SDK バージョンをダウンロードします。
+ JavaScript の依存関係の `npm` を使用する場合、次のコマンドを実行してダウンロードおよびインストールします。

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

### オプションの組み込み Generative Q&A エクスペリエンス機能
<a name="embedded-analytics-gen-bi-authenticated-users-step-4"></a>

Embedding SDK を使用すると、埋め込み Generative Q&A エクスペリエンスで次のオプション機能を使用できます。

#### Generative Q&A 検索バーアクションを呼び出す
<a name="w2aac35c27c21c43c29b9c21b5"></a>
+ 質問を設定する — この機能は、Generative Q&A エクスペリエンスに質問を送信し、すぐに質問をクエリします。

  ```
  embeddedGenerativeQnExperience.setQuestion('show me monthly revenue');
  ```
+ 回答パネルを閉じる (Generative Q&A 検索バーオプションに適用) — この機能は回答パネルを閉じ、iframe を元の検索バーの状態に戻します。

  ```
  embeddedGenerativeQnExperience.close();
  ```

詳細については、[「Amazon Quick Sight 埋め込み SDK](https://github.com/awslabs/amazon-quicksight-embedding-sdk)」を参照してください。

## 匿名 (未登録) ユーザー向けのクイック生成 Q&A エクスペリエンスに Amazon Q を埋め込む
<a name="embedded-analytics-gen-bi-anonymous-users"></a>


|  | 
| --- |
|    対象者:  Amazon Quick デベロッパー  | 

以下のセクションでは、匿名 (未登録) ユーザー向けの埋め込み Generative Q&A エクスペリエンスをセットアップする方法について詳しく説明します。

**Topics**
+ [

### ステップ 1: 許可をセットアップする
](#embedded-analytics-gen-bi-anonymous-users-step-1)
+ [

### ステップ 2: 認証コードがアタッチされた URL を生成する
](#embedded-analytics-gen-bi-anonymous-users-step-2)
+ [

### ステップ 3: Generative Q&A エクスペリエンス URL を埋め込む
](#embedded-analytics-gen-bi-anonymous-users-step-3)
+ [

### オプションの組み込み Generative Q&A エクスペリエンス機能
](#embedded-analytics-gen-bi-anonymous-users-step-4)

### ステップ 1: 許可をセットアップする
<a name="embedded-analytics-gen-bi-anonymous-users-step-1"></a>

以下のセクションでは、Generative Q&A エクスペリエンスを埋め込むために、バックエンドアプリケーションまたはウェブサーバーのアクセス許可をセットアップする方法を説明します。このタスクには AWS Identity and Access Management 、 (IAM) への管理アクセスが必要です。

Generative Q&A エクスペリエンスにアクセスする各ユーザーは、Amazon Quick Sight のアクセスとアクセス許可を付与するロールを引き受けます。これを可能にするには、 AWS アカウントに IAM ロールを作成します。IAM ポリシーをロールに関連付けて、それを引き受けるすべてのユーザーにアクセス許可を付与します。IAM ロールでは、特定のユーザープールに埋め込み URL を取得するアクセス許可を提供する必要があります。

ワイルドカード文字 *\$1* を使用することにより、特定の名前空間内の全ユーザーに URL を生成する許可を付与できます。または、特定の名前空間内のユーザーのサブセットに URL を生成する許可を付与することもできます。このためには、`quicksight:GenerateEmbedUrlForAnonymousUser` を追加します。

IAM ポリシーで条件を作成し、デベロッパーが `GenerateEmbedUrlForAnonymousUser` API オペレーションの `AllowedDomains` パラメータにリストできるドメインを制限できます。`AllowedDomains` パラメータはオプションのパラメータです。Amazon **Quick Sight の管理**メニューで設定された静的ドメインを上書きし、代わりに生成された URL にアクセスできる最大 3 つのドメインまたはサブドメインを一覧表示するオプションをデベロッパーに付与します。そして、この URL はデベロッパーのウェブサイトに埋め込むことができます。パラメータにリストされているドメインのみが、埋め込み Q 検索バーにアクセスできます。すなわち、この条件を設定していない場合、デベロッパーはインターネット上の任意のドメインを `AllowedDomains` パラメータにリストできてしまいます。

デベロッパーがこのパラメータで使用できるドメインを制限するには、`AllowedEmbeddingDomains` 条件を IAM ポリシーに追加します。`AllowedDomains` パラメータの詳細については、*Amazon Quick Sight API リファレンス*の[GenerateEmbedUrlForAnonymousUser](https://docs.aws.amazon.com//quicksight/latest/APIReference/API_GenerateEmbedUrlForAnonymousUser.html)」を参照してください。

**IAM 条件演算子のセキュリティのベストプラクティス**  
正しく設定されていない IAM 条件演算子は、URL のバリエーションを通じて埋め込み Quick リソースへの不正アクセスを許可できます。IAM ポリシーで `quicksight:AllowedEmbeddingDomains` 条件キーを使用する場合は、特定のドメインを許可するか、特に許可されていないすべてのドメインを拒否する条件演算子を使用します。IAM 条件演算子の詳細については、IAM [ユーザーガイドの「IAM JSON ポリシー要素: 条件演算子](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_elements_condition_operators.html)」を参照してください。  
多くの異なる URL バリエーションが同じリソースを指す場合があります。たとえば、次の URLsはすべて同じコンテンツに解決されます。  
`https://example.com`
`https://example.com/`
`https://Example.com`
ポリシーでこれらの URL バリエーションを考慮しない演算子を使用している場合、攻撃者は同等の URL バリエーションを提供することで制限を回避できます。  
IAM ポリシーが適切な条件演算子を使用してバイパスの脆弱性を防ぎ、目的のドメインのみが埋め込みリソースにアクセスできることを確認する必要があります。

作成したロールへのアクセスを許可するには、アプリケーションの IAM ID に関連付けられた信頼ポリシーが必要です。つまり、ユーザーがアプリケーションにアクセスすると、アプリケーションはユーザーに代わって Generative Q&A エクスペリエンスを開くためのロールを引き受けます。次の例は、サンプルの信頼ポリシーを示しています。

------
#### [ 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 ユーザーガイドの「[Temporary security credentials in IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_temp.html)」(IAM の一時的な認証情報) を参照してください

### ステップ 2: 認証コードがアタッチされた URL を生成する
<a name="embedded-analytics-gen-bi-anonymous-users-step-2"></a>

以下のセクションでは、ユーザーの認証方法と、アプリケーションサーバー上に埋め込むことができる Q トピック URL の取得方法を説明します。

ユーザーがアプリケーションにアクセスすると、アプリケーションはユーザーに代わって IAM ロールを引き受けます。次に、そのユーザーがまだ存在しない場合、アプリはユーザーを Amazon Quick Sight に追加します。次に、アプリケーションが一意のロールセッション ID として識別子を渡します。

#### Java
<a name="embedded-analytics-gen-bi-anonymous-users-java"></a>

```
import java.util.List;
import com.amazonaws.auth.AWSCredentials;
import com.amazonaws.auth.AWSCredentialsProvider;
import com.amazonaws.auth.BasicAWSCredentials;
import com.amazonaws.regions.Regions;
import com.amazonaws.services.quicksight.AmazonQuickSight;
import com.amazonaws.services.quicksight.AmazonQuickSightClientBuilder;
import com.amazonaws.services.quicksight.model.AnonymousUserGenerativeQnAEmbeddingConfiguration;
import com.amazonaws.services.quicksight.model.AnonymousUserEmbeddingExperienceConfiguration;
import com.amazonaws.services.quicksight.model.GenerateEmbedUrlForAnonymousUserRequest;
import com.amazonaws.services.quicksight.model.GenerateEmbedUrlForAnonymousUserResult;
import com.amazonaws.services.quicksight.model.SessionTag;

/**
* Class to call QuickSight AWS SDK to generate embed url for anonymous user.
*/
public class GenerateEmbedUrlForAnonymousUserExample {

    private final AmazonQuickSight quickSightClient;

    public GenerateEmbedUrlForAnonymousUserExample() {
        quickSightClient = AmazonQuickSightClientBuilder
            .standard()
            .withRegion(Regions.US_EAST_1.getName())
            .withCredentials(new AWSCredentialsProvider() {
                    @Override
                    public AWSCredentials getCredentials() {
                        // provide actual IAM access key and secret key here
                        return new BasicAWSCredentials("access-key", "secret-key");
                    }

                    @Override
                    public void refresh() {
                    }
                }
            )
            .build();
    }

    public String GenerateEmbedUrlForAnonymousUser(
        final String accountId, // YOUR AWS ACCOUNT ID
        final String initialTopicId, // Q TOPIC ID TO WHICH THE CONSTRUCTED URL POINTS AND EXPERIENCE PREPOPULATES INITIALLY
        final String namespace, // ANONYMOUS EMBEDDING REQUIRES SPECIFYING A VALID NAMESPACE FOR WHICH YOU WANT THE EMBEDDING URL
        final List<String> authorizedResourceArns, // Q TOPIC ARN LIST TO EMBED
        final List<String> allowedDomains, // RUNTIME ALLOWED DOMAINS FOR EMBEDDING
        final List<SessionTag> sessionTags // SESSION TAGS USED FOR ROW-LEVEL SECURITY
    ) throws Exception {
        AnonymousUserEmbeddingExperienceConfiguration experienceConfiguration = new AnonymousUserEmbeddingExperienceConfiguration();
        AnonymousUserGenerativeQnAEmbeddingConfiguration generativeQnAConfiguration = new AnonymousUserGenerativeQnAEmbeddingConfiguration();
        generativeQnAConfiguration.setInitialTopicId(initialTopicId);
        experienceConfiguration.setGenerativeQnA(generativeQnAConfiguration);

        GenerateEmbedUrlForAnonymousUserRequest generateEmbedUrlForAnonymousUserRequest = new GenerateEmbedUrlForAnonymousUserRequest()
            .withAwsAccountId(accountId)
            .withNamespace(namespace)
            .withAuthorizedResourceArns(authorizedResourceArns)
            .withExperienceConfiguration(experienceConfiguration)
            .withSessionTags(sessionTags)
            .withSessionLifetimeInMinutes(600L); // OPTIONAL: VALUE CAN BE [15-600]. DEFAULT: 600
            .withAllowedDomains(allowedDomains);

        GenerateEmbedUrlForAnonymousUserResult result = quickSightClient.generateEmbedUrlForAnonymousUser(generateEmbedUrlForAnonymousUserRequest);

        return result.getEmbedUrl();
    }

}
```

#### JavaScript
<a name="embedded-analytics-gen-bi-anonymous-users-js"></a>

**注記**  
埋め込み URL 生成 API は、ブラウザから直接呼び出すことはできません。代わりに Node.JS の例を参照してください。

#### Python3
<a name="embedded-analytics-gen-bi-anonymous-users-py"></a>

```
import json
import boto3
from botocore.exceptions import ClientError
import time

# Create QuickSight and STS clients
quicksightClient = boto3.client('quicksight',region_name='us-west-2')
sts = boto3.client('sts')

# Function to generate embedded URL for anonymous user
# accountId: YOUR AWS ACCOUNT ID
# topicId: Topic ID to embed
# quicksightNamespace: VALID NAMESPACE WHERE YOU WANT TO DO NOAUTH EMBEDDING
# authorizedResourceArns: TOPIC ARN LIST TO EMBED
# allowedDomains: RUNTIME ALLOWED DOMAINS FOR EMBEDDING
# sessionTags: SESSION TAGS USED FOR ROW-LEVEL SECURITY
def generateEmbedUrlForAnonymousUser(accountId, quicksightNamespace, authorizedResourceArns, allowedDomains, sessionTags):
    try:
        response = quicksightClient.generate_embed_url_for_anonymous_user(
            AwsAccountId = accountId,
            Namespace = quicksightNamespace,
            AuthorizedResourceArns = authorizedResourceArns,
            AllowedDomains = allowedDomains,
            ExperienceConfiguration = {
                'GenerativeQnA': {
                        'InitialTopicId': topicId
                    }
            },
            SessionTags = sessionTags,
            SessionLifetimeInMinutes = 600
        )
            
        return {
            'statusCode': 200,
            'headers': {"Access-Control-Allow-Origin": "*", "Access-Control-Allow-Headers": "Content-Type"},
            'body': json.dumps(response),
            'isBase64Encoded':  bool('false')
        }
    except ClientError as e:
        print(e)
        return "Error generating embeddedURL: " + str(e)
```

#### Node.js
<a name="embedded-analytics-gen-bi-anonymous-users-node"></a>

次の例は、埋め込みダッシュボードの URL を生成するためにアプリケーションサーバーで使用できる JavaScript (Node.js) を示しています。ダッシュボードを表示するには、ウェブサイトまたはアプリでこの URL を使用します。

**Example**  

```
const AWS = require('aws-sdk');
const https = require('https');

var quicksightClient = new AWS.Service({
    region: 'us-east-1',
});

quicksightClient.generateEmbedUrlForAnonymousUser({
    'AwsAccountId': '111122223333',
    'Namespace': 'DEFAULT'
    'AuthorizedResourceArns': '["topic-arn-topicId1","topic-arn-topicId2"]',
    'AllowedDomains': allowedDomains,
    'ExperienceConfiguration': { 
        'GenerativeQnA': {
            'InitialTopicId': 'U4zJMVZ2n2stZflc8Ou3iKySEb3BEV6f'
        }
    },
    'SessionTags': '["Key": tag-key-1,"Value": tag-value-1,{"Key": tag-key-1,"Value": tag-value-1}]',
    'SessionLifetimeInMinutes': 15
}, function(err, data) {
    console.log('Errors: ');
    console.log(err);
    console.log('Response: ');
    console.log(data);
});
```

#### .NET/C\$1
<a name="embedded-analytics-gen-bi-anonymous-users-cs"></a>

以下は、埋め込まれた Q 検索バーの URL を生成するためにアプリケーションサーバーで使用できる .NET/C\$1 コードの例です。ウェブサイトまたはアプリケーションでこの URL を使用して、Q 検索バーを表示することができます。

**Example**  

```
using System;
using Amazon.QuickSight;
using Amazon.QuickSight.Model;

namespace GenerateGenerativeQnAEmbedUrlForAnonymousUser
{
    class Program
    {
        static void Main(string[] args)
        {
            var quicksightClient = new AmazonQuickSightClient(
                AccessKey,
                SecretAccessKey,
                SessionToken,
                Amazon.RegionEndpoint.USEast1);
            try
            {
                AnonymousUserGenerativeQnAEmbeddingConfiguration anonymousUserGenerativeQnAEmbeddingConfiguration
                    = new AnonymousUserGenerativeQnAEmbeddingConfiguration
                    {
                        InitialTopicId = "U4zJMVZ2n2stZflc8Ou3iKySEb3BEV6f"
                    };
                AnonymousUserEmbeddingExperienceConfiguration anonymousUserEmbeddingExperienceConfiguration
                    = new AnonymousUserEmbeddingExperienceConfiguration
                    {
                        GenerativeQnA = anonymousUserGenerativeQnAEmbeddingConfiguration
                    }; 
                
                Console.WriteLine(
                    quicksightClient.GenerateEmbedUrlForAnonymousUserAsync(new GenerateEmbedUrlForAnonymousUserRequest
                    {
                        AwsAccountId = "111122223333",
                        Namespace = "DEFAULT",
                        AuthorizedResourceArns '["topic-arn-topicId1","topic-arn-topicId2"]',
                        AllowedDomains = allowedDomains,
                        ExperienceConfiguration = anonymousUserEmbeddingExperienceConfiguration,
                        SessionTags = '["Key": tag-key-1,"Value": tag-value-1,{"Key": tag-key-1,"Value": tag-value-1}]',
                        SessionLifetimeInMinutes = 15,
                    }).Result.EmbedUrl
                );
            } catch (Exception ex) {
                Console.WriteLine(ex.Message);
            }
        }
    }
}
```

#### AWS CLI
<a name="embedded-analytics-gen-bi-anonymous-users-cli"></a>

ロールを引き受けるには、次のいずれかの AWS Security Token Service (AWS STS) API オペレーションを選択します。
+ [AssumeRole](https://docs.aws.amazon.com/STS/latest/APIReference/API_AssumeRole.html) – ロールを引き受けるために IAM ID を使用している場合は、このオペレーションを使用します。
+ [AssumeRoleWithWebIdentity](https://docs.aws.amazon.com/STS/latest/APIReference/API_AssumeRoleWithWebIdentity.html) – ユーザーの認証にウェブ ID プロバイダーを使用している場合は、このオペレーションを使用します。
+ [AssumeRoleWithSAML](https://docs.aws.amazon.com/STS/latest/APIReference/API_AssumeRoleWithSAML.html) – ユーザーの認証に SAML を使用している場合は、このオペレーションを使用します。

次の例は、IAM ロールを設定するための CLI コマンドを示しています。ロールは、`quicksight:GenerateEmbedUrlForAnonymousUser` を有効にする許可を取得する必要があります。

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

`assume-role` オペレーションは、アクセスキー、シークレットキー、およびセッショントークンの 3 つの出力パラメータを返します。

**注記**  
`AssumeRole` オペレーションを呼び出すときに `ExpiredToken` エラーが発生した場合は、以前の `SESSION TOKEN` がまだ環境変数に残っている可能性があります。以下の変数を設定することで、これをオフにします。  
*AWS\$1ACCESS\$1KEY\$1ID* 
*AWS\$1SECRET\$1ACCESS\$1KEY* 
*AWS\$1SESSION\$1TOKEN* 

次の例は、CLI でこれら 3 つのパラメータを設定する方法を示しています。Microsoft Windows マシンの場合は、`export` の代わりに `set` を使用してください。

```
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_q_search_bar_role/QuickSightEmbeddingAnonymousPolicy` に設定されます。ロールセッション ID は、`role-arn` の役割名と `role-session-name` 値で構成されています。各ユーザーに一意のロールセッション ID を使用すると、各ユーザーに適切なアクセス許可が設定されます。また、ユーザーアクセスのスロットリングが防止されます。*スロットリング*は、同じユーザーが複数の場所から Amazon Quick Sight にアクセスできないようにするセキュリティ機能です。また、各セッションを別個に保ちます。ロードバランシングなどのウェブサーバーの配列を使用していて、セッションが別のサーバーに再接続されると、新しいセッションが開始されます。

ダッシュボードの署名付き URL を取得するには、アプリケーションサーバーから `generate-embed-url-for-anynymous-user` を呼び出します。これは埋め込み可能なダッシュボードの URL を返します。次の例は、ウェブポータルまたはアプリケーションに匿名で訪問するユーザーのサーバーサイド呼び出しを使用して、埋め込みダッシュボードの URL を生成する方法を説明しています。

```
aws quicksight generate-embed-url-for-anonymous-user \
--aws-account-id 111122223333 \
--namespace default-or-something-else \
--authorized-resource-arns '["topic-arn-topicId","topic-arn-topicId2"]' \
--allowed-domains '["domain1","domain2"]' \
--experience-configuration 'GenerativeQnA={InitialTopicId="topicId1"}' \
--session-tags '["Key": tag-key-1,"Value": tag-value-1,{"Key": tag-key-1,"Value": tag-value-1}]' \
--session-lifetime-in-minutes 15
```

このオペレーションの使用に関する詳細については、[https://docs.aws.amazon.com/quicksight/latest/APIReference/API_GenerateEmbedUrlForAnonymousUser.html](https://docs.aws.amazon.com/quicksight/latest/APIReference/API_GenerateEmbedUrlForAnonymousUser.html) を参照してください。これと他の API オペレーションは、独自のコードで使用できます。

### ステップ 3: Generative Q&A エクスペリエンス URL を埋め込む
<a name="embedded-analytics-gen-bi-anonymous-users-step-3"></a>

以下のセクションでは、Generative Q&A エクスペリエンス URL をウェブサイトまたはアプリケーションページに埋め込む方法を説明します。これは、[Amazon Quick Sight 埋め込み SDK](https://www.npmjs.com/package/amazon-quicksight-embedding-sdk) (JavaScript) で行います。この SDK を使用することで、以下を実行できます。
+ Generative Q&A エクスペリエンスを HTML ページに配置します。
+ アプリケーションのニーズに合わせて組み込みエクスペリエンスのレイアウトと外観をカスタマイズします。
+ アプリケーションに合わせてカスタマイズされたメッセージでエラー状態を処理します。

アプリケーションに埋め込むことができる URL を生成するには、`GenerateEmbedUrlForAnonymousUser` API オペレーションを呼び出します。この URL は 5 分間有効で、得られたセッションは最大 10 時間有効です。API オペレーションは、シングルサインオンセッションを有効にする `auth_code` 値を伴う URL を提供します。

以下に、`generate-embed-url-for-anonymous-user` からのレスポンスの例を示します。

```
//The URL returned is over 900 characters. For this example, we've shortened the string for
//readability and added ellipsis to indicate that it's incomplete.{
     "Status": "200",
     "EmbedUrl": "https://quicksightdomain/embedding/12345/q/search...",
     "RequestId": "7bee030e-f191-45c4-97fe-d9faf0e03713"
}
```

[Amazon Quick Sight 埋め込み SDK を使用して、](https://www.npmjs.com/package/amazon-quicksight-embedding-sdk)またはこの URL を iframe に追加して、Generative Q&A エクスペリエンスをウェブページに埋め込みます。固定の高さと幅の数値 (ピクセル単位) を設定した場合、Amazon Quick Sight はそれらを使用し、ウィンドウのサイズ変更に伴ってビジュアルを変更しません。相対的な高さと幅の割合を設定すると、Amazon Quick Sight はウィンドウサイズの変化に応じて変化するレスポンシブレイアウトを提供します。

Generative Q&A エクスペリエンスをホストするドメインが、Amazon Quick Sight サブスクリプションで承認されたドメインのリストである*許可*リストに含まれていることを確認します。この要件は、未承認のドメインが埋め込み Generative Q&A エクスペリエンスをホストしないようにすることでデータを保護します。埋め込み Generative Q&A エクスペリエンス向けのドメインの追加に関する詳細については、「[ドメインの管理](manage-domains.md)」を参照してください。

Amazon Quick Sight Embedding SDK を使用して、埋め込み Generative Q&A エクスペリエンスのレイアウトと外観をアプリケーションに合わせてカスタマイズできます。`panelType` プロパティを使用して、アプリケーションでレンダリングするときに Generative Q&A エクスペリエンスのランディング状態を設定します。`panelType` プロパティを `'FULL'` に設定して、完全な Generative Q&A エクスペリエンスパネルをレンダリングします。このパネルは、Amazon Quick Sight コンソールでの Amazon Quick Sight ユーザーのエクスペリエンスに似ています。パネルのフレーム高さはユーザーインタラクションに基づいて変更さることはなく、 `frameOptions.height` プロパティで設定した値が尊重されます。以下の図は、`panelType` 値を `'FULL'` に設定するとレンダリングされる Generative Q&A エクスペリエンスパネルを示しています。

`panelType` プロパティを `'SEARCH_BAR'` に設定して、Generative Q&A エクスペリエンスを検索バーとしてレンダリングします。この検索バーは、アプリケーションに埋め込まれたときに Q 検索バーがレンダリングする方法に似ています。Generative Q&A 検索バーは、トピック選択オプション、質問提案リスト、回答パネル、またはピンボードを表示する大きなパネルに展開されます。

埋め込みアセットがロードされると、Generative Q&A 検索バーのデフォルトの最小高さが表示されます。`frameOptions.height` 値を `"38px"` に設定して検索バーエクスペリエンスを最適化することをお勧めします。`focusedHeight` プロパティを使用して、トピック選択ドロップダウンと質問提案リストの最適なサイズを設定します。`expandedHeight` プロパティを使用して、回答パネルとピンボードの最適なサイズを設定します。`'SEARCH_BAR'` オプションを選択した場合は、親コンテナのスタイルを位置で設定することをお勧めします。アプリケーション内の不要なコンテンツシフトを避けるには、[絶対] を選択します。以下の図は、`panelType` 値を `'SEARCH_BAR'` に設定したときにレンダリングされる生成 Q&A エクスペリエンス検索バーを示しています。

`panelType` プロパティを設定したら、Amazon Quick Sight 埋め込み SDK を使用して、生成 Q&A エクスペリエンスの次のプロパティをカスタマイズします。
+ Generative Q&A パネルのタイトル (`panelType: FULL` オプションにのみ適用されます)。
+ 検索バーのプレースホルダーテキスト。
+ トピックの選択を許可するかどうか。
+ トピック名を表示するか非表示にするか。
+ Amazon Q アイコンを表示するか非表示にするか (`panelType: FULL` オプションにのみ適用されます)。
+ ピンボードを表示するか非表示にするか。
+ ユーザーが Genertaive Q&A パネルをフルスクリーンに最大化できるかどうか。
+ Generative Q&A パネルのテーマ。カスタムテーマ ARN を SDK に渡して、フレームのコンテンツの外観を変更できます。Amazon Quick Sight スターターテーマは、埋め込み Generative BI パネルではサポートされていません。Amazon Quick Sight スターターテーマを使用するには、Amazon Quick Sight でカスタムテーマとして保存します。

Amazon Quick Sight Embedding SDK を使用すると、ページの生成 Q&A エクスペリエンスは 状態に基づいて動的にサイズ変更されます。Amazon Quick Sight Embedding SDK を使用すると、生成 Q&A エクスペリエンス内のパラメータを制御し、ページロードの完了、状態の変更、エラーに関してコールバックを受信することもできます。

次の例は生成された URL の使用方法を示しています。このコードはアプリケーションサーバー上で生成されます。

#### SDK 2.0
<a name="embedded-analytics-gen-bi-anonymous-users-sdkv2"></a>

```
<!DOCTYPE html>
<html>
    <head>
        <title>Generative Q&A Embedding Example</title>
        <script src="https://unpkg.com/amazon-quicksight-embedding-sdk@2.7.0/dist/quicksight-embedding-js-sdk.min.js"></script>
        <script type="text/javascript">
            const embedGenerativeQnA = async() => {    
                const {createEmbeddingContext} = QuickSightEmbedding;

                const embeddingContext = await createEmbeddingContext({
                    onChange: (changeEvent, metadata) => {
                        console.log('Context received a change', changeEvent, metadata);
                    },
                });

                const frameOptions = {
                    url: "<YOUR_EMBED_URL>", // replace this value with the url generated via embedding API
                    container: '#experience-container',
                    height: "700px",
                    width: "1000px",
                    onChange: (changeEvent, metadata) => {
                        switch (changeEvent.eventName) {
                            case 'FRAME_MOUNTED': {
                                console.log("Do something when the experience frame is mounted.");
                                break;
                            }
                            case 'FRAME_LOADED': {
                                console.log("Do something when the experience frame is loaded.");
                                break;
                            }
                        }
                    },
                };

                const contentOptions = {
                    // Optional panel settings. Default behavior is equivalent to {panelType: 'FULL'}
                    panelOptions: {
                        panelType: 'FULL',
                        title: 'custom title', // Optional
                        showQIcon: false, // Optional, Default: true
                    },
                    // Use SEARCH_BAR panel type for the landing state to be similar to embedQSearchBar
                    // with generative capability enabled topics
                    /*
                    panelOptions: {
                        panelType: 'SEARCH_BAR',
                        focusedHeight: '250px',
                        expandedHeight: '500px',
                    },
                    */
                    showTopicName: false, // Optional, Default: true
                    showPinboard: false, // Optional, Default: true
                    allowTopicSelection: false, // Optional, Default: true
                    allowFullscreen: false, // Optional, Default: true
                    searchPlaceholderText: "custom search placeholder", // Optional
                    themeOptions: { // Optional
                        themeArn: 'arn:aws:quicksight:<Region>:<AWS-Account-ID>:theme/<Theme-ID>'
                    }
                    onMessage: async (messageEvent, experienceMetadata) => {
                        switch (messageEvent.eventName) {
                            case 'Q_SEARCH_OPENED': {
                                // called when pinboard is shown / visuals are rendered
                                console.log("Do something when SEARCH_BAR type panel is expanded");
                                break;
                            }
                            case 'Q_SEARCH_FOCUSED': {
                                // called when question suggestions or topic selection dropdown are shown
                                console.log("Do something when SEARCH_BAR type panel is focused");
                                break;
                            }
                            case 'Q_SEARCH_CLOSED': {
                                // called when shrinked to initial bar height
                                console.log("Do something when SEARCH_BAR type panel is collapsed");
                                break;
                            }
                            case 'Q_PANEL_ENTERED_FULLSCREEN': {
                                console.log("Do something when panel enters full screen mode");
                                break;
                            }
                            case 'Q_PANEL_EXITED_FULLSCREEN': {
                                console.log("Do something when panel exits full screen mode");
                                break;
                            }
                            case 'CONTENT_LOADED': {
                                console.log("Do something after experience is loaded");
                                break;
                            }
                            case 'ERROR_OCCURRED': {
                                console.log("Do something when experience fails to load");
                                break;
                            }
                        }
                    }
                };
                const embeddedGenerativeQnExperience = await embeddingContext.embedGenerativeQnA(frameOptions, contentOptions);
            };
        </script>
    </head>

    <body onload="embedGenerativeQnA()">
        <div id="experience-container"></div>
    </body>

</html>
```

この例では、Amazon Quick Sight Embedding SDK を使用して、JavaScript を使用してウェブサイトに埋め込み Generative Q&A エクスペリエンスをロードしてください。コピーを取得するには、次のいずれかを実行します。
+ GitHub から [Amazon Quick Sight 埋め込み SDK](https://github.com/awslabs/amazon-quicksight-embedding-sdk#step-3-create-the-quicksight-session-object) をダウンロードします。このリポジトリは、Amazon Quick Sight 開発者のグループによって管理されます。
+ [https://www.npmjs.com/package/amazon-quicksight-embedding-sdk](https://www.npmjs.com/package/amazon-quicksight-embedding-sdk) から、最新の埋め込み SDK バージョンをダウンロードします。
+ JavaScript の依存関係の `npm` を使用する場合、次のコマンドを実行してダウンロードおよびインストールします。

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

### オプションの組み込み Generative Q&A エクスペリエンス機能
<a name="embedded-analytics-gen-bi-anonymous-users-step-4"></a>

Embedding SDK を使用すると、埋め込み Generative Q&A エクスペリエンスで次のオプション機能を使用できます。

#### Generative Q&A 検索バーアクションを呼び出す
<a name="w2aac35c27c21c43c29c13c25b5"></a>
+ 質問を設定する — この機能は、Generative Q&A エクスペリエンスに質問を送信し、すぐに質問をクエリします。

  ```
  embeddedGenerativeQnExperience.setQuestion('show me monthly revenue');
  ```
+ 回答パネルを閉じる (Generative Q&A 検索バーオプションに適用) — この機能は回答パネルを閉じ、iframe を元の検索バーの状態に戻します。

  ```
  embeddedGenerativeQnExperience.close();
  ```

詳細については、[「Amazon Quick Sight 埋め込み SDK](https://github.com/awslabs/amazon-quicksight-embedding-sdk)」を参照してください。

# Amazon Quick Sight Q 検索バーの埋め込み (クラシック)
<a name="embedding-quicksight-q"></a>


|  | 
| --- |
|    対象者:  Amazon Quick デベロッパー  | 

**注記**  
埋め込み Amazon Quick Sight Q 検索バーは、従来の Amazon Quick Sight Q&A エクスペリエンスを提供します。Amazon Quick Sight は Amazon Q Business と統合して、新しい生成 Q&A エクスペリエンスを起動します。デベロッパーは、新しい生成 Q&A エクスペリエンスを使用することをお勧めします。組み込みの生成 Q&A エクスペリエンスの詳細については、[「Amazon Quick Sight の生成 Q&A エクスペリエンスに Amazon Q を埋め込む](https://docs.aws.amazon.com/quicksight/latest/user/embedding-gen-bi.html)」を参照してください。

以下のトピックでは、Amazon Quick Sight APIs を使用した Amazon Quick Sight Q 検索バーの埋め込みについて説明します。

**Topics**
+ [

# 登録済みユーザーの Amazon Quick Sight Q 検索バーの埋め込み
](embedded-analytics-q-search-bar-for-authenticated-users.md)
+ [

# 匿名 (未登録) ユーザー向けの Amazon Quick Sight Q 検索バーの埋め込み
](embedded-analytics-q-search-bar-for-anonymous-users.md)

# 登録済みユーザーの Amazon Quick Sight Q 検索バーの埋め込み
<a name="embedded-analytics-q-search-bar-for-authenticated-users"></a>


|  | 
| --- |
|  適用対象: Enterprise Edition  | 


|  | 
| --- |
|    対象者:  Amazon Quick デベロッパー  | 

**注記**  
埋め込み Amazon Quick Sight Q 検索バーは、従来の Amazon Quick Sight Q&A エクスペリエンスを提供します。Amazon Quick Sight は Amazon Q Business と統合して、新しい生成 Q&A エクスペリエンスを起動します。デベロッパーは、新しい生成 Q&A エクスペリエンスを使用することをお勧めします。埋め込み Generative Q&A エクスペリエンスの詳細については、[「Amazon Quick Sight Generative Q&A エクスペリエンスに Amazon Q を埋め込む](https://docs.aws.amazon.com/quicksight/latest/user/embedding-gen-bi.html)」を参照してください。

以下のセクションでは、Amazon Quick Sight の登録ユーザー用に埋め込み Amazon Quick Sight Q 検索バーを設定する方法について詳しく説明します。

**Topics**
+ [

## ステップ 1: 許可をセットアップする
](#embedded-q-bar-for-authenticated-users-step-1)
+ [

## ステップ 2: 認証コードがアタッチされた URL を生成する
](#embedded-q-bar-for-authenticated-users-step-2)
+ [

## ステップ 3: Q 検索バー URL を埋め込む
](#embedded-q-bar-for-authenticated-users-step-3)
+ [

## オプションの Amazon Quick Sight Q 検索バー埋め込み機能
](#embedded-q-bar-for-authenticated-users-step-4)

## ステップ 1: 許可をセットアップする
<a name="embedded-q-bar-for-authenticated-users-step-1"></a>

**注記**  
埋め込み Amazon Quick Sight Q 検索バーは、従来の Amazon Quick Sight Q&A エクスペリエンスを提供します。Amazon Quick Sight は Amazon Q Business と統合して、新しい生成 Q&A エクスペリエンスを起動します。デベロッパーは、新しい生成 Q&A エクスペリエンスを使用することをお勧めします。埋め込み Generative Q&A エクスペリエンスの詳細については、[「Amazon Quick Sight Generative Q&A エクスペリエンスに Amazon Q を埋め込む](https://docs.aws.amazon.com/quicksight/latest/user/embedding-gen-bi.html)」を参照してください。

以下のセクションでは、Q 検索バーを埋め込むために、バックエンドアプリケーションまたはウェブサーバーの許可をセットアップする方法を説明します。このタスクには AWS Identity and Access Management 、 (IAM) への管理アクセスが必要です。

ダッシュボードにアクセスする各ユーザーは、Amazon Quick Sight にダッシュボードへのアクセスとアクセス許可を付与するロールを引き受けます。これを可能にするには、 で IAM ロールを作成します AWS アカウント。IAM ポリシーをロールに関連付けて、それを引き受けるすべてのユーザーにアクセス許可を付与します。IAM ロールでは、特定のユーザープールに埋め込み URL を取得するアクセス許可を提供する必要があります。

ワイルドカード文字 *\$1* を使用することにより、特定の名前空間内の全ユーザーに URL を生成する許可を付与できます。または、特定の名前空間内のユーザーのサブセットに URL を生成する許可を付与することもできます。このためには、`quicksight:GenerateEmbedUrlForRegisteredUser` を追加します。

IAM ポリシーで条件を作成し、デベロッパーが `GenerateEmbedUrlForRegisteredUser` API オペレーションの `AllowedDomains` パラメータにリストできるドメインを制限できます。`AllowedDomains` パラメータはオプションのパラメータです。Amazon **Quick Sight の管理**メニューで設定された静的ドメインを上書きし、代わりに生成された URL にアクセスできる最大 3 つのドメインまたはサブドメインを一覧表示するオプションをデベロッパーに付与します。そして、この URL はデベロッパーのウェブサイトに埋め込むことができます。パラメータにリストされているドメインのみが、埋め込み Q 検索バーにアクセスできます。すなわち、この条件を設定していない場合、デベロッパーはインターネット上の任意のドメインを `AllowedDomains` パラメータにリストできてしまいます。

デベロッパーがこのパラメータで使用できるドメインを制限するには、`AllowedEmbeddingDomains` 条件を IAM ポリシーに追加します。`AllowedDomains` パラメータの詳細については、*Amazon Quick Sight API リファレンス*の[GenerateEmbedUrlForRegisteredUser](https://docs.aws.amazon.com//quicksight/latest/APIReference/API_GenerateEmbedUrlForRegisteredUser.html)」を参照してください。

**IAM 条件演算子のセキュリティのベストプラクティス**  
正しく設定されていない IAM 条件演算子は、URL のバリエーションを通じて埋め込み Quick リソースへの不正アクセスを許可できます。IAM ポリシーで `quicksight:AllowedEmbeddingDomains` 条件キーを使用する場合は、特定のドメインを許可するか、特に許可されていないすべてのドメインを拒否する条件演算子を使用します。IAM 条件演算子の詳細については、IAM [ユーザーガイドの「IAM JSON ポリシー要素: 条件演算子](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_elements_condition_operators.html)」を参照してください。  
多くの異なる URL バリエーションが同じリソースを指す場合があります。たとえば、次の URLsはすべて同じコンテンツに解決されます。  
`https://example.com`
`https://example.com/`
`https://Example.com`
ポリシーでこれらの URL バリエーションを考慮しない演算子を使用している場合、攻撃者は同等の URL バリエーションを提供することで制限を回避できます。  
IAM ポリシーが適切な条件演算子を使用してバイパスの脆弱性を防ぎ、目的のドメインのみが埋め込みリソースにアクセスできることを確認する必要があります。

次のサンプルポリシーで、これらの権限が付与されます。

また、Amazon Quick Sight リーダーとなる初めてのユーザーを作成する場合は、ポリシーに アクセス`quicksight:RegisterUser`許可を追加してください。

次のサンプルポリシーは、Amazon Quick Sight リーダーになる初めてのユーザーの埋め込み URL を取得するアクセス許可を提供します。

最後に、作成したロールへのアクセスを許可するには、アプリケーションの IAM ID に関連付けられた信頼ポリシーが必要です。つまり、ユーザーがアプリケーションにアクセスすると、アプリケーションはユーザーに代わってロールを引き受け、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 または Security Assertion Markup Language (SAML) 認証の信頼ポリシーに関する詳細については、*IAM ユーザーガイド*の以下のセクションを参照してください。
+ [ウェブ ID または OpenID Connect フェデレーション用のロールの作成 (コンソール)](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_create_for-idp_oidc.html)
+ [SAML 2.0 フェデレーション用のロールの作成 (コンソール)](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_create_for-idp_saml.html)

## ステップ 2: 認証コードがアタッチされた URL を生成する
<a name="embedded-q-bar-for-authenticated-users-step-2"></a>

**注記**  
埋め込み Amazon Quick Sight Q 検索バーは、従来の Amazon Quick Sight Q&A エクスペリエンスを提供します。Amazon Quick Sight は Amazon Q Business と統合して、新しい生成 Q&A エクスペリエンスを起動します。デベロッパーは、新しい生成 Q&A エクスペリエンスを使用することをお勧めします。埋め込み Generative Q&A エクスペリエンスの詳細については、[「Amazon Quick Sight Generative Q&A エクスペリエンスに Amazon Q を埋め込む](https://docs.aws.amazon.com/quicksight/latest/user/embedding-gen-bi.html)」を参照してください。

以下のセクションでは、ユーザーの認証方法と、アプリケーションサーバー上に埋め込むことができる Q トピック URL の取得方法を説明します。IAM または Amazon Quick Sight ID タイプの Q バーを埋め込む場合は、Q トピックをユーザーと共有します。

ユーザーがアプリケーションにアクセスすると、アプリケーションはユーザーに代わって IAM ロールを引き受けます。次に、そのユーザーがまだ存在しない場合、アプリはユーザーを Amazon Quick Sight に追加します。次に、アプリケーションが一意のロールセッション ID として識別子を渡します。

説明されているステップを実行すると、Q トピックの各ビューワーが Amazon Quick Sight で一意にプロビジョニングされます。行レベルのセキュリティやパラメータの動的デフォルトなど、ユーザーごとの設定も強制されます。

次の例では、ユーザーに代わって IAM 認証を実行します。このコードはアプリケーションサーバー上で実行されます。

### Java
<a name="embedded-q-bar-for-embedded-q-bar-for-authenticated-users-java"></a>

```
import com.amazonaws.auth.AWSCredentials;
import com.amazonaws.auth.BasicAWSCredentials;
        import com.amazonaws.auth.AWSCredentialsProvider;
        import com.amazonaws.regions.Regions;
        import com.amazonaws.services.quicksight.AmazonQuickSight;
        import com.amazonaws.services.quicksight.AmazonQuickSightClientBuilder;
import com.amazonaws.services.quicksight.model.GenerateEmbedUrlForRegisteredUserRequest;
import com.amazonaws.services.quicksight.model.GenerateEmbedUrlForRegisteredUserResult;
import com.amazonaws.services.quicksight.model.RegisteredUserEmbeddingExperienceConfiguration;
import com.amazonaws.services.quicksight.model.RegisteredUserQSearchBarEmbeddingConfiguration;

        /**
 * Class to call QuickSight AWS SDK to get url for embedding the Q search bar.
        */
public class RegisteredUserQSearchBarEmbeddingConfiguration {

            private final AmazonQuickSight quickSightClient;

    public RegisteredUserQSearchBarEmbeddingConfiguration() {
        this.quickSightClient = AmazonQuickSightClientBuilder
                    .standard()
                    .withRegion(Regions.US_EAST_1.getName())
                    .withCredentials(new AWSCredentialsProvider() {
                            @Override
                            public AWSCredentials getCredentials() {
                                // provide actual IAM access key and secret key here
                                return new BasicAWSCredentials("access-key", "secret-key");
                            }

                            @Override
                            public void refresh() {
                            }
                        }
                    )
                    .build();
            }

    public String getQuicksightEmbedUrl(
            final String accountId, // AWS Account ID
            final String topicId, // Topic ID to embed
            final List<String> allowedDomains, // Runtime allowed domain for embedding
            final String userArn // Registered user arn to use for embedding. Refer to Get Embed Url section in developer portal to find how to get user arn for a QuickSight user.
            ) throws Exception {
        final RegisteredUserEmbeddingExperienceConfiguration experienceConfiguration = new RegisteredUserEmbeddingExperienceConfiguration()
                .withQSearchBar(new RegisteredUserQSearchBarEmbeddingConfiguration().withInitialTopicId(topicId));
        final GenerateEmbedUrlForRegisteredUserRequest generateEmbedUrlForRegisteredUserRequest = new GenerateEmbedUrlForRegisteredUserRequest();
        generateEmbedUrlForRegisteredUserRequest.setAwsAccountId(accountId);
        generateEmbedUrlForRegisteredUserRequest.setUserArn(userArn);
        generateEmbedUrlForRegisteredUserRequest.setAllowedDomains(allowedDomains);
        generateEmbedUrlForRegisteredUserRequest.setExperienceConfiguration(QSearchBar);

        final GenerateEmbedUrlForRegisteredUserResult generateEmbedUrlForRegisteredUserResult = quickSightClient.generateEmbedUrlForRegisteredUser(generateEmbedUrlForRegisteredUserRequest);

        return generateEmbedUrlForRegisteredUserResult.getEmbedUrl();
            }
        }
```

### JavaScript
<a name="embedded-q-bar-for-embedded-q-bar-for-authenticated-users-js"></a>

```
global.fetch = require('node-fetch');
const AWS = require('aws-sdk');

function generateEmbedUrlForRegisteredUser(
    accountId,
    topicId, // Topic ID to embed
    openIdToken, // Cognito-based token
    userArn, // registered user arn
    roleArn, // IAM user role to use for embedding
    sessionName, // Session name for the roleArn assume role
    allowedDomains, // Runtime allowed domain for embedding
    getEmbedUrlCallback, // GetEmbedUrl success callback method
    errorCallback // GetEmbedUrl error callback method
    ) {
    const stsClient = new AWS.STS();
    let stsParams = {
        RoleSessionName: sessionName,
        WebIdentityToken: openIdToken,
        RoleArn: roleArn
        }
    
    stsClient.assumeRoleWithWebIdentity(stsParams, function(err, data) {
        if (err) {
            console.log('Error assuming role');
            console.log(err, err.stack);
            errorCallback(err);
        } else {
            const getQSearchBarParams = {
        "AwsAccountId": accountId,
                "ExperienceConfiguration": {
                    "QSearchBar": {
                        "InitialTopicId": topicId
                    }
                },
                "UserArn": userArn,
        "AllowedDomains": allowedDomains,
        "SessionLifetimeInMinutes": 600
    };

            const quicksightGetQSearchBar = new AWS.QuickSight({
        region: process.env.AWS_REGION,
                credentials: {
                    accessKeyId: data.Credentials.AccessKeyId,
                    secretAccessKey: data.Credentials.SecretAccessKey,
                    sessionToken: data.Credentials.SessionToken,
                    expiration: data.Credentials.Expiration
                }
    });

            quicksightGetQSearchBar.generateEmbedUrlForRegisteredUser(getQSearchBarParams, function(err, data) {
        if (err) {
            console.log(err, err.stack);
            errorCallback(err);
        } else {
            const result = {
                "statusCode": 200,
                "headers": {
                            "Access-Control-Allow-Origin": "*", // Use your website domain to secure access to GetEmbedUrl API
                    "Access-Control-Allow-Headers": "Content-Type"
                },
                "body": JSON.stringify(data),
                "isBase64Encoded": false
            }
                    getEmbedUrlCallback(result);
                }
            });
        }
    });
}
```

### Python3
<a name="embedded-q-bar-for-embedded-q-bar-for-authenticated-users-python"></a>

```
import json
import boto3
from botocore.exceptions import ClientError

sts = boto3.client('sts')

# Function to generate embedded URL  
# accountId: AWS account ID
# topicId: Topic ID to embed
# userArn: arn of registered user
# allowedDomains: Runtime allowed domain for embedding
# roleArn: IAM user role to use for embedding
# sessionName: session name for the roleArn assume role
def getEmbeddingURL(accountId, topicId, userArn, allowedDomains, roleArn, sessionName):
    try:
        assumedRole = sts.assume_role(
            RoleArn = roleArn,
            RoleSessionName = sessionName,
        )
    except ClientError as e:
        return "Error assuming role: " + str(e)
    else: 
        assumedRoleSession = boto3.Session(
            aws_access_key_id = assumedRole['Credentials']['AccessKeyId'],
            aws_secret_access_key = assumedRole['Credentials']['SecretAccessKey'],
            aws_session_token = assumedRole['Credentials']['SessionToken'],
        )
        try:
            quicksightClient = assumedRoleSession.client('quicksight', region_name='us-west-2')
            response = quicksightClient.generate_embed_url_for_registered_user(
                AwsAccountId=accountId,
                ExperienceConfiguration = {
                    "QSearchBar": {
                        "InitialTopicId": topicId
                    }
                },
                UserArn = userArn,
                AllowedDomains = allowedDomains,
                SessionLifetimeInMinutes = 600
            )
            
            return {
                'statusCode': 200,
                'headers': {"Access-Control-Allow-Origin": "*", "Access-Control-Allow-Headers": "Content-Type"},
                'body': json.dumps(response),
                'isBase64Encoded':  bool('false')
            }
        except ClientError as e:
            return "Error generating embedding url: " + str(e)
```

### Node.js
<a name="embedded-q-bar-for-embedded-q-bar-for-authenticated-users-node"></a>

次の例は、埋め込みダッシュボードの URL を生成するためにアプリケーションサーバーで使用できる JavaScript (Node.js) を示しています。ダッシュボードを表示するには、ウェブサイトまたはアプリでこの URL を使用します。

**Example**  

```
const AWS = require('aws-sdk');
const https = require('https');

var quicksightClient = new AWS.Service({
    apiConfig: require('./quicksight-2018-04-01.min.json'),
    region: 'us-east-1',
});

quicksightClient.generateEmbedUrlForRegisteredUser({
    'AwsAccountId': '111122223333',
    'ExperienceConfiguration': { 
        'QSearchBar': {
            'InitialTopicId': 'U4zJMVZ2n2stZflc8Ou3iKySEb3BEV6f'
        }
    },
    'UserArn': 'REGISTERED_USER_ARN',
    'AllowedDomains': allowedDomains,
    'SessionLifetimeInMinutes': 100
}, function(err, data) {
    console.log('Errors: ');
    console.log(err);
    console.log('Response: ');
    console.log(data);
});
```

**Example**  

```
//The URL returned is over 900 characters. For this example, we've shortened the string for
//readability and added ellipsis to indicate that it's incomplete.
    { 
        Status: 200,
        EmbedUrl: "https://quicksightdomain/embed/12345/dashboards/67890/sheets/12345/visuals/67890...",
        RequestId: '7bee030e-f191-45c4-97fe-d9faf0e03713' 
    }
```

### .NET/C\$1
<a name="embedded-q-bar-for-embedded-q-bar-for-authenticated-users-cs"></a>

以下は、埋め込まれた Q 検索バーの URL を生成するためにアプリケーションサーバーで使用できる .NET/C\$1 コードの例です。ウェブサイトまたはアプリケーションでこの URL を使用して、Q 検索バーを表示することができます。

**Example**  

```
using System;
using Amazon.QuickSight;
using Amazon.QuickSight.Model;

namespace GenerateDashboardEmbedUrlForRegisteredUser
{
    class Program
    {
        static void Main(string[] args)
        {
            var quicksightClient = new AmazonQuickSightClient(
                AccessKey,
                SecretAccessKey,
                SessionToken,
                Amazon.RegionEndpoint.USEast1);
            try
            {
                RegisteredUserQSearchBarEmbeddingConfiguration registeredUserQSearchBarEmbeddingConfiguration
                    = new RegisteredUserQSearchBarEmbeddingConfiguration
                    {
                        InitialTopicId = "U4zJMVZ2n2stZflc8Ou3iKySEb3BEV6f"
                    };
                RegisteredUserEmbeddingExperienceConfiguration registeredUserEmbeddingExperienceConfiguration
                    = new RegisteredUserEmbeddingExperienceConfiguration
                    {
                        QSearchBar = registeredUserQSearchBarEmbeddingConfiguration
                    }; 
                
                Console.WriteLine(
                    quicksightClient.GenerateEmbedUrlForRegisteredUserAsync(new GenerateEmbedUrlForRegisteredUserRequest
                    {
                        AwsAccountId = "111122223333",
                        ExperienceConfiguration = registeredUserEmbeddingExperienceConfiguration,
                        UserArn = "REGISTERED_USER_ARN",
                        AllowedDomains = allowedDomains,
                        SessionLifetimeInMinutes = 100
                    }).Result.EmbedUrl
                );
            } catch (Exception ex) {
                Console.WriteLine(ex.Message);
            }
        }
    }
}
```

### AWS CLI
<a name="embedded-q-bar-for-embedded-q-bar-for-authenticated-users-cli"></a>

ロールを引き受けるには、次のいずれかの AWS Security Token Service (AWS STS) API オペレーションを選択します。
+ [AssumeRole](https://docs.aws.amazon.com/STS/latest/APIReference/API_AssumeRole.html) – ロールを引き受けるために IAM ID を使用している場合は、このオペレーションを使用します。
+ [AssumeRoleWithWebIdentity](https://docs.aws.amazon.com/STS/latest/APIReference/API_AssumeRoleWithWebIdentity.html) – ユーザーの認証にウェブ ID プロバイダーを使用している場合は、このオペレーションを使用します。
+ [AssumeRoleWithSAML](https://docs.aws.amazon.com/STS/latest/APIReference/API_AssumeRoleWithSAML.html) – ユーザーの認証に SAML を使用している場合は、このオペレーションを使用します。

次の例は、IAM ロールを設定するための CLI コマンドを示しています。ロールでは、`quicksight:GenerateEmbedUrlForRegisteredUser` に対する許可が有効化されている必要があります。ユーザーが Q 検索バーを使用するときにユーザーを追加するジャストインタイムアプローチを取っている場合は、ロールで `quicksight:RegisterUser` に対する許可も有効化されている必要があります。

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

`assume-role` オペレーションは、アクセスキー、シークレットキー、およびセッショントークンの 3 つの出力パラメータを返します。

**注記**  
`AssumeRole` オペレーションを呼び出すときに `ExpiredToken` エラーが発生した場合は、以前の `SESSION TOKEN` がまだ環境変数に残っている可能性があります。以下の変数を設定することで、これをオフにします。  
*AWS\$1ACCESS\$1KEY\$1ID* 
*AWS\$1SECRET\$1ACCESS\$1KEY* 
*AWS\$1SESSION\$1TOKEN* 

次の例は、CLI でこれら 3 つのパラメータを設定する方法を示しています。Microsoft Windows マシンの場合は、`export` の代わりに `set` を使用してください。

```
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_q_search_bar_role/john.doe@example.com` に設定されます。ロールセッション ID は、`role-arn` の役割名と `role-session-name` 値で構成されています。各ユーザーに一意のロールセッション ID を使用すると、各ユーザーに適切なアクセス許可が設定されます。また、ユーザーアクセスのスロットリングが防止されます。*スロットリング*は、同じユーザーが複数の場所から Amazon Quick Sight にアクセスできないようにするセキュリティ機能です。

ロールセッション ID も Amazon Quick Sight のユーザー名になります。このパターンを使用して、Amazon Quick Sight でユーザーを事前にプロビジョニングしたり、Q 検索バーに初めてアクセスしたときにプロビジョニングしたりできます。

次の例は、ユーザーをプロビジョニングするために使用できる CLI コマンドを示しています。[RegisterUser](https://docs.aws.amazon.com/quicksight/latest/APIReference/API_RegisterUser.html)、[DescribeUser](https://docs.aws.amazon.com/quicksight/latest/APIReference/API_DescribeUser.html)、およびその他の Amazon Quick Sight API オペレーションの詳細については、[Amazon Quick Sight API リファレンス](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_q_search_bar_role" \
    --user-role READER \
    --user-name jhnd \
    --session-name "john.doe@example.com" \
    --email john.doe@example.com \
    --region us-east-1 \
    --custom-permissions-name TeamA1
```

ユーザーが Microsoft AD を介して認証されている場合、`RegisterUser` を使用してユーザーを設定する必要はありません。代わりに、Amazon Quick Sight に初めてアクセスするときに自動的にサブスクライブする必要があります。Microsoft AD ユーザーの場合は、`DescribeUser` を使用してユーザーの Amazon リソースネーム (ARN) を取得できます。

ユーザーが Amazon Quick Sight に初めてアクセスするときに、ダッシュボードが共有されているグループにこのユーザーを追加することもできます。次の例は、ユーザーをグループに追加するための CLI コマンドを示しています。

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

これで、Amazon Quick Sight のユーザーでもあり、ダッシュボードにアクセスできるアプリのユーザーができました。

最後に、ダッシュボードの署名付き 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 \
--session-lifetime-in-minutes 600 \
--user-arn arn:aws:quicksight:us-east-1:111122223333:user/default/embedding_quicksight_q_search_bar_role/embeddingsession
--allowed-domains '["domain1","domain2"]' \
--experience-configuration QSearchBar={InitialTopicId=U4zJMVZ2n2stZflc8Ou3iKySEb3BEV6f}
```

このオペレーションの使用に関する詳細については、[https://docs.aws.amazon.com/quicksight/latest/APIReference/API_GenerateEmbedUrlForRegisteredUser.html](https://docs.aws.amazon.com/quicksight/latest/APIReference/API_GenerateEmbedUrlForRegisteredUser.html) を参照してください。これと他の API オペレーションは、独自のコードで使用できます。

## ステップ 3: Q 検索バー URL を埋め込む
<a name="embedded-q-bar-for-authenticated-users-step-3"></a>

**注記**  
埋め込み Amazon Quick Sight Q 検索バーは、従来の Amazon Quick Sight Q&A エクスペリエンスを提供します。Amazon Quick Sight は Amazon Q Business と統合して、新しい生成 Q&A エクスペリエンスを起動します。デベロッパーは、新しい生成 Q&A エクスペリエンスを使用することをお勧めします。埋め込み Generative Q&A エクスペリエンスの詳細については、[「Amazon Quick Sight Generative Q&A エクスペリエンスに Amazon Q を埋め込む](https://docs.aws.amazon.com/quicksight/latest/user/embedding-gen-bi.html)」を参照してください。

以下のセクションでは、ステップ 3 からの Q 検索バー URL をウェブサイトまたはアプリケーションページに埋め込む方法を説明します。これは、[Amazon Quick Sight 埋め込み SDK](https://www.npmjs.com/package/amazon-quicksight-embedding-sdk) (JavaScript) で行います。この SDK を使用することで、以下を実行できます。
+ Q 検索バーを HTML ページに設置する。
+ Q 検索バーにパラメータを渡す。
+ アプリケーションに合わせてカスタマイズされたメッセージでエラー状態を処理します。

アプリケーションに埋め込むことができる URL を生成するには、`GenerateEmbedUrlForRegisteredUser` API オペレーションを呼び出します。この URL は 5 分間有効で、得られたセッションは最大 10 時間有効です。API オペレーションは、シングルサインオンセッションを有効にする `auth_code` 値を伴う URL を提供します。

以下に、`generate-embed-url-for-registered-user` からのレスポンスの例を示します。

```
//The URL returned is over 900 characters. For this example, we've shortened the string for
//readability and added ellipsis to indicate that it's incomplete.
{
     "Status": "200",
     "EmbedUrl": "https://quicksightdomain/embedding/12345/q/search...",
     "RequestId": "7bee030e-f191-45c4-97fe-d9faf0e03713"
}
```

[Amazon Quick Sight 埋め込み SDK を使用する](https://www.npmjs.com/package/amazon-quicksight-embedding-sdk)か、この URL を iframe に追加して、ウェブページに Q 検索バーを埋め込みます。固定の高さと幅の数値 (ピクセル単位) を設定した場合、Amazon Quick Sight はそれらを使用し、ウィンドウのサイズ変更に伴ってビジュアルを変更しません。相対的な高さと幅の割合を設定すると、Amazon Quick Sight はウィンドウサイズの変化に応じて変化するレスポンシブレイアウトを提供します。

これを行うには、埋め込み Q 検索バーをホストするドメインが、Amazon Quick Sight サブスクリプションで承認されたドメインのリストである*許可リスト*にあることを確認します。この要件は、未承認のドメインが埋め込みダッシュボードをホストしないようにすることでデータを保護します。埋め込み Q 検索バーのドメインの追加の詳細については、[「ドメインの管理と埋め込み](https://docs.aws.amazon.com/quicksight/latest/user/manage-qs-domains-and-embedding.html)」を参照してください。

Amazon Quick Sight Embedding SDK を使用すると、ページの Q 検索バーは 状態に基づいて動的にサイズ変更されます。Amazon Quick Sight Embedding SDK を使用すると、Q 検索バー内のパラメータを制御し、ページロードの完了とエラーの観点からコールバックを受信することもできます。

次の例は生成された URL の使用方法を示しています。このコードはアプリケーションサーバー上で生成されます。

### SDK 2.0
<a name="embedded-q-bar-for-authenticated-users-sdkv2"></a>

```
<!DOCTYPE html>
<html>

    <head>
        <title>Q Search Bar Embedding Example</title>
        <script src="https://unpkg.com/amazon-quicksight-embedding-sdk@2.0.0/dist/quicksight-embedding-js-sdk.min.js"></script>
        <script type="text/javascript">
            const embedQSearchBar = async() => {    
                const {
                    createEmbeddingContext,
                } = QuickSightEmbedding;

                const embeddingContext = await createEmbeddingContext({
                    onChange: (changeEvent, metadata) => {
                        console.log('Context received a change', changeEvent, metadata);
                    },
                });

                const frameOptions = {
                    url: "<YOUR_EMBED_URL>", // replace this value with the url generated via embedding API
                    container: '#experience-container',
                    height: "700px",
                    width: "1000px",
                    onChange: (changeEvent, metadata) => {
                        switch (changeEvent.eventName) {
                            case 'FRAME_MOUNTED': {
                                console.log("Do something when the experience frame is mounted.");
                                break;
                            }
                            case 'FRAME_LOADED': {
                                console.log("Do something when the experience frame is loaded.");
                                break;
                            }
                        }
                    },
                };

                const contentOptions = {
                    hideTopicName: false, 
                    theme: '<YOUR_THEME_ID>',
                    allowTopicSelection: true,
                    onMessage: async (messageEvent, experienceMetadata) => {
                        switch (messageEvent.eventName) {
                            case 'Q_SEARCH_OPENED': {
                                console.log("Do something when Q Search content expanded");
                                break;
                            }
                            case 'Q_SEARCH_CLOSED': {
                                console.log("Do something when Q Search content collapsed");
                                break;
                            }
                            case 'Q_SEARCH_SIZE_CHANGED': {
                                console.log("Do something when Q Search size changed");
                                break;
                            }
                            case 'CONTENT_LOADED': {
                                console.log("Do something when the Q Search is loaded.");
                                break;
                            }
                            case 'ERROR_OCCURRED': {
                                console.log("Do something when the Q Search fails loading.");
                                break;
                            }
                        }
                    }
                };
                const embeddedDashboardExperience = await embeddingContext.embedQSearchBar(frameOptions, contentOptions);
            };
        </script>
    </head>

    <body onload="embedQSearchBar()">
        <div id="experience-container"></div>
    </body>

</html>
```

### SDK 1.0
<a name="embedded-q-bar-for-authenticated-users-sdkv1"></a>

```
<!DOCTYPE html>
<html>

    <head>
        <title>QuickSight Q Search Bar Embedding</title>
        <script src="https://unpkg.com/amazon-quicksight-embedding-sdk@1.18.0/dist/quicksight-embedding-js-sdk.min.js"></script>
        <script type="text/javascript">
            var session

            function onError(payload) {
                console.log("Do something when the session fails loading");
            }

            function onOpen() {
                console.log("Do something when the Q search bar opens");
            }

            function onClose() {
                console.log("Do something when the Q search bar closes");
            }

            function embedQSearchBar() {
                var containerDiv = document.getElementById("embeddingContainer");
                var options = {
                    url: "https://us-east-1.quicksight.aws.amazon.com/sn/dashboards/dashboardId?isauthcode=true&identityprovider=quicksight&code=authcode", // replace this dummy url with the one generated via embedding API
                    container: containerDiv,
                    width: "1000px",
                    locale: "en-US",
                    qSearchBarOptions: {
                        expandCallback: onOpen,
                        collapseCallback: onClose,
                        iconDisabled: false,
                        topicNameDisabled: false, 
                        themeId: 'bdb844d0-0fe9-4d9d-b520-0fe602d93639',
                        allowTopicSelection: true
                    }
                };
                session = QuickSightEmbedding.embedQSearchBar(options);
                session.on("error", onError);
            }

            function onCountryChange(obj) {
                session.setParameters({country: obj.value});
            }
        </script>
    </head>

    <body onload="embedQSearchBar()">
        <div id="embeddingContainer"></div>
    </body>

</html>
```

この例では、Amazon Quick Sight Embedding SDK を使用して、JavaScript を使用してウェブサイトに埋め込みダッシュボードをロードします。コピーを取得するには、次のいずれかを実行します。
+ GitHub から [Amazon Quick Sight 埋め込み SDK](https://github.com/awslabs/amazon-quicksight-embedding-sdk#step-3-create-the-quicksight-session-object) をダウンロードします。このリポジトリは、Amazon Quick Sight 開発者のグループによって管理されます。
+ [https://www.npmjs.com/package/amazon-quicksight-embedding-sdk](https://www.npmjs.com/package/amazon-quicksight-embedding-sdk) から、最新の埋め込み SDK バージョンをダウンロードします。
+ JavaScript の依存関係の `npm` を使用する場合、次のコマンドを実行してダウンロードおよびインストールします。

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

## オプションの Amazon Quick Sight Q 検索バー埋め込み機能
<a name="embedded-q-bar-for-authenticated-users-step-4"></a>

**注記**  
埋め込み Amazon Quick Sight Q 検索バーは、従来の Amazon Quick Sight Q&A エクスペリエンスを提供します。Amazon Quick Sight は Amazon Q Business と統合して、新しい生成 Q&A エクスペリエンスを起動します。デベロッパーは、新しい生成 Q&A エクスペリエンスを使用することをお勧めします。埋め込み Generative Q&A エクスペリエンスの詳細については、[「Amazon Quick Sight Generative Q&A エクスペリエンスに Amazon Q を埋め込む](https://docs.aws.amazon.com/quicksight/latest/user/embedding-gen-bi.html)」を参照してください。

埋め込み SDK を使用して、埋め込み Q 検索バーで次のオプション機能を使用できます。

### Q 検索バーのアクションを呼び出す
<a name="w2aac35c27c21c43c31c15c21b7"></a>

次のオプションは、Q 検索バーの埋め込みでのみサポートされます。
+ Q 検索バーの質問を設定する — Q 検索バーで質問を送信し、それをすぐにクエリする機能です。この機能では Q ポップオーバーも自動的に開きます。

  ```
  qBar.setQBarQuestion('show me monthly revenue');
  ```
+ Q ポップオーバーを閉じる — Q ポップオーバーを閉じて、iframe を元の Q 検索バーのサイズに戻す機能です。

  ```
  qBar.closeQPopover();
  ```

詳細については、[「Amazon Quick Sight 埋め込み SDK](https://github.com/awslabs/amazon-quicksight-embedding-sdk)」を参照してください。

# 匿名 (未登録) ユーザー向けの Amazon Quick Sight Q 検索バーの埋め込み
<a name="embedded-analytics-q-search-bar-for-anonymous-users"></a>


|  | 
| --- |
|    対象者:  Amazon Quick デベロッパー  | 

**注記**  
埋め込み Amazon Quick Sight Q 検索バーは、従来の Amazon Quick Sight Q&A エクスペリエンスを提供します。Amazon Quick Sight は Amazon Q Business と統合して、新しい生成 Q&A エクスペリエンスを起動します。デベロッパーは、新しい生成 Q&A エクスペリエンスを使用することをお勧めします。埋め込み Generative Q&A エクスペリエンスの詳細については、[「Amazon Quick Sight Generative Q&A エクスペリエンスに Amazon Q を埋め込む](https://docs.aws.amazon.com/quicksight/latest/user/embedding-gen-bi.html)」を参照してください。

以下のセクションでは、匿名 (未登録) ユーザーの埋め込み Amazon Quick Sight Q 検索バーを設定する方法について詳しく説明します。

**Topics**
+ [

## ステップ 1: 許可をセットアップする
](#embedded-q-bar-for-anonymous-users-step-1)
+ [

## ステップ 2: 認証コードがアタッチされた URL を生成する
](#embedded-q-bar-for-anonymous-users-step-2)
+ [

## ステップ 3: Q 検索バー URL を埋め込む
](#embedded-q-bar-for-anonymous-users-step-3)
+ [

## オプションの Amazon Quick Sight Q 検索バー埋め込み機能
](#embedded-q-bar-for-anonymous-users-step-4)

## ステップ 1: 許可をセットアップする
<a name="embedded-q-bar-for-anonymous-users-step-1"></a>

**注記**  
埋め込み Amazon Quick Sight Q 検索バーは、従来の Amazon Quick Sight Q&A エクスペリエンスを提供します。Amazon Quick Sight は Amazon Q Business と統合して、新しい生成 Q&A エクスペリエンスを起動します。デベロッパーは、新しい生成 Q&A エクスペリエンスを使用することをお勧めします。埋め込み Generative Q&A エクスペリエンスの詳細については、[「Amazon Quick Sight Generative Q&A エクスペリエンスに Amazon Q を埋め込む](https://docs.aws.amazon.com/quicksight/latest/user/embedding-gen-bi.html)」を参照してください。

以下のセクションでは、Q 検索バーを埋め込むために、バックエンドアプリケーションまたはウェブサーバーの許可をセットアップする方法を説明します。このタスクには AWS Identity and Access Management 、 (IAM) への管理アクセスが必要です。

Q 検索バーにアクセスする各ユーザーは、Amazon Quick Sight に Q 検索バーへのアクセスとアクセス許可を付与するロールを引き受けます。これを可能にするには、 で IAM ロールを作成します AWS アカウント。IAM ポリシーをロールに関連付けて、それを引き受けるすべてのユーザーにアクセス許可を付与します。IAM ロールでは、特定のユーザープールに埋め込み URL を取得するアクセス許可を提供する必要があります。

ワイルドカード文字 *\$1* を使用することにより、特定の名前空間内の全ユーザーに URL を生成する許可を付与できます。または、特定の名前空間内のユーザーのサブセットに URL を生成する許可を付与することもできます。このためには、`quicksight:GenerateEmbedUrlForAnonymousUser` を追加します。

IAM ポリシーで条件を作成し、デベロッパーが `GenerateEmbedUrlForAnonymousUser` API オペレーションの `AllowedDomains` パラメータにリストできるドメインを制限できます。`AllowedDomains` パラメータはオプションのパラメータです。Amazon **Quick Sight の管理**メニューで設定された静的ドメインを上書きし、代わりに生成された URL にアクセスできる最大 3 つのドメインまたはサブドメインを一覧表示するオプションをデベロッパーに付与します。そして、この URL はデベロッパーのウェブサイトに埋め込むことができます。パラメータにリストされているドメインのみが、埋め込み Q 検索バーにアクセスできます。すなわち、この条件を設定していない場合、デベロッパーはインターネット上の任意のドメインを `AllowedDomains` パラメータにリストできてしまいます。

デベロッパーがこのパラメータで使用できるドメインを制限するには、`AllowedEmbeddingDomains` 条件を IAM ポリシーに追加します。`AllowedDomains` パラメータの詳細については、*Amazon Quick Sight API リファレンス*の[GenerateEmbedUrlForAnonymousUser](https://docs.aws.amazon.com//quicksight/latest/APIReference/API_GenerateEmbedUrlForAnonymousUser.html)」を参照してください。

**IAM 条件演算子のセキュリティのベストプラクティス**  
正しく設定されていない IAM 条件演算子は、URL のバリエーションを通じて埋め込み Quick リソースへの不正アクセスを許可できます。IAM ポリシーで `quicksight:AllowedEmbeddingDomains` 条件キーを使用する場合は、特定のドメインを許可するか、特に許可されていないすべてのドメインを拒否する条件演算子を使用します。IAM 条件演算子の詳細については、IAM [ユーザーガイドの「IAM JSON ポリシー要素: 条件演算子](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_elements_condition_operators.html)」を参照してください。  
多くの異なる URL バリエーションが同じリソースを指す場合があります。たとえば、次の URLsはすべて同じコンテンツに解決されます。  
`https://example.com`
`https://example.com/`
`https://Example.com`
ポリシーでこれらの URL バリエーションを考慮しない演算子を使用している場合、攻撃者は同等の URL バリエーションを提供することで制限を回避できます。  
IAM ポリシーが適切な条件演算子を使用してバイパスの脆弱性を防ぎ、目的のドメインのみが埋め込みリソースにアクセスできることを確認する必要があります。

作成したロールへのアクセスを許可するには、アプリケーションの IAM ID に関連付けられた信頼ポリシーが必要です。つまり、ユーザーがアプリケーションにアクセスすると、アプリケーションはユーザーに代わって Q 検索バーを開くためのロールを引き受けます。次の例は、サンプルの信頼ポリシーを示しています。

------
#### [ 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 ユーザーガイドの「[Temporary security credentials in IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_temp.html)」(IAM の一時的な認証情報) を参照してください

## ステップ 2: 認証コードがアタッチされた URL を生成する
<a name="embedded-q-bar-for-anonymous-users-step-2"></a>

**注記**  
埋め込み Amazon Quick Sight Q 検索バーは、従来の Amazon Quick Sight Q&A エクスペリエンスを提供します。Amazon Quick Sight は Amazon Q Business と統合して、新しい生成 Q&A エクスペリエンスを起動します。デベロッパーは、新しい生成 Q&A エクスペリエンスを使用することをお勧めします。埋め込み Generative Q&A エクスペリエンスの詳細については、[「Amazon Quick Sight Generative Q&A エクスペリエンスに Amazon Q を埋め込む](https://docs.aws.amazon.com/quicksight/latest/user/embedding-gen-bi.html)」を参照してください。

以下のセクションでは、ユーザーの認証方法と、アプリケーションサーバー上に埋め込むことができる Q トピック URL の取得方法を説明します。

ユーザーがアプリケーションにアクセスすると、アプリケーションはユーザーに代わって IAM ロールを引き受けます。その後、そのユーザーがまだ存在しない場合、アプリは Amazon Quick Sight にユーザーを追加します。次に、アプリケーションが一意のロールセッション ID として識別子を渡します。

詳細については、「[https://docs.aws.amazon.com/quicksight/latest/APIReference/AnonymousUserQSearchBarEmbeddingConfiguration.html](https://docs.aws.amazon.com/quicksight/latest/APIReference/AnonymousUserQSearchBarEmbeddingConfiguration.html)」を参照してください。

### Java
<a name="embedded-q-bar-for-anonymous-users-java"></a>

```
        import java.util.List;
        import com.amazonaws.auth.AWSCredentials;
        import com.amazonaws.auth.AWSCredentialsProvider;
        import com.amazonaws.auth.BasicAWSCredentials;
        import com.amazonaws.regions.Regions;
        import com.amazonaws.services.quicksight.AmazonQuickSight;
        import com.amazonaws.services.quicksight.AmazonQuickSightClientBuilder;
        import com.amazonaws.services.quicksight.model.AnonymousUserQSearchBarEmbeddingConfiguration;
        import com.amazonaws.services.quicksight.model.AnonymousUserEmbeddingExperienceConfiguration;
        import com.amazonaws.services.quicksight.model.GenerateEmbedUrlForAnonymousUserRequest;
        import com.amazonaws.services.quicksight.model.GenerateEmbedUrlForAnonymousUserResult;
        import com.amazonaws.services.quicksight.model.SessionTag;


        /**
        * Class to call QuickSight AWS SDK to generate embed url for anonymous user.
        */
        public class GenerateEmbedUrlForAnonymousUserExample {

            private final AmazonQuickSight quickSightClient;

            public GenerateEmbedUrlForAnonymousUserExample() {
                quickSightClient = AmazonQuickSightClientBuilder
                    .standard()
                    .withRegion(Regions.US_EAST_1.getName())
                    .withCredentials(new AWSCredentialsProvider() {
                            @Override
                            public AWSCredentials getCredentials() {
                                // provide actual IAM access key and secret key here
                                return new BasicAWSCredentials("access-key", "secret-key");
                            }

                            @Override
                            public void refresh() {
                            }
                        }
                    )
                    .build();
            }

            public String GenerateEmbedUrlForAnonymousUser(
                final String accountId, // YOUR AWS ACCOUNT ID
                final String initialTopicId, // Q TOPIC ID TO WHICH THE CONSTRUCTED URL POINTS AND SEARCHBAR PREPOPULATES INITIALLY
                final String namespace, // ANONYMOUS EMBEDDING REQUIRES SPECIFYING A VALID NAMESPACE FOR WHICH YOU WANT THE EMBEDDING URL
                final List<String> authorizedResourceArns, // Q SEARCHBAR TOPIC ARN LIST TO EMBED
                final List<String> allowedDomains, // RUNTIME ALLOWED DOMAINS FOR EMBEDDING
                final List<SessionTag> sessionTags // SESSION TAGS USED FOR ROW-LEVEL SECURITY
            ) throws Exception {
                AnonymousUserEmbeddingExperienceConfiguration experienceConfiguration = new AnonymousUserEmbeddingExperienceConfiguration();
                AnonymousUserQSearchBarEmbeddingConfiguration qSearchBarConfiguration = new AnonymousUserQSearchBarEmbeddingConfiguration();
                qSearchBarConfiguration.setInitialTopicId(initialTopicId);
                experienceConfiguration.setQSearchBar(qSearchBarConfiguration);

                GenerateEmbedUrlForAnonymousUserRequest generateEmbedUrlForAnonymousUserRequest = new GenerateEmbedUrlForAnonymousUserRequest()
                    .withAwsAccountId(accountId)
                    .withNamespace(namespace)
                    .withAuthorizedResourceArns(authorizedResourceArns)
                    .withExperienceConfiguration(experienceConfiguration)
                    .withSessionTags(sessionTags)
                    .withSessionLifetimeInMinutes(600L); // OPTIONAL: VALUE CAN BE [15-600]. DEFAULT: 600
                    .withAllowedDomains(allowedDomains);

                GenerateEmbedUrlForAnonymousUserResult qSearchBarEmbedUrl = quickSightClient.generateEmbedUrlForAnonymousUser(generateEmbedUrlForAnonymousUserRequest);

                return qSearchBarEmbedUrl.getEmbedUrl();
            }

        }
```

### JavaScript
<a name="embedded-q-bar-for-anonymous-users-js"></a>

```
global.fetch = require('node-fetch');
const AWS = require('aws-sdk');

function generateEmbedUrlForAnonymousUser(
    accountId, // YOUR AWS ACCOUNT ID
    initialTopicId, // Q TOPIC ID TO WHICH THE CONSTRUCTED URL POINTS
    quicksightNamespace, // VALID NAMESPACE WHERE YOU WANT TO DO NOAUTH EMBEDDING
    authorizedResourceArns, // Q SEARCHBAR TOPIC ARN LIST TO EMBED
    allowedDomains, // RUNTIME ALLOWED DOMAINS FOR EMBEDDING
    sessionTags, // SESSION TAGS USED FOR ROW-LEVEL SECURITY
    generateEmbedUrlForAnonymousUserCallback, // SUCCESS CALLBACK METHOD
    errorCallback // ERROR CALLBACK METHOD
    ) {
    const experienceConfiguration = {
        "QSearchBar": {
            "InitialTopicId": initialTopicId // TOPIC ID CAN BE FOUND IN THE URL ON THE TOPIC AUTHOR PAGE
        }
    };
    
    const generateEmbedUrlForAnonymousUserParams = {
        "AwsAccountId": accountId,
        "Namespace": quicksightNamespace,
        "AuthorizedResourceArns": authorizedResourceArns,
        "AllowedDomains": allowedDomains,
        "ExperienceConfiguration": experienceConfiguration,
        "SessionTags": sessionTags,
        "SessionLifetimeInMinutes": 600
    };

    const quicksightClient = new AWS.QuickSight({
        region: process.env.AWS_REGION,
        credentials: {
            accessKeyId: AccessKeyId,
            secretAccessKey: SecretAccessKey,
            sessionToken: SessionToken,
            expiration: Expiration
        }
    });

    quicksightClient.generateEmbedUrlForAnonymousUser(generateEmbedUrlForAnonymousUserParams, function(err, data) {
        if (err) {
            console.log(err, err.stack);
            errorCallback(err);
        } else {
            const result = {
                "statusCode": 200,
                "headers": {
                    "Access-Control-Allow-Origin": "*", // USE YOUR WEBSITE DOMAIN TO SECURE ACCESS TO THIS API
                    "Access-Control-Allow-Headers": "Content-Type"
                },
                "body": JSON.stringify(data),
                "isBase64Encoded": false
            }
            generateEmbedUrlForAnonymousUserCallback(result);
        }
    });
}
```

### Python3
<a name="embedded-q-bar-for-anonymous-users-py"></a>

```
import json
import boto3
from botocore.exceptions import ClientError
import time

# Create QuickSight and STS clients
quicksightClient = boto3.client('quicksight',region_name='us-west-2')
sts = boto3.client('sts')

# Function to generate embedded URL for anonymous user
# accountId: YOUR AWS ACCOUNT ID
# quicksightNamespace: VALID NAMESPACE WHERE YOU WANT TO DO NOAUTH EMBEDDING
# authorizedResourceArns: TOPIC ARN LIST TO EMBED
# allowedDomains: RUNTIME ALLOWED DOMAINS FOR EMBEDDING
# experienceConfiguration: configuration which specifies the TOPIC ID to point URL to
# sessionTags: SESSION TAGS USED FOR ROW-LEVEL SECURITY
def generateEmbedUrlForAnonymousUser(accountId, quicksightNamespace, authorizedResourceArns, allowedDomains, experienceConfiguration, sessionTags):
    try:
        response = quicksightClient.generate_embed_url_for_anonymous_user(
            AwsAccountId = accountId,
            Namespace = quicksightNamespace,
            AuthorizedResourceArns = authorizedResourceArns,
            AllowedDomains = allowedDomains,
            ExperienceConfiguration = experienceConfiguration,
            SessionTags = sessionTags,
            SessionLifetimeInMinutes = 600
        )
            
        return {
            'statusCode': 200,
            'headers': {"Access-Control-Allow-Origin": "*", "Access-Control-Allow-Headers": "Content-Type"},
            'body': json.dumps(response),
            'isBase64Encoded':  bool('false')
        }
    except ClientError as e:
        print(e)
        return "Error generating embeddedURL: " + str(e)
```

### Node.js
<a name="embedded-q-bar-for-anonymous-users-nodejs"></a>

次の例は、埋め込みダッシュボードの URL を生成するためにアプリケーションサーバーで使用できる JavaScript (Node.js) を示しています。ダッシュボードを表示するには、ウェブサイトまたはアプリでこの URL を使用します。

**Example**  

```
const AWS = require('aws-sdk');
const https = require('https');

var quicksightClient = new AWS.Service({
    apiConfig: require('./quicksight-2018-04-01.min.json'),
    region: 'us-east-1',
});

quicksightClient.generateEmbedUrlForAnonymousUser({
    'AwsAccountId': '111122223333',
    'Namespace': 'DEFAULT'
    'AuthorizedResourceArns': '["topic-arn-topicId1","topic-arn-topicId2"]',
    'AllowedDomains': allowedDomains,
    'ExperienceConfiguration': { 
        'QSearchBar': {
            'InitialTopicId': 'U4zJMVZ2n2stZflc8Ou3iKySEb3BEV6f'
        }
    },
    'SessionTags': '["Key": tag-key-1,"Value": tag-value-1,{"Key": tag-key-1,"Value": tag-value-1}]',
    'SessionLifetimeInMinutes': 15
}, function(err, data) {
    console.log('Errors: ');
    console.log(err);
    console.log('Response: ');
    console.log(data);
});
```

**Example**  

```
//The URL returned is over 900 characters. For this example, we've shortened the string for
//readability and added ellipsis to indicate that it's incomplete.
    { 
        Status: 200,
        EmbedUrl : 'https://quicksightdomain/embed/12345/dashboards/67890/sheets/12345/visuals/67890...',
        RequestId: '7bee030e-f191-45c4-97fe-d9faf0e03713' 
    }
```

### .NET/C\$1
<a name="embedded-q-bar-for-anonymous-users-cs"></a>

以下は、埋め込まれた Q 検索バーの URL を生成するためにアプリケーションサーバーで使用できる .NET/C\$1 コードの例です。ウェブサイトまたはアプリケーションでこの URL を使用して、Q 検索バーを表示することができます。

**Example**  

```
using System;
using Amazon.QuickSight;
using Amazon.QuickSight.Model;

namespace GenerateQSearchBarEmbedUrlForAnonymousUser
{
    class Program
    {
        static void Main(string[] args)
        {
            var quicksightClient = new AmazonQuickSightClient(
                AccessKey,
                SecretAccessKey,
                SessionToken,
                Amazon.RegionEndpoint.USEast1);
            try
            {
                AnonymousUserQSearchBarEmbeddingConfiguration anonymousUserQSearchBarEmbeddingConfiguration
                    = new AnonymousUserQSearchBarEmbeddingConfiguration
                    {
                        InitialTopicId = "U4zJMVZ2n2stZflc8Ou3iKySEb3BEV6f"
                    };
                AnonymousUserEmbeddingExperienceConfiguration anonymousUserEmbeddingExperienceConfiguration
                    = new AnonymousUserEmbeddingExperienceConfiguration
                    {
                        QSearchBar = anonymousUserQSearchBarEmbeddingConfiguration
                    }; 
                
                Console.WriteLine(
                    quicksightClient.GenerateEmbedUrlForAnonymousUserAsync(new GenerateEmbedUrlForAnonymousUserRequest
                    {
                        AwsAccountId = "111122223333",
                        Namespace = "DEFAULT",
                        AuthorizedResourceArns '["topic-arn-topicId1","topic-arn-topicId2"]',
                        AllowedDomains = allowedDomains,
                        ExperienceConfiguration = anonymousUserEmbeddingExperienceConfiguration,
                        SessionTags = '["Key": tag-key-1,"Value": tag-value-1,{"Key": tag-key-1,"Value": tag-value-1}]',
                        SessionLifetimeInMinutes = 15,
                    }).Result.EmbedUrl
                );
            } catch (Exception ex) {
                Console.WriteLine(ex.Message);
            }
        }
    }
}
```

### AWS CLI
<a name="embedded-q-bar-for-anonymous-users-cli"></a>

ロールを引き受けるには、次のいずれかの AWS Security Token Service (AWS STS) API オペレーションを選択します。
+ [AssumeRole](https://docs.aws.amazon.com/STS/latest/APIReference/API_AssumeRole.html) – ロールを引き受けるために IAM ID を使用している場合は、このオペレーションを使用します。
+ [AssumeRoleWithWebIdentity](https://docs.aws.amazon.com/STS/latest/APIReference/API_AssumeRoleWithWebIdentity.html) – ユーザーの認証にウェブ ID プロバイダーを使用している場合は、このオペレーションを使用します。
+ [AssumeRoleWithSAML](https://docs.aws.amazon.com/STS/latest/APIReference/API_AssumeRoleWithSAML.html) – ユーザーの認証に SAML を使用している場合は、このオペレーションを使用します。

次の例は、IAM ロールを設定するための CLI コマンドを示しています。ロールは、`quicksight:GenerateEmbedUrlForAnonymousUser` を有効にする許可を取得する必要があります。

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

`assume-role` オペレーションは、アクセスキー、シークレットキー、およびセッショントークンの 3 つの出力パラメータを返します。

**注記**  
`AssumeRole` オペレーションを呼び出すときに `ExpiredToken` エラーが発生した場合は、以前の `SESSION TOKEN` がまだ環境変数に残っている可能性があります。以下の変数を設定することで、これをオフにします。  
*AWS\$1ACCESS\$1KEY\$1ID* 
*AWS\$1SECRET\$1ACCESS\$1KEY* 
*AWS\$1SESSION\$1TOKEN* 

次の例は、CLI でこれら 3 つのパラメータを設定する方法を示しています。Microsoft Windows マシンの場合は、`export` の代わりに `set` を使用してください。

```
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_q_search_bar_role/QuickSightEmbeddingAnonymousPolicy` に設定されます。ロールセッション ID は、`role-arn` の役割名と `role-session-name` 値で構成されています。各ユーザーに一意のロールセッション ID を使用すると、各ユーザーに適切なアクセス許可が設定されます。また、ユーザーアクセスのスロットリングが防止されます。*スロットリング*は、同じユーザーが複数の場所から Amazon Quick Sight にアクセスできないようにするセキュリティ機能です。また、各セッションを別個に保ちます。ロードバランシングなどのウェブサーバーの配列を使用していて、セッションが別のサーバーに再接続されると、新しいセッションが開始されます。

ダッシュボードの署名付き URL を取得するには、アプリケーションサーバーから `generate-embed-url-for-anynymous-user` を呼び出します。これは埋め込み可能なダッシュボードの URL を返します。次の例は、ウェブポータルまたはアプリケーションに匿名で訪問するユーザーのサーバーサイド呼び出しを使用して、埋め込みダッシュボードの URL を生成する方法を説明しています。

```
aws quicksight generate-embed-url-for-anonymous-user \
--aws-account-id 111122223333 \
--namespace default-or-something-else \
--authorized-resource-arns '["topic-arn-topicId1","topic-arn-topicId2"]' \
--allowed-domains '["domain1","domain2"]' \
--experience-configuration 'QSearchBar={InitialTopicId="topicId1"}' \
--session-tags '["Key": tag-key-1,"Value": tag-value-1,{"Key": tag-key-1,"Value": tag-value-1}]' \
--session-lifetime-in-minutes 15
```

このオペレーションの使用に関する詳細については、[https://docs.aws.amazon.com/quicksight/latest/APIReference/API_GenerateEmbedUrlForRegisteredUser.html](https://docs.aws.amazon.com/quicksight/latest/APIReference/API_GenerateEmbedUrlForRegisteredUser.html) を参照してください。これと他の API オペレーションは、独自のコードで使用できます。

## ステップ 3: Q 検索バー URL を埋め込む
<a name="embedded-q-bar-for-anonymous-users-step-3"></a>

**注記**  
埋め込み Amazon Quick Sight Q 検索バーは、従来の Amazon Quick Sight Q&A エクスペリエンスを提供します。Amazon Quick Sight は Amazon Q Business と統合して、新しい生成 Q&A エクスペリエンスを起動します。デベロッパーは、新しい生成 Q&A エクスペリエンスを使用することをお勧めします。埋め込みの生成 Q&A エクスペリエンスの詳細については、[「Amazon Quick Sight の生成 Q&A エクスペリエンスに Amazon Q を埋め込む](https://docs.aws.amazon.com/quicksight/latest/user/embedding-gen-bi.html)」を参照してください。

以下のセクションでは、ステップ 3 からの Q 検索バー URL をウェブサイトまたはアプリケーションページに埋め込む方法を説明します。これは、[Amazon Quick Sight 埋め込み SDK](https://www.npmjs.com/package/amazon-quicksight-embedding-sdk) (JavaScript) で行います。この SDK を使用することで、以下を実行できます。
+ Q 検索バーを HTML ページに設置する。
+ Q 検索バーにパラメータを渡す。
+ アプリケーションに合わせてカスタマイズされたメッセージでエラー状態を処理します。

アプリケーションに埋め込むことができる URL を生成するには、`GenerateEmbedUrlForAnonymousUser` API オペレーションを呼び出します。この URL は 5 分間有効で、得られたセッションは最大 10 時間有効です。API オペレーションは、シングルサインオンセッションを有効にする `auth_code` 値を伴う URL を提供します。

以下に、`generate-embed-url-for-anonymous-user` からのレスポンスの例を示します。

```
//The URL returned is over 900 characters. For this example, we've shortened the string for
//readability and added ellipsis to indicate that it's incomplete.
{
     "Status": "200",
     "EmbedUrl": "https://quicksightdomain/embedding/12345/q/search...",
     "RequestId": "7bee030e-f191-45c4-97fe-d9faf0e03713"
}
```

[Amazon Quick Sight 埋め込み SDK を使用する](https://www.npmjs.com/package/amazon-quicksight-embedding-sdk)か、この URL を iframe に追加して、ウェブページに Q 検索バーを埋め込みます。固定の高さと幅の数値 (ピクセル単位) を設定した場合、Amazon Quick Sight はそれらを使用し、ウィンドウのサイズ変更に伴ってビジュアルを変更しません。相対的な高さと幅の割合を設定すると、Amazon Quick Sight はウィンドウサイズの変化に応じて変化するレスポンシブレイアウトを提供します。

これを行うには、埋め込み Q 検索バーをホストするドメインが、Amazon Quick Sight サブスクリプションで承認されたドメインのリストである*許可リスト*にあることを確認します。この要件は、未承認のドメインが埋め込み Q 検索バーをホストしないようにすることでデータを保護します。埋め込み Q 検索バーにドメインを追加する方法の詳細については、[「ドメインの管理と埋め込み](https://docs.aws.amazon.com/quicksight/latest/user/manage-qs-domains-and-embedding.html)」を参照してください。

Amazon Quick Sight Embedding SDK を使用すると、ページの Q 検索バーは状態に基づいて動的にサイズ変更されます。Amazon Quick Sight Embedding SDK を使用すると、Q 検索バー内のパラメータを制御し、ページロードの完了とエラーの観点からコールバックを受信することもできます。

次の例は生成された URL の使用方法を示しています。このコードはアプリケーションサーバー上で生成されます。

### SDK 2.0
<a name="embedded-q-bar-for-anonymous-users-sdkv2"></a>

```
<!DOCTYPE html>
<html>

    <head>
        <title>Q Search Bar Embedding Example</title>
        <script src="https://unpkg.com/amazon-quicksight-embedding-sdk@2.0.0/dist/quicksight-embedding-js-sdk.min.js"></script>
        <script type="text/javascript">
            const embedQSearchBar = async() => {    
                const {
                    createEmbeddingContext,
                } = QuickSightEmbedding;

                const embeddingContext = await createEmbeddingContext({
                    onChange: (changeEvent, metadata) => {
                        console.log('Context received a change', changeEvent, metadata);
                    },
                });

                const frameOptions = {
                    url: "<YOUR_EMBED_URL>", // replace this value with the url generated via embedding API
                    container: '#experience-container',
                    height: "700px",
                    width: "1000px",
                    onChange: (changeEvent, metadata) => {
                        switch (changeEvent.eventName) {
                            case 'FRAME_MOUNTED': {
                                console.log("Do something when the experience frame is mounted.");
                                break;
                            }
                            case 'FRAME_LOADED': {
                                console.log("Do something when the experience frame is loaded.");
                                break;
                            }
                        }
                    },
                };

                const contentOptions = {
                    hideTopicName: false, 
                    theme: '<YOUR_THEME_ID>',
                    allowTopicSelection: true,
                    onMessage: async (messageEvent, experienceMetadata) => {
                        switch (messageEvent.eventName) {
                            case 'Q_SEARCH_OPENED': {
                                console.log("Do something when Q Search content expanded");
                                break;
                            }
                            case 'Q_SEARCH_CLOSED': {
                                console.log("Do something when Q Search content collapsed");
                                break;
                            }
                            case 'Q_SEARCH_SIZE_CHANGED': {
                                console.log("Do something when Q Search size changed");
                                break;
                            }
                            case 'CONTENT_LOADED': {
                                console.log("Do something when the Q Search is loaded.");
                                break;
                            }
                            case 'ERROR_OCCURRED': {
                                console.log("Do something when the Q Search fails loading.");
                                break;
                            }
                        }
                    }
                };
                const embeddedDashboardExperience = await embeddingContext.embedQSearchBar(frameOptions, contentOptions);
            };
        </script>
    </head>

    <body onload="embedQSearchBar()">
        <div id="experience-container"></div>
    </body>

</html>
```

### SDK 1.0
<a name="embedded-q-bar-for-anonymous-users-sdkv1"></a>

```
<!DOCTYPE html>
<html>

    <head>
        <title>QuickSight Q Search Bar Embedding</title>
        <script src="https://unpkg.com/amazon-quicksight-embedding-sdk@1.18.0/dist/quicksight-embedding-js-sdk.min.js"></script>
        <script type="text/javascript">
            var session

            function onError(payload) {
                console.log("Do something when the session fails loading");
            }

            function onOpen() {
                console.log("Do something when the Q search bar opens");
            }

            function onClose() {
                console.log("Do something when the Q search bar closes");
            }

            function embedQSearchBar() {
                var containerDiv = document.getElementById("embeddingContainer");
                var options = {
                    url: "https://us-east-1.quicksight.aws.amazon.com/sn/dashboards/dashboardId?isauthcode=true&identityprovider=quicksight&code=authcode", // replace this dummy url with the one generated via embedding API
                    container: containerDiv,
                    width: "1000px",
                    locale: "en-US",
                    qSearchBarOptions: {
                        expandCallback: onOpen,
                        collapseCallback: onClose,
                        iconDisabled: false,
                        topicNameDisabled: false, 
                        themeId: 'bdb844d0-0fe9-4d9d-b520-0fe602d93639',
                        allowTopicSelection: true
                    }
                };
                session = QuickSightEmbedding.embedQSearchBar(options);
                session.on("error", onError);
            }

            function onCountryChange(obj) {
                session.setParameters({country: obj.value});
            }
        </script>
    </head>

    <body onload="embedQSearchBar()">
        <div id="embeddingContainer"></div>
    </body>

</html>
```

この例では、Amazon Quick Sight Embedding SDK を使用して、JavaScript を使用してウェブサイトに埋め込み Q 検索バーをロードします。コピーを取得するには、次のいずれかを実行します。
+ GitHub から [Amazon Quick Sight 埋め込み SDK](https://github.com/awslabs/amazon-quicksight-embedding-sdk#step-3-create-the-quicksight-session-object) をダウンロードします。このリポジトリは、Amazon Quick Sight 開発者のグループによって管理されます。
+ [https://www.npmjs.com/package/amazon-quicksight-embedding-sdk](https://www.npmjs.com/package/amazon-quicksight-embedding-sdk) から、最新の埋め込み SDK バージョンをダウンロードします。
+ JavaScript の依存関係の `npm` を使用する場合、次のコマンドを実行してダウンロードおよびインストールします。

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

## オプションの Amazon Quick Sight Q 検索バー埋め込み機能
<a name="embedded-q-bar-for-anonymous-users-step-4"></a>

**注記**  
埋め込み Amazon Quick Sight Q 検索バーは、従来の Amazon Quick Sight Q&A エクスペリエンスを提供します。Amazon Quick Sight は Amazon Q Business と統合して、新しい生成 Q&A エクスペリエンスを起動します。デベロッパーは、新しい生成 Q&A エクスペリエンスを使用することをお勧めします。埋め込み Generative Q&A エクスペリエンスの詳細については、[「Amazon Quick Sight Generative Q&A エクスペリエンスに Amazon Q を埋め込む](https://docs.aws.amazon.com/quicksight/latest/user/embedding-gen-bi.html)」を参照してください。

埋め込み SDK を使用して、埋め込み Q 検索バーで次のオプション機能を使用できます。

### Q 検索バーのアクションを呼び出す
<a name="w2aac35c27c21c43c31c17c21b7"></a>

次のオプションは、Q 検索バーの埋め込みでのみサポートされます。
+ Q 検索バーの質問を設定する — Q 検索バーで質問を送信し、それをすぐにクエリする機能です。この機能では Q ポップオーバーも自動的に開きます。

  ```
  qBar.setQBarQuestion('show me monthly revenue');
  ```
+ Q ポップオーバーを閉じる — Q ポップオーバーを閉じて、iframe を元の Q 検索バーのサイズに戻す機能です。

  ```
  qBar.closeQPopover();
  ```

詳細については、[「Amazon Quick Sight 埋め込み SDK](https://github.com/awslabs/amazon-quicksight-embedding-sdk)」を参照してください。

# GetDashboardEmbedURL および GetSessionEmbedURL API 操作を使用した分析の埋め込み
<a name="embedded-analytics-deprecated"></a>


|  | 
| --- |
|  適用対象: Enterprise Edition  | 


|  | 
| --- |
|    対象者:  Amazon Quick デベロッパー  | 

Amazon Quick Sight ダッシュボードと Amazon Quick Sight コンソールを埋め込むための次の API オペレーションは、 GenerateEmbedUrlForAnonymousUserおよび GenerateEmbedUrlForRegisteredUser API オペレーションに置き換えられました。引き続きこれらを使用してアプリケーションに分析を埋め込むことはできますが、今後メンテナンスが行われないうえ、最新の埋め込み機能が含まれていません。up-to-date埋め込みエクスペリエンスについては、[「Amazon Quick Sight 分析をアプリケーションに埋め込む」を参照してください。](https://docs.aws.amazon.com/quicksight/latest/user/embedding-overview.html)
+ [GetDashboardEmbedUrl](https://docs.aws.amazon.com/quicksight/latest/APIReference/API_GetDashboardEmbedUrl.html) API オペレーションにより、インタラクティブなダッシュボードを埋め込みます。
+ [GetSessionEmbedUrl](https://docs.aws.amazon.com/quicksight/latest/APIReference/API_GetSessionEmbedUrl.html) API オペレーションは、Amazon Quick Sight コンソールを埋め込みます。

**Topics**
+ [

# GetDashboardEmbedURL (古い API) を使用した全ユーザー向けのダッシュボードの埋め込み
](embedded-analytics-dashboards-with-anonymous-users-get.md)
+ [

# GetDashboardEmbedUrl (古い API) を使用した登録済みユーザー向けのダッシュボードの埋め込み
](embedded-analytics-dashboards-for-authenticated-users-get.md)
+ [

# (GetSessionEmbedUrl古い API) を使用した Amazon Quick Sight コンソールの埋め込み
](embedded-analytics-full-console-for-authenticated-users-get.md)

# GetDashboardEmbedURL (古い API) を使用した全ユーザー向けのダッシュボードの埋め込み
<a name="embedded-analytics-dashboards-with-anonymous-users-get"></a>

**重要**  
Amazon Quick Sight には、分析を埋め込むための新しい APIs として `GenerateEmbedUrlForAnonymousUser`と があります`GenerateEmbedUrlForRegisteredUser`。  
`GetDashboardEmbedUrl` および `GetSessionEmbedUrl` APIs を使用してダッシュボードと Amazon Quick Sight コンソールを埋め込むことはできますが、最新の埋め込み機能は含まれていません。up-to-date埋め込みエクスペリエンスについては、[「Amazon Quick Sight 分析をアプリケーションに埋め込む](https://docs.aws.amazon.com/quicksight/latest/user/embedding-overview.html)」を参照してください。


|  | 
| --- |
|  適用対象: Enterprise Edition  | 


|  | 
| --- |
|    対象者:  Amazon Quick デベロッパー  | 

以下のセクションでは、GetDashboardEmbedURL を使用してすべてのユーザー (認証されていないユーザー) に埋め込み Amazon Quick Sight ダッシュボードを設定する方法について詳しく説明します。

**Topics**
+ [

# ステップ 1: 許可をセットアップする
](embedded-analytics-dashboards-with-anonymous-users-get-step-1.md)
+ [

# ステップ 2: 認証コードがアタッチされた URL を取得する
](embedded-analytics-dashboards-with-anonymous-users-get-step-2.md)
+ [

# ステップ 3: ダッシュボード URL を埋め込む
](embedded-analytics-dashboards-with-anonymous-users-get-step-3.md)

# ステップ 1: 許可をセットアップする
<a name="embedded-analytics-dashboards-with-anonymous-users-get-step-1"></a>

**重要**  
Amazon Quick Sight には、分析を埋め込むための新しい APIs として `GenerateEmbedUrlForAnonymousUser`と があります`GenerateEmbedUrlForRegisteredUser`。  
`GetDashboardEmbedUrl` と `GetSessionEmbedUrl` APIs を使用してダッシュボードと Amazon Quick Sight コンソールを埋め込むことはできますが、最新の埋め込み機能は含まれていません。up-to-date埋め込みエクスペリエンスについては、[「Amazon Quick Sight 分析をアプリケーションに埋め込む](https://docs.aws.amazon.com/quicksight/latest/user/embedding-overview.html)」を参照してください。


|  | 
| --- |
|  適用対象: Enterprise Edition  | 


|  | 
| --- |
|    対象者:  Amazon Quick デベロッパー  | 

次のセクションでは、バックエンドアプリケーションまたはウェブサーバーのアクセス許可を設定する方法について説明します。このタスクには IAM への管理者アクセス権が必要です。

ダッシュボードにアクセスする各ユーザーは、Amazon Quick Sight にダッシュボードへのアクセスとアクセス許可を付与するロールを引き受けます。これを可能にするには、 AWS アカウントに IAM ロールを作成します。IAM ポリシーをロールに関連付けて、それを引き受けるすべてのユーザーにアクセス許可を付与します。

次のサンプルポリシーで、`IdentityType=ANONYMOUS` で使用するこれらの許可が付与されます。このアプローチを機能させるには、 AWS アカウントにセッションパックまたはセッション容量の料金も必要です。これがないと、ユーザーがダッシュボードにアクセスする際に、エラー `UnsupportedPricingPlanException` が返されます。

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

****  

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

------

作成したロールへのアクセスを許可するには、アプリケーションの IAM ID に関連付けられた信頼ポリシーが必要です。つまり、ユーザーがアプリケーションにアクセスすると、アプリケーションはユーザーに代わってロールを引き受け、ダッシュボードを開きます。次の例は、`QuickSightEmbeddingAnonymousPolicy` というロールを示しています。このロールには、リソースとしてサンプルポリシーが先行しています。

信頼ポリシーの詳細については、「IAM ユーザーガイド」の「[IAM の一時的な認証情報](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_temp.html)」を参照してください。

# ステップ 2: 認証コードがアタッチされた URL を取得する
<a name="embedded-analytics-dashboards-with-anonymous-users-get-step-2"></a>

**重要**  
Amazon Quick Sight には、分析を埋め込むための新しい APIs として `GenerateEmbedUrlForAnonymousUser`と があります`GenerateEmbedUrlForRegisteredUser`。  
`GetDashboardEmbedUrl` および `GetSessionEmbedUrl` APIs を使用してダッシュボードと Amazon Quick Sight コンソールを埋め込むことはできますが、最新の埋め込み機能は含まれていません。up-to-date埋め込みエクスペリエンスについては、[「Amazon Quick Sight 分析をアプリケーションに埋め込む](https://docs.aws.amazon.com/quicksight/latest/user/embedding-overview.html)」を参照してください。


|  | 
| --- |
|  適用対象: Enterprise Edition  | 


|  | 
| --- |
|    対象者:  Amazon Quick デベロッパー  | 

次のセクションでは、匿名の訪問者に代わって認証を取得する方法とアプリケーションサーバー上の埋め込みダッシュボードの URL の取得方法について説明します。

ユーザーがアプリケーションにアクセスすると、アプリケーションはユーザーに代わって IAM ロールを引き受けます。次に、そのユーザーがまだ存在しない場合、そのユーザーを Amazon Quick Sight に追加します。次に、一意のロールセッション ID として識別子を渡します。

次の例では、ユーザーに代わって IAM 認証を実行します。一意のロールセッション ID として識別子を渡します。このコードはアプリケーションサーバー上で実行されます。

------
#### [ Java ]

```
import com.amazonaws.auth.AWSCredentials;
import com.amazonaws.auth.BasicAWSCredentials;
import com.amazonaws.auth.AWSCredentialsProvider;
import com.amazonaws.regions.Regions;
import com.amazonaws.services.quicksight.AmazonQuickSight;
import com.amazonaws.services.quicksight.AmazonQuickSightClientBuilder;
import com.amazonaws.services.quicksight.model.GetDashboardEmbedUrlRequest;
import com.amazonaws.services.quicksight.model.GetDashboardEmbedUrlResult;

/**
 * Class to call QuickSight AWS SDK to get url for dashboard embedding.
 */
public class GetQuicksightEmbedUrlNoAuth {

    private static String ANONYMOUS = "ANONYMOUS";

    private final AmazonQuickSight quickSightClient;

    public GetQuicksightEmbedUrlNoAuth() {
        this.quickSightClient = AmazonQuickSightClientBuilder
                .standard()
                .withRegion(Regions.US_EAST_1.getName())
                .withCredentials(new AWSCredentialsProvider() {
                                     @Override
                                     public AWSCredentials getCredentials() {
                                         // provide actual IAM access key and secret key here
                                         return new BasicAWSCredentials("access-key", "secret-key");
                                     }

                                     @Override
                                     public void refresh() {}
                                 }
                )
                .build();
    }

    public String getQuicksightEmbedUrl(
            final String accountId, // YOUR AWS ACCOUNT ID
            final String dashboardId, // YOUR DASHBOARD ID TO EMBED
            final String addtionalDashboardIds, // ADDITIONAL DASHBOARD-1 ADDITIONAL DASHBOARD-2
            final boolean resetDisabled, // OPTIONAL PARAMETER TO ENABLE DISABLE RESET BUTTON IN EMBEDDED DASHBAORD
            final boolean undoRedoDisabled // OPTIONAL PARAMETER TO ENABLE DISABLE UNDO REDO BUTTONS IN EMBEDDED DASHBAORD
    ) throws Exception {
        GetDashboardEmbedUrlRequest getDashboardEmbedUrlRequest = new GetDashboardEmbedUrlRequest()
                .withDashboardId(dashboardId)
                .withAdditionalDashboardIds(addtionalDashboardIds)
                .withAwsAccountId(accountId)
                .withNamespace("default") // Anonymous embedding requires specifying a valid namespace for which you want the embedding url
                .withIdentityType(ANONYMOUS)
                .withResetDisabled(resetDisabled)
                .withUndoRedoDisabled(undoRedoDisabled);

        GetDashboardEmbedUrlResult dashboardEmbedUrl = quickSightClient.getDashboardEmbedUrl(getDashboardEmbedUrlRequest);

        return dashboardEmbedUrl.getEmbedUrl();
    }
}
```

------
#### [ JavaScript ]

```
global.fetch = require('node-fetch');
const AWS = require('aws-sdk');

function getDashboardEmbedURL(
    accountId, // YOUR AWS ACCOUNT ID
    dashboardId, // YOUR DASHBOARD ID TO EMBED
    additionalDashboardIds, // ADDITIONAL DASHBOARD-1 ADDITIONAL DASHBOARD-2
    quicksightNamespace, // VALID NAMESPACE WHERE YOU WANT TO DO NOAUTH EMBEDDING
    resetDisabled, // OPTIONAL PARAMETER TO ENABLE DISABLE RESET BUTTON IN EMBEDDED DASHBAORD
    undoRedoDisabled, // OPTIONAL PARAMETER TO ENABLE DISABLE UNDO REDO BUTTONS IN EMBEDDED DASHBAORD
    getEmbedUrlCallback, // GETEMBEDURL SUCCESS CALLBACK METHOD
    errorCallback // GETEMBEDURL ERROR CALLBACK METHOD
    ) {
    const getDashboardParams = {
        AwsAccountId: accountId,
        DashboardId: dashboardId,
        AdditionalDashboardIds: additionalDashboardIds,
        Namespace: quicksightNamespace,
        IdentityType: 'ANONYMOUS',
        ResetDisabled: resetDisabled,
        SessionLifetimeInMinutes: 600,
        UndoRedoDisabled: undoRedoDisabled
    };

    const quicksightGetDashboard = new AWS.QuickSight({
        region: process.env.AWS_REGION,
    });

    quicksightGetDashboard.getDashboardEmbedUrl(getDashboardParams, function(err, data) {
        if (err) {
            console.log(err, err.stack);
            errorCallback(err);
        } else {
            const result = {
                "statusCode": 200,
                "headers": {
                    "Access-Control-Allow-Origin": "*", // USE YOUR WEBSITE DOMAIN TO SECURE ACCESS TO GETEMBEDURL API
                    "Access-Control-Allow-Headers": "Content-Type"
                },
                "body": JSON.stringify(data),
                "isBase64Encoded": false
            }
            getEmbedUrlCallback(result);
        }
    });
}
```

------
#### [ Python3 ]

```
import json
import boto3
from botocore.exceptions import ClientError
import time

# Create QuickSight and STS clients
qs = boto3.client('quicksight',region_name='us-east-1')
sts = boto3.client('sts')

# Function to generate embedded URL
# accountId: YOUR AWS ACCOUNT ID
# dashboardId: YOUR DASHBOARD ID TO EMBED
# additionalDashboardIds: ADDITIONAL DASHBOARD-1 ADDITIONAL DASHBOARD-2 WITHOUT COMMAS
# quicksightNamespace: VALID NAMESPACE WHERE YOU WANT TO DO NOAUTH EMBEDDING
# resetDisabled: PARAMETER TO ENABLE DISABLE RESET BUTTON IN EMBEDDED DASHBAORD
# undoRedoDisabled: OPTIONAL PARAMETER TO ENABLE DISABLE UNDO REDO BUTTONS IN EMBEDDED DASHBAORD
def getDashboardURL(accountId, dashboardId, quicksightNamespace, resetDisabled, undoRedoDisabled):
    try:
        response = qs.get_dashboard_embed_url(
            AwsAccountId = accountId,
            DashboardId = dashboardId,
            AdditionalDashboardIds = additionalDashboardIds,
            Namespace = quicksightNamespace,
            IdentityType = 'ANONYMOUS',
            SessionLifetimeInMinutes = 600,
            UndoRedoDisabled = undoRedoDisabled,
            ResetDisabled = resetDisabled
        )
            
        return {
            'statusCode': 200,
            'headers': {"Access-Control-Allow-Origin": "*", "Access-Control-Allow-Headers": "Content-Type"},
            'body': json.dumps(response),
            'isBase64Encoded':  bool('false')
        }
    except ClientError as e:
        print(e)
        return "Error generating embeddedURL: " + str(e)
```

------
#### [ Node.js ]

次の例は、埋め込みダッシュボードの URL を取得するためにアプリサーバーで使用できるJavaScript (Node.js) を示しています。ダッシュボードを表示するには、ウェブサイトまたはアプリでこの URL を使用します。

**Example**  

```
const AWS = require('aws-sdk');
            const https = require('https');
            
            var quicksight = new AWS.Service({
                apiConfig: require('./quicksight-2018-04-01.min.json'),
                region: 'us-east-1',
            });
            
            quicksight.getDashboardEmbedUrl({
                'AwsAccountId': '111122223333',
                'DashboardId': 'dashboard-id',
                'AdditionalDashboardIds': 'added-dashboard-id-1 added-dashboard-id-2 added-dashboard-id-3'
                'Namespace' : 'default',
                'IdentityType': 'ANONYMOUS',
                'SessionLifetimeInMinutes': 100,
                'UndoRedoDisabled': false,
                'ResetDisabled': true
            
            }, function(err, data) {
                console.log('Errors: ');
                console.log(err);
                console.log('Response: ');
                console.log(data);
            });
```

**Example**  

```
//The URL returned is over 900 characters. For this example, we've shortened the string for
            //readability and added ellipsis to indicate that it's incomplete.
                                { Status: 200,
              EmbedUrl: 'https://dashboards.example.com/embed/620bef10822743fab329fb3751187d2d…
              RequestId: '7bee030e-f191-45c4-97fe-d9faf0e03713' }
```

------
#### [ .NET/C\$1 ]

次の例は、埋め込みダッシュボードの URL を取得するためにアプリケーションサーバーで使用できる .NET/C\$1 コードを示しています。ダッシュボードを表示するには、ウェブサイトまたはアプリでこの URL を使用します。

**Example**  

```
            var client = new AmazonQuickSightClient(
                AccessKey,
                SecretAccessKey,
                sessionToken,
                Amazon.RegionEndpoint.USEast1);
            try
            {
                Console.WriteLine(
                    client.GetDashboardEmbedUrlAsync(new GetDashboardEmbedUrlRequest
                    {
                        AwsAccountId = “111122223333”,
                        DashboardId = "dashboard-id",
                        AdditionalDashboardIds = "added-dashboard-id-1 added-dashboard-id-2 added-dashboard-id-3",
                        Namespace = default,
                        IdentityType = IdentityType.ANONYMOUS,
                        SessionLifetimeInMinutes = 600,
                        UndoRedoDisabled = false,
                        ResetDisabled = true
                    }).Result.EmbedUrl
                );
            } catch (Exception ex) {
                Console.WriteLine(ex.Message);
            }
```

------
#### [ AWS CLI ]

ロールを引き受けるには、次のいずれかの AWS Security Token Service (AWS STS) API オペレーションを選択します。
+ [AssumeRole](https://docs.aws.amazon.com/STS/latest/APIReference/API_AssumeRole.html) – ロールを引き受けるために IAM ID を使用している場合は、このオペレーションを使用します。
+ [AssumeRoleWithWebIdentity](https://docs.aws.amazon.com/STS/latest/APIReference/API_AssumeRoleWithWebIdentity.html) – ユーザーの認証にウェブ ID プロバイダーを使用している場合は、このオペレーションを使用します。
+ [AssumeRoleWithSAML](https://docs.aws.amazon.com/STS/latest/APIReference/API_AssumeRoleWithSAML.html) — ユーザーの認証に Security Assertion Markup Language (SAML) を使用している場合は、このオペレーションを使用します。

次の例は、IAM ロールを設定するための CLI コマンドを示しています。ロールは、`quicksight:GetDashboardEmbedURL` を有効にする許可を取得する必要があります。

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

`assume-role` オペレーションは、アクセスキー、シークレットキー、およびセッショントークンの 3 つの出力パラメータを返します。

**注記**  
`AssumeRole` オペレーションを呼び出すときに `ExpiredToken` エラーが発生した場合は、以前の `SESSION TOKEN` がまだ環境変数に残っている可能性があります。以下の変数を設定することで、これをオフにします。  
*AWS\$1ACCESS\$1KEY\$1ID* 
*AWS\$1SECRET\$1ACCESS\$1KEY* 
*AWS\$1SESSION\$1TOKEN* 

次の例は、CLI でこれら 3 つのパラメータを設定する方法を示しています。Microsoft Windows マシンを使用している場合は、`export` の代わりに `set` を使用します。

```
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 を使用すると、各訪問ユーザーに適切なアクセス許可が設定されます。また、各セッションを別個に保ちます。ロードバランシングなどのウェブサーバーの配列を使用していて、セッションが別のサーバーに再接続されると、新しいセッションが開始されます。

ダッシュボードの署名付き URL を取得するには、アプリケーションサーバーから `get-dashboard-embed-url` を呼び出します。これは埋め込み可能なダッシュボードの URL を返します。次の例は ウェブポータルまたはアプリケーションに匿名で訪問するユーザーのサーバーサイド呼び出しを使用して、埋め込みダッシュボードの URL を取得する方法を説明しています。

```
aws quicksight get-dashboard-embed-url \
     --aws-account-id 111122223333 \
     --dashboard-id dashboard-id \
     --additional-dashboard-ids added-dashboard-id-1 added-dashboard-id-2 added-dashboard-id-3
     --namespace default-or-something-else \
     --identity-type ANONYMOUS \
     --session-lifetime-in-minutes 30 \
     --undo-redo-disabled true \
     --reset-disabled true \
     --user-arn arn:aws:quicksight:us-east-1:111122223333:user/default/QuickSightEmbeddingAnonymousPolicy/embeddingsession
```

このオペレーションの使用に関する詳細については、[https://docs.aws.amazon.com/quicksight/latest/APIReference/API_GetDashboardEmbedUrl.html](https://docs.aws.amazon.com/quicksight/latest/APIReference/API_GetDashboardEmbedUrl.html) を参照してください。これと他の API オペレーションは、独自のコードで使用できます。

------

# ステップ 3: ダッシュボード URL を埋め込む
<a name="embedded-analytics-dashboards-with-anonymous-users-get-step-3"></a>

**重要**  
Amazon Quick Sight には、分析を埋め込むための新しい APIs として `GenerateEmbedUrlForAnonymousUser`と があります`GenerateEmbedUrlForRegisteredUser`。  
`GetDashboardEmbedUrl` および `GetSessionEmbedUrl` APIs を使用してダッシュボードと Amazon Quick Sight コンソールを埋め込むことはできますが、最新の埋め込み機能は含まれていません。up-to-date埋め込みエクスペリエンスについては、[「Amazon Quick Sight 分析をアプリケーションに埋め込む](https://docs.aws.amazon.com/quicksight/latest/user/embedding-overview.html)」を参照してください。


|  | 
| --- |
|  適用対象: Enterprise Edition  | 


|  | 
| --- |
|    対象者:  Amazon Quick デベロッパー  | 

次のセクションでは、[Amazon Quick Sight 埋め込み SDK](https://www.npmjs.com/package/amazon-quicksight-embedding-sdk) (JavaScript) を使用して、ステップ 2 のダッシュボード URL をウェブサイトまたはアプリケーションページに埋め込む方法について説明します。SDK を使用すると、次のことを実行できます。
+ ダッシュボードを HTML ページに配置します。
+ ダッシュボードにパラメータを渡します。
+ アプリケーションに合わせてカスタマイズされたメッセージでエラー状態を処理します。

`GetDashboardEmbedUrl` API オペレーションを呼び出して URL を取得し、アプリケーションに埋め込みます。この URL は 5 分間有効で、得られたセッションは 10 時間有効です。API オペレーションは、シングルサインオンセッションを有効にする `auth_code` の URL を提供します。

以下に、`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"
}
```

Amazon Quick Sight [Embedding SDK を使用する](https://www.npmjs.com/package/amazon-quicksight-embedding-sdk)か、この URL を iframe に追加して、このダッシュボードをウェブページに埋め込みます。固定の高さと幅の数値 (ピクセル単位) を設定した場合、Amazon Quick Sight はそれらを使用し、ウィンドウのサイズ変更に伴ってビジュアルを変更しません。相対的な高さと幅の割合を設定すると、Amazon Quick Sight はウィンドウサイズの変化に応じて変化するレスポンシブレイアウトを提供します。Amazon Quick Sight Embedding SDK を使用すると、ダッシュボード内のパラメータを制御し、ページロードの完了とエラーの観点からコールバックを受信することもできます。

次の例は生成された URL の使用方法を示しています。このコードはアプリケーションサーバーにあります。

```
<!DOCTYPE html>
<html>

<head>
    <title>Basic Embed</title>
    <!-- You can download the latest QuickSight embedding SDK version from https://www.npmjs.com/package/amazon-quicksight-embedding-sdk -->
    <!-- Or you can do "npm install amazon-quicksight-embedding-sdk", if you use npm for javascript dependencies -->
    <script src="./quicksight-embedding-js-sdk.min.js"></script>
    <script type="text/javascript">
        var dashboard;

        function embedDashboard() {
            var containerDiv = document.getElementById("embeddingContainer");
            var options = {
                // replace this dummy url with the one generated via embedding API
                url: "https://us-east-1.quicksight.aws.amazon.com/sn/dashboards/dashboardId?isauthcode=true&identityprovider=quicksight&code=authcode",  
                container: containerDiv,
                scrolling: "no",
                height: "700px",
                width: "1000px",
                footerPaddingEnabled: true
            };
            dashboard = QuickSightEmbedding.embedDashboard(options);
        }
    </script>
</head>

<body onload="embedDashboard()">
    <div id="embeddingContainer"></div>
</body>

</html>
```

この例では、Amazon Quick Sight Embedding SDK を使用して、JavaScript を使用してウェブサイトに埋め込みダッシュボードをロードします。コピーを取得するには、次のいずれかを実行します。
+ GitHub から [Amazon Quick Sight 埋め込み SDK](https://github.com/awslabs/amazon-quicksight-embedding-sdk#step-3-create-the-quicksight-session-object) をダウンロードします。このリポジトリは、Amazon Quick Sight 開発者のグループによって管理されます。
+ [https://www.npmjs.com/package/amazon-quicksight-embedding-sdk](https://www.npmjs.com/package/amazon-quicksight-embedding-sdk) から最新の QuickSight Embedding SDK バージョンをダウンロードします。
+ JavaScript の依存関係の `npm` を使用する場合、次のコマンドを実行してダウンロードおよびインストールします。

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

# GetDashboardEmbedUrl (古い API) を使用した登録済みユーザー向けのダッシュボードの埋め込み
<a name="embedded-analytics-dashboards-for-authenticated-users-get"></a>

**重要**  
Amazon Quick Sight には、分析を埋め込むための新しい APIs として `GenerateEmbedUrlForAnonymousUser`と があります`GenerateEmbedUrlForRegisteredUser`。  
`GetDashboardEmbedUrl` および `GetSessionEmbedUrl` APIs を使用してダッシュボードと Amazon Quick Sight コンソールを埋め込むことはできますが、最新の埋め込み機能は含まれていません。up-to-date埋め込みエクスペリエンスについては、[「Amazon Quick Sight 分析をアプリケーションに埋め込む](https://docs.aws.amazon.com/quicksight/latest/user/embedding-overview.html)」を参照してください。

以下のセクションでは、 を使用して登録済みユーザーの埋め込み Amazon Quick Sight ダッシュボードを設定する方法について詳しく説明します`GetDashboardEmbedUrl`。

**Topics**
+ [

# ステップ 1: 許可をセットアップする
](embedded-dashboards-for-authenticated-users-get-step-1.md)
+ [

# ステップ 2: 認証コードがアタッチされた URL を取得する
](embedded-dashboards-for-authenticated-users-get-step-2.md)
+ [

# ステップ 3: ダッシュボード URL を埋め込む
](embedded-dashboards-for-authenticated-users-get-step-3.md)

# ステップ 1: 許可をセットアップする
<a name="embedded-dashboards-for-authenticated-users-get-step-1"></a>

**重要**  
Amazon Quick Sight には、分析を埋め込むための新しい APIs として `GenerateEmbedUrlForAnonymousUser`と があります`GenerateEmbedUrlForRegisteredUser`。  
`GetDashboardEmbedUrl` および `GetSessionEmbedUrl` APIs を使用してダッシュボードと Amazon Quick Sight コンソールを埋め込むことはできますが、最新の埋め込み機能は含まれていません。up-to-date埋め込みエクスペリエンスについては、[「Amazon Quick Sight 分析をアプリケーションに埋め込む](https://docs.aws.amazon.com/quicksight/latest/user/embedding-overview.html)」を参照してください。

次のセクションでは、バックエンドアプリケーションまたはウェブサーバーのアクセス許可を設定する方法について説明します。このタスクには IAM への管理者アクセス権が必要です。

ダッシュボードにアクセスする各ユーザーは、Amazon Quick Sight にダッシュボードへのアクセスとアクセス許可を付与するロールを引き受けます。これを可能にするには、 AWS アカウントに IAM ロールを作成します。IAM ポリシーをロールに関連付けて、それを引き受けるすべてのユーザーにアクセス許可を付与します。IAM ロールは、ダッシュボードの URL を取得する許可を提供する必要があります。このためには、`quicksight:GetDashboardEmbedUrl` を追加します。

次のサンプルポリシーで、`IdentityType=IAM` で使用するこれらの許可が付与されます。

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

****  

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

------

次のサンプルポリシーで、ダッシュボード URL を取得する許可が付与されます。Amazon Quick Sight リーダーとなる初めてユーザーを作成する`quicksight:RegisterUser`場合は、 で ポリシーを使用します。

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

****  

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

------

`QUICKSIGHT` を `identityType` として使用し、ユーザーの Amazon リソースネーム (ARN) を指定する場合は、ポリシーで `quicksight:GetAuthCode` アクションを許可する必要もあります。次のサンプルポリシーで、このアクセス許可が付与されます。

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

****  

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

------

作成したロールへのアクセスを許可するには、アプリケーションの IAM ID に関連付けられた信頼ポリシーが必要です。つまり、ユーザーがアプリケーションにアクセスすると、アプリケーションはユーザーに代わってロールを引き受け、Amazon Quick Sight でユーザーをプロビジョニングできます。次の例は、`embedding_quicksight_dashboard_role` というロールを示しています。このロールには、リソースとしてサンプルポリシーが先行しています。

OpenId Connect または SAML 認証の信頼ポリシーに関する詳細については、「*IAM ユーザーガイド*」の以下のセクションを参照してください。
+ [ウェブ ID または OpenID Connect フェデレーション用のロールの作成 (コンソール)](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_create_for-idp_oidc.html)
+ [SAML 2.0 フェデレーション用のロールの作成 (コンソール)](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_create_for-idp_saml.html)

# ステップ 2: 認証コードがアタッチされた URL を取得する
<a name="embedded-dashboards-for-authenticated-users-get-step-2"></a>

**重要**  
Amazon Quick Sight には、分析を埋め込むための新しい APIs として `GenerateEmbedUrlForAnonymousUser`と があります`GenerateEmbedUrlForRegisteredUser`。  
`GetDashboardEmbedUrl` および `GetSessionEmbedUrl` APIs を使用してダッシュボードと Amazon Quick Sight コンソールを埋め込むことはできますが、最新の埋め込み機能は含まれていません。up-to-date埋め込みエクスペリエンスについては、[「Amazon Quick Sight 分析をアプリケーションに埋め込む](https://docs.aws.amazon.com/quicksight/latest/user/embedding-overview.html)」を参照してください。

次のセクションでは、ユーザーの認証方法とアプリケーションサーバー上の埋め込みダッシュボード URL の取得方法について説明します。

ユーザーがアプリケーションにアクセスすると、アプリケーションはユーザーに代わって IAM ロールを引き受けます。次に、そのユーザーがまだ存在しない場合、そのユーザーを Amazon Quick Sight に追加します。次に、アプリケーションが一意のロールセッション ID として識別子を渡します。

説明されているステップを実行すると、ダッシュボードの各ビューワーが Amazon Quick Sight で一意にプロビジョニングされます。行レベルのセキュリティやパラメータの動的デフォルトなど、ユーザーごとの設定も強制されます。

次の例では、ユーザーに代わって IAM 認証を実行します。このコードはアプリケーションサーバー上で実行されます。

------
#### [ Java ]

```
import com.amazonaws.auth.AWSCredentials;
import com.amazonaws.auth.AWSStaticCredentialsProvider;
import com.amazonaws.auth.BasicSessionCredentials;
import com.amazonaws.auth.BasicAWSCredentials;
import com.amazonaws.auth.AWSCredentialsProvider;
import com.amazonaws.regions.Regions;
import com.amazonaws.services.quicksight.AmazonQuickSight;
import com.amazonaws.services.quicksight.AmazonQuickSightClientBuilder;
import com.amazonaws.services.quicksight.model.GetDashboardEmbedUrlRequest;
import com.amazonaws.services.quicksight.model.GetDashboardEmbedUrlResult;
import com.amazonaws.services.securitytoken.AWSSecurityTokenService;
import com.amazonaws.services.securitytoken.model.AssumeRoleRequest;
import com.amazonaws.services.securitytoken.model.AssumeRoleResult;

/**
 * Class to call QuickSight AWS SDK to get url for dashboard embedding.
 */
public class GetQuicksightEmbedUrlIAMAuth {

    private static String IAM = "IAM";

    private final AmazonQuickSight quickSightClient;

    private final AWSSecurityTokenService awsSecurityTokenService;

    public GetQuicksightEmbedUrlIAMAuth(final AWSSecurityTokenService awsSecurityTokenService) {
        this.quickSightClient = AmazonQuickSightClientBuilder
                .standard()
                .withRegion(Regions.US_EAST_1.getName())
                .withCredentials(new AWSCredentialsProvider() {
                                     @Override
                                     public AWSCredentials getCredentials() {
                                         // provide actual IAM access key and secret key here
                                         return new BasicAWSCredentials("access-key", "secret-key");
                                     }

                                     @Override
                                     public void refresh() {}
                                 }
                )
                .build();
        this.awsSecurityTokenService = awsSecurityTokenService;
    }

    public String getQuicksightEmbedUrl(
            final String accountId, // YOUR AWS ACCOUNT ID
            final String dashboardId, // YOUR DASHBOARD ID TO EMBED
            final String openIdToken, // TOKEN TO ASSUME ROLE WITH ROLEARN
            final String roleArn, // IAM USER ROLE TO USE FOR EMBEDDING
            final String sessionName, // SESSION NAME FOR THE ROLEARN ASSUME ROLE
            final boolean resetDisabled, // OPTIONAL PARAMETER TO ENABLE DISABLE RESET BUTTON IN EMBEDDED DASHBAORD
            final boolean undoRedoDisabled // OPTIONAL PARAMETER TO ENABLE DISABLE UNDO REDO BUTTONS IN EMBEDDED DASHBAORD
    ) throws Exception {
        AssumeRoleRequest request = new AssumeRoleRequest()
                .withRoleArn(roleArn)
                .withRoleSessionName(sessionName)
                .withTokenCode(openIdToken)
                .withDurationSeconds(3600);
        AssumeRoleResult assumeRoleResult = awsSecurityTokenService.assumeRole(request);

        AWSCredentials temporaryCredentials = new BasicSessionCredentials(
                assumeRoleResult.getCredentials().getAccessKeyId(),
                assumeRoleResult.getCredentials().getSecretAccessKey(),
                assumeRoleResult.getCredentials().getSessionToken());
        AWSStaticCredentialsProvider awsStaticCredentialsProvider = new AWSStaticCredentialsProvider(temporaryCredentials);

        GetDashboardEmbedUrlRequest getDashboardEmbedUrlRequest = new GetDashboardEmbedUrlRequest()
                .withDashboardId(dashboardId)
                .withAwsAccountId(accountId)
                .withIdentityType(IAM)
                .withResetDisabled(resetDisabled)
                .withUndoRedoDisabled(undoRedoDisabled)
                .withRequestCredentialsProvider(awsStaticCredentialsProvider);

        GetDashboardEmbedUrlResult dashboardEmbedUrl = quickSightClient.getDashboardEmbedUrl(getDashboardEmbedUrlRequest);

        return dashboardEmbedUrl.getEmbedUrl();
    }
}
```

------
#### [ JavaScript ]

```
global.fetch = require('node-fetch');
const AWS = require('aws-sdk');

function getDashboardEmbedURL(
    accountId, // YOUR AWS ACCOUNT ID
    dashboardId, // YOUR DASHBOARD ID TO EMBED
    openIdToken, // TOKEN TO ASSUME ROLE WITH ROLEARN
    roleArn, // IAM USER ROLE TO USE FOR EMBEDDING
    sessionName, // SESSION NAME FOR THE ROLEARN ASSUME ROLE
    resetDisabled, // OPTIONAL PARAMETER TO ENABLE DISABLE RESET BUTTON IN EMBEDDED DASHBAORD
    undoRedoDisabled, // OPTIONAL PARAMETER TO ENABLE DISABLE UNDO REDO BUTTONS IN EMBEDDED DASHBAORD
    getEmbedUrlCallback, // GETEMBEDURL SUCCESS CALLBACK METHOD
    errorCallback // GETEMBEDURL ERROR CALLBACK METHOD
    ) {
    const stsClient = new AWS.STS();
    let stsParams = {
        RoleSessionName: sessionName,
        WebIdentityToken: openIdToken,
        RoleArn: roleArn
    }

    stsClient.assumeRoleWithWebIdentity(stsParams, function(err, data) {
        if (err) {
            console.log('Error assuming role');
            console.log(err, err.stack);
            errorCallback(err);
        } else {
            const getDashboardParams = {
                AwsAccountId: accountId,
                DashboardId: dashboardId,
                IdentityType: 'IAM',
                ResetDisabled: resetDisabled,
                SessionLifetimeInMinutes: 600,
                UndoRedoDisabled: undoRedoDisabled
            };

            const quicksightGetDashboard = new AWS.QuickSight({
                region: process.env.AWS_REGION,
                credentials: {
                    accessKeyId: data.Credentials.AccessKeyId,
                    secretAccessKey: data.Credentials.SecretAccessKey,
                    sessionToken: data.Credentials.SessionToken,
                    expiration: data.Credentials.Expiration
                }
            });

            quicksightGetDashboard.getDashboardEmbedUrl(getDashboardParams, function(err, data) {
                if (err) {
                    console.log(err, err.stack);
                    errorCallback(err);
                } else {
                    const result = {
                        "statusCode": 200,
                        "headers": {
                            "Access-Control-Allow-Origin": "*", // USE YOUR WEBSITE DOMAIN TO SECURE ACCESS TO GETEMBEDURL API
                            "Access-Control-Allow-Headers": "Content-Type"
                        },
                        "body": JSON.stringify(data),
                        "isBase64Encoded": false
                    }
                    getEmbedUrlCallback(result);
                }
            });
        }
    });
}
```

------
#### [ Python3 ]

```
import json
import boto3
from botocore.exceptions import ClientError

# Create QuickSight and STS clients
qs = boto3.client('quicksight',region_name='us-east-1')
sts = boto3.client('sts')

# Function to generate embedded URL  
# accountId: YOUR AWS ACCOUNT ID
# dashboardId: YOUR DASHBOARD ID TO EMBED
# openIdToken: TOKEN TO ASSUME ROLE WITH ROLEARN
# roleArn: IAM USER ROLE TO USE FOR EMBEDDING
# sessionName: SESSION NAME FOR THE ROLEARN ASSUME ROLE
# resetDisabled: PARAMETER TO ENABLE DISABLE RESET BUTTON IN EMBEDDED DASHBAORD
# undoRedoDisabled: PARAMETER TO ENABLE DISABLE UNDO REDO BUTTONS IN EMBEDDED DASHBAORD
def getDashboardURL(accountId, dashboardId, openIdToken, roleArn, sessionName, resetDisabled, undoRedoDisabled):
    try:
        assumedRole = sts.assume_role(
            RoleArn = roleArn,
            RoleSessionName = sessionName,
            WebIdentityToken = openIdToken
        )
    except ClientError as e:
        return "Error assuming role: " + str(e)
    else: 
        assumedRoleSession = boto3.Session(
            aws_access_key_id = assumedRole['Credentials']['AccessKeyId'],
            aws_secret_access_key = assumedRole['Credentials']['SecretAccessKey'],
            aws_session_token = assumedRole['Credentials']['SessionToken'],
        )
        try:
            quickSight = assumedRoleSession.client('quicksight',region_name='us-east-1')
            
            response = quickSight.get_dashboard_embed_url(
                 AwsAccountId = accountId,
                 DashboardId = dashboardId,
                 IdentityType = 'IAM',
                 SessionLifetimeInMinutes = 600,
                 UndoRedoDisabled = undoRedoDisabled,
                 ResetDisabled = resetDisabled
            )
            
            return {
                'statusCode': 200,
                'headers': {"Access-Control-Allow-Origin": "*", "Access-Control-Allow-Headers": "Content-Type"},
                'body': json.dumps(response),
                'isBase64Encoded':  bool('false')
            }
        except ClientError as e:
            return "Error generating embeddedURL: " + str(e)
```

------
#### [ Node.js ]

次の例は、埋め込みダッシュボードの URL を取得するためにアプリサーバーで使用できるJavaScript (Node.js) を示しています。ダッシュボードを表示するには、ウェブサイトまたはアプリでこの URL を使用します。

**Example**  

```
const AWS = require('aws-sdk');
            const https = require('https');
            
            var quicksight = new AWS.Service({
                apiConfig: require('./quicksight-2018-04-01.min.json'),
                region: 'us-east-1',
            });
            
            quicksight.getDashboardEmbedUrl({
                'AwsAccountId': '111122223333',
                'DashboardId': '1c1fe111-e2d2-3b30-44ef-a0e111111cde',
                'IdentityType': 'IAM',
                'ResetDisabled': true,
                'SessionLifetimeInMinutes': 100,
                'UndoRedoDisabled': false,
                'StatePersistenceEnabled': true
            
            }, function(err, data) {
                console.log('Errors: ');
                console.log(err);
                console.log('Response: ');
                console.log(data);
            });
```

**Example**  

```
//The URL returned is over 900 characters. For this example, we've shortened the string for
            //readability and added ellipsis to indicate that it's incomplete.
                                { Status: 200,
              EmbedUrl: 'https://dashboards.example.com/embed/620bef10822743fab329fb3751187d2d…
              RequestId: '7bee030e-f191-45c4-97fe-d9faf0e03713' }
```

------
#### [ .NET/C\$1 ]

次の例は、埋め込みダッシュボードの URL を取得するためにアプリケーションサーバーで使用できる .NET/C\$1 コードを示しています。ダッシュボードを表示するには、ウェブサイトまたはアプリでこの URL を使用します。

**Example**  

```
            var client = new AmazonQuickSightClient(
                AccessKey,
                SecretAccessKey,
                sessionToken,
                Amazon.RegionEndpoint.USEast1);
            try
            {
                Console.WriteLine(
                    client.GetDashboardEmbedUrlAsync(new GetDashboardEmbedUrlRequest
                    {
                        AwsAccountId = “111122223333”,
                        DashboardId = "1c1fe111-e2d2-3b30-44ef-a0e111111cde",
                        IdentityType = EmbeddingIdentityType.IAM,
                        ResetDisabled = true,
                        SessionLifetimeInMinutes = 100,
                        UndoRedoDisabled = false,
                        StatePersistenceEnabled = true
                    }).Result.EmbedUrl
                );
            } catch (Exception ex) {
                Console.WriteLine(ex.Message);
            }
```

------
#### [ AWS CLI ]

ロールを引き受けるには、次のいずれかの AWS Security Token Service (AWS STS) API オペレーションを選択します。
+ [AssumeRole](https://docs.aws.amazon.com/STS/latest/APIReference/API_AssumeRole.html) – ロールを引き受けるために IAM ID を使用している場合は、このオペレーションを使用します。
+ [AssumeRoleWithWebIdentity](https://docs.aws.amazon.com/STS/latest/APIReference/API_AssumeRoleWithWebIdentity.html) – ユーザーの認証にウェブ ID プロバイダーを使用している場合は、このオペレーションを使用します。
+ [AssumeRoleWithSAML](https://docs.aws.amazon.com/STS/latest/APIReference/API_AssumeRoleWithSAML.html) – ユーザーの認証に SAML を使用している場合は、このオペレーションを使用します。

次の例は、IAM ロールを設定するための CLI コマンドを示しています。ロールは、`quicksight:GetDashboardEmbedURL` を有効にする許可を取得する必要があります。ユーザーがダッシュボードを初めて開いたときに、ジャストインタイム方式でユーザーを追加する場合は、ロールには `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` オペレーションは、アクセスキー、シークレットキー、およびセッショントークンの 3 つの出力パラメータを返します。

**注記**  
`AssumeRole` オペレーションを呼び出すときに `ExpiredToken` エラーが発生した場合は、以前の `SESSION TOKEN` がまだ環境変数に残っている可能性があります。以下の変数を設定することで、これをオフにします。  
*AWS\$1ACCESS\$1KEY\$1ID* 
*AWS\$1SECRET\$1ACCESS\$1KEY* 
*AWS\$1SESSION\$1TOKEN* 

次の例は、CLI でこれら 3 つのパラメータを設定する方法を示しています。Microsoft Windows マシンを使用している場合は、`export` の代わりに `set` を使用します。

```
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](https://docs.aws.amazon.com/quicksight/latest/APIReference/API_RegisterUser.html)、[DescribeUser](https://docs.aws.amazon.com/quicksight/latest/APIReference/API_DescribeUser.html)、およびその他の Amazon Quick Sight API オペレーションの詳細については、[Amazon Quick Sight API リファレンス](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
```

ユーザーが 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 を取得するには、アプリケーションサーバーから `get-dashboard-embed-url` を呼び出します。これは埋め込み可能なダッシュボードの URL を返します。次の例は、 AWS Managed Microsoft AD または IAM Identity Center で認証されたユーザーのサーバー側の呼び出しを使用して、埋め込みダッシュボードの URL を取得する方法を示しています。

```
aws quicksight get-dashboard-embed-url \
     --aws-account-id 111122223333 \
     --dashboard-id 1a1ac2b2-3fc3-4b44-5e5d-c6db6778df89 \
     --identity-type IAM \
     --session-lifetime-in-minutes 30 \
     --undo-redo-disabled true \
     --reset-disabled true \
     --state-persistence-enabled true \
     --user-arn arn:aws:quicksight:us-east-1:111122223333:user/default/embedding_quicksight_dashboard_role/embeddingsession
```

このオペレーションの使用に関する詳細については、[https://docs.aws.amazon.com/quicksight/latest/APIReference/API_GetDashboardEmbedUrl.html](https://docs.aws.amazon.com/quicksight/latest/APIReference/API_GetDashboardEmbedUrl.html) を参照してください。これと他の API オペレーションは、独自のコードで使用できます。

------

# ステップ 3: ダッシュボード URL を埋め込む
<a name="embedded-dashboards-for-authenticated-users-get-step-3"></a>

**重要**  
Amazon Quick Sight には、分析を埋め込むための新しい APIs として `GenerateEmbedUrlForAnonymousUser`と があります`GenerateEmbedUrlForRegisteredUser`。  
`GetDashboardEmbedUrl` と `GetSessionEmbedUrl` APIs を使用してダッシュボードと Amazon Quick Sight コンソールを埋め込むことはできますが、最新の埋め込み機能は含まれていません。up-to-date埋め込みエクスペリエンスについては、[「Amazon Quick Sight 分析をアプリケーションに埋め込む](https://docs.aws.amazon.com/quicksight/latest/user/embedding-overview.html)」を参照してください。

次のセクションでは、[Amazon Quick Sight 埋め込み SDK](https://www.npmjs.com/package/amazon-quicksight-embedding-sdk) (JavaScript) を使用して、ステップ 3 のダッシュボード URL をウェブサイトまたはアプリケーションページに埋め込む方法について説明します。SDK を使用すると、次のことを実行できます。
+ ダッシュボードを HTML ページに配置します。
+ ダッシュボードにパラメータを渡します。
+ アプリケーションに合わせてカスタマイズされたメッセージでエラー状態を処理します。

`GetDashboardEmbedUrl` API オペレーションを呼び出して URL を取得し、アプリケーションに埋め込みます。この URL は 5 分間有効で、得られたセッションは 10 時間有効です。API オペレーションは、シングルサインオンセッションを有効にする `auth_code` の URL を提供します。

以下に、`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"
}
```

[Amazon Quick Sight 埋め込み SDK を使用する](https://www.npmjs.com/package/amazon-quicksight-embedding-sdk)か、この URL を iframe に追加して、このダッシュボードをウェブページに埋め込みます。固定の高さと幅の数値 (ピクセル単位) を設定した場合、Amazon Quick Sight はそれらを使用し、ウィンドウのサイズ変更に伴ってビジュアルを変更しません。相対的な高さと幅の割合を設定すると、Amazon Quick Sight はウィンドウサイズの変化に応じて変化するレスポンシブレイアウトを提供します。Amazon Quick Sight Embedding SDK を使用すると、ダッシュボード内のパラメータを制御し、ページロードの完了とエラーの観点からコールバックを受信することもできます。

次の例は生成された URL の使用方法を示しています。このコードはアプリケーションサーバー上で生成されます。

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

この例では、Amazon Quick Sight Embedding SDK を使用して、JavaScript を使用してウェブサイトに埋め込みダッシュボードをロードします。コピーを取得するには、次のいずれかを実行します。
+ GitHub から [Amazon Quick Sight 埋め込み SDK](https://github.com/awslabs/amazon-quicksight-embedding-sdk#step-3-create-the-quicksight-session-object) をダウンロードします。このリポジトリは、Amazon Quick Sight 開発者のグループによって管理されます。
+ [https://www.npmjs.com/package/amazon-quicksight-embedding-sdk](https://www.npmjs.com/package/amazon-quicksight-embedding-sdk) から、最新の埋め込み SDK バージョンをダウンロードします。
+ JavaScript の依存関係の `npm` を使用する場合、次のコマンドを実行してダウンロードおよびインストールします。

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

# (GetSessionEmbedUrl古い API) を使用した Amazon Quick Sight コンソールの埋め込み
<a name="embedded-analytics-full-console-for-authenticated-users-get"></a>

**重要**  
Amazon Quick Sight には、分析を埋め込むための新しい APIs として `GenerateEmbedUrlForAnonymousUser`と があります`GenerateEmbedUrlForRegisteredUser`。  
`GetDashboardEmbedUrl` と `GetSessionEmbedUrl` APIs を使用してダッシュボードと Amazon Quick Sight コンソールを埋め込むことはできますが、最新の埋め込み機能は含まれていません。up-to-date埋め込みエクスペリエンスについては、[「Amazon Quick Sight 分析をアプリケーションに埋め込む](https://docs.aws.amazon.com/quicksight/latest/user/embedding-overview.html)」を参照してください。


|  | 
| --- |
|  適用対象: Enterprise Edition  | 


|  | 
| --- |
|    対象者:  Amazon Quick デベロッパー  | 

以下のセクションでは、`GetSessionEmbedUrl`API を使用して登録されたユーザー向けにカスタムブランドのオーサリングポータルで Amazon Quick Sight コンソールエクスペリエンスを提供する方法について詳しく説明します。

**Topics**
+ [

# ステップ 1: 許可をセットアップする
](embedded-analytics-full-console-for-authenticated-users-get-step-1.md)
+ [

# ステップ 2: 認証コードがアタッチされた URL を取得する
](embedded-analytics-full-console-for-authenticated-users-get-step-2.md)
+ [

# ステップ 3: コンソールセッション URL を埋め込む
](embedded-analytics-full-console-for-authenticated-users-get-step-3.md)

# ステップ 1: 許可をセットアップする
<a name="embedded-analytics-full-console-for-authenticated-users-get-step-1"></a>

**重要**  
Amazon Quick Sight には、分析を埋め込むための新しい APIs として `GenerateEmbedUrlForAnonymousUser`と があります`GenerateEmbedUrlForRegisteredUser`。  
`GetDashboardEmbedUrl` および `GetSessionEmbedUrl` APIs を使用してダッシュボードと Amazon Quick Sight コンソールを埋め込むことはできますが、最新の埋め込み機能は含まれていません。up-to-date埋め込みエクスペリエンスについては、[「Amazon Quick Sight 分析をアプリケーションに埋め込む](https://docs.aws.amazon.com/quicksight/latest/user/embedding-overview.html)」を参照してください。

次のセクションでは、バックエンドアプリケーションまたはウェブサーバーのアクセス許可を設定する方法について説明します。このタスクには IAM への管理者アクセス権が必要です。

Amazon Quick Sight にアクセスする各ユーザーは、コンソールセッションへのアクセスとアクセス許可を Amazon Quick Sight に付与するロールを引き受けます。これを可能にするには、 AWS アカウントに IAM ロールを作成します。IAM ポリシーをロールに関連付けて、それを引き受けるすべてのユーザーにアクセス許可を付与します。アクセス`quicksight:RegisterUser`許可を追加して、閲覧者が Amazon Quick Sight に読み取り専用でアクセスでき、他のデータや作成機能にアクセスできないようにします。IAM ロールは、コンソールセッションの URL を取得する許可も付与する必要があります。このためには、`quicksight:GetSessionEmbedUrl` を追加します。

次のサンプルポリシーで、`IdentityType=IAM` で使用するこれらの許可が付与されます。

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

****  

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

------

次のサンプルポリシーで、コンソールセッションの URL を取得する許可が付与されます。ユーザーが埋め込みセッションにアクセスする前にユーザーを作成する場合、`quicksight:RegisterUser` なしでポリシーを使用します。

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

****  

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

------

`QUICKSIGHT` を `identityType` として使用し、ユーザーの Amazon リソースネーム (ARN) を指定する場合は、ポリシーで `quicksight:GetAuthCode` アクションを許可する必要もあります。次のサンプルポリシーで、このアクセス許可が付与されます。

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

****  

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

------

作成したロールへのアクセスを許可するには、アプリケーションの IAM ID に関連付けられた信頼ポリシーが必要です。つまり、ユーザーがアプリケーションにアクセスすると、アプリケーションはユーザーに代わってロールを引き受け、Amazon Quick Sight でユーザーをプロビジョニングできます。次の例は、`embedding_quicksight_console_session_role` というロールを示しています。このロールには、リソースとしてサンプルポリシーが先行しています。

OpenId Connect または SAML 認証の信頼ポリシーに関する詳細については、「*IAM ユーザーガイド*」の以下のセクションを参照してください。
+ [ウェブ ID または OpenID Connect フェデレーション用のロールの作成 (コンソール)](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_create_for-idp_oidc.html)
+ [SAML 2.0 フェデレーション用のロールの作成 (コンソール)](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_create_for-idp_saml.html)

# ステップ 2: 認証コードがアタッチされた URL を取得する
<a name="embedded-analytics-full-console-for-authenticated-users-get-step-2"></a>

**重要**  
Amazon Quick Sight には、分析を埋め込むための新しい APIs として `GenerateEmbedUrlForAnonymousUser`と があります`GenerateEmbedUrlForRegisteredUser`。  
`GetDashboardEmbedUrl` と `GetSessionEmbedUrl` APIs を使用してダッシュボードと Amazon Quick Sight コンソールを埋め込むことはできますが、最新の埋め込み機能は含まれていません。up-to-date埋め込みエクスペリエンスについては、[「Amazon Quick Sight 分析をアプリケーションに埋め込む](https://docs.aws.amazon.com/quicksight/latest/user/embedding-overview.html)」を参照してください。

次のセクションでは、ユーザーの認証方法とアプリケーションサーバー上の埋め込みコンソールセッションの URL の取得方法について説明します。

ユーザーがアプリケーションにアクセスすると、アプリケーションはユーザーに代わって IAM ロールを引き受けます。次に、そのユーザーがまだ存在しない場合、Amazon Quick Sight にユーザーを追加します。次に、アプリケーションが一意のロールセッション ID として識別子を渡します。

説明されているステップを実行すると、コンソールセッションの各ビューワーが Amazon Quick Sight で一意にプロビジョニングされます。行レベルのセキュリティやパラメータの動的デフォルトなど、ユーザーごとの設定も強制されます。

次の例では、ユーザーに代わって IAM 認証を実行します。このコードはアプリケーションサーバー上で実行されます。

------
#### [ 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 ]

次の例は、埋め込みコンソールセッションの URL を取得するためにアプリケーションサーバーで使用する JavaScript (Node.js) を示しています。コンソールセッションを表示するには、ウェブサイトまたはアプリケーションでこの URL を使用します。

**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 ]

次の例は、埋め込みコンソールセッションの URL を取得するためにアプリケーションサーバーで使用する .NET/C\$1 コードを示しています。コンソールを表示するには、ウェブサイトまたはアプリケーションでこの URL を使用します。

**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 ]

ロールを引き受けるには、次のいずれかの AWS Security Token Service (AWS STS) API オペレーションを選択します。
+ [AssumeRole](https://docs.aws.amazon.com/STS/latest/APIReference/API_AssumeRole.html) – ロールを引き受けるために IAM ID を使用している場合は、このオペレーションを使用します。
+ [AssumeRoleWithWebIdentity](https://docs.aws.amazon.com/STS/latest/APIReference/API_AssumeRoleWithWebIdentity.html) – ユーザーの認証にウェブ ID プロバイダーを使用している場合は、このオペレーションを使用します。
+ [AssumeRoleWithSAML](https://docs.aws.amazon.com/STS/latest/APIReference/API_AssumeRoleWithSAML.html) – ユーザーの認証に SAML を使用している場合は、このオペレーションを使用します。

次の例は、IAM ロールを設定するための CLI コマンドを示しています。ロールでは、`quicksight:GetSessionEmbedUrl` に対する許可が有効化されている必要があります。ユーザーが最初に Amazon Quick Sight を開いたときに、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` オペレーションは、アクセスキー、シークレットキー、およびセッショントークンの 3 つの出力パラメータを返します。

**注記**  
`AssumeRole` オペレーションを呼び出すときに `ExpiredToken` エラーが発生した場合は、以前の `SESSION TOKEN` がまだ環境変数に残っている可能性があります。以下の変数を設定することで、これをオフにします。  
*AWS\$1ACCESS\$1KEY\$1ID* 
*AWS\$1SECRET\$1ACCESS\$1KEY* 
*AWS\$1SESSION\$1TOKEN* 

次の例は、CLI でこれら 3 つのパラメータを設定する方法を示しています。Microsoft Windows マシンを使用している場合は、`export` の代わりに `set` を使用します。

```
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 を使用すると、各ユーザーに適切なアクセス許可が設定されます。また、ユーザーアクセスのスロットリングが防止されます。スロットリングは、同じユーザーが複数の場所から Amazon Quick Sight にアクセスできないようにするセキュリティ機能です。

ロールセッション ID も Amazon Quick Sight のユーザー名になります。このパターンを使用して、Amazon Quick Sight でユーザーを事前にプロビジョニングしたり、コンソールセッションに初めてアクセスしたときにユーザーをプロビジョニングしたりできます。

次の例は、ユーザーをプロビジョニングするために使用できる CLI コマンドを示しています。[RegisterUser](https://docs.aws.amazon.com/quicksight/latest/APIReference/API_RegisterUser.html)、[DescribeUser](https://docs.aws.amazon.com/quicksight/latest/APIReference/API_DescribeUser.html)、およびその他の Amazon Quick Sight API オペレーションの詳細については、[Amazon Quick Sight API リファレンス](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
```

ユーザーが 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 のユーザーでもあり、Amazon Quick Sight コンソールセッションにアクセスできるアプリのユーザーができました。

最後に、コンソールセッションの署名付き URL を取得するには、アプリケーションサーバーから `get-session-embed-url` を呼び出します。これは、埋め込み可能なコンソールセッションの URL を返します。次の例は、 AWS Managed Microsoft AD または Single Sign-On (IAM Identity Center) で認証されたユーザーのサーバー側の呼び出しを使用して、埋め込みコンソールセッションの URL を取得する方法を示しています。

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

このオペレーションの使用に関する詳細については、[https://docs.aws.amazon.com/quicksight/latest/APIReference/API_GetSessionEmbedUrl.html](https://docs.aws.amazon.com/quicksight/latest/APIReference/API_GetSessionEmbedUrl.html) を参照してください。これと他の API オペレーションは、独自のコードで使用できます。

------

# ステップ 3: コンソールセッション URL を埋め込む
<a name="embedded-analytics-full-console-for-authenticated-users-get-step-3"></a>

**重要**  
Amazon Quick Sight には、分析を埋め込むための新しい APIs として `GenerateEmbedUrlForAnonymousUser`と があります`GenerateEmbedUrlForRegisteredUser`。  
`GetDashboardEmbedUrl` と `GetSessionEmbedUrl` APIs を使用してダッシュボードと Amazon Quick Sight コンソールを埋め込むことはできますが、最新の埋め込み機能は含まれていません。up-to-date埋め込みエクスペリエンスについては、[「Amazon Quick Sight 分析をアプリケーションに埋め込む](https://docs.aws.amazon.com/quicksight/latest/user/embedding-overview.html)」を参照してください。

次のセクションでは、[Amazon Quick Sight 埋め込み SDK](https://www.npmjs.com/package/amazon-quicksight-embedding-sdk) (JavaScript) を使用して、ウェブサイトまたはアプリケーションページのステップ 3 のコンソールセッション URL を埋め込む方法について説明します。この SDK を使用することで、以下を実行できます。
+ コンソールセッションを HTML ページに配置します。
+ コンソールセッションにパラメータを渡します。
+ アプリケーションに合わせてカスタマイズされたメッセージでエラー状態を処理します。

`GetSessionEmbedUrl` API オペレーションを呼び出して URL を取得し、アプリケーションに埋め込みます。この URL は 5 分間有効で、得られたセッションは 10 時間有効です。API オペレーションは、シングルサインオンセッションを有効にする `auth_code` の URL を提供します。

以下に、`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"
}
```

Amazon Quick Sight [Embedding SDK を使用する](https://www.npmjs.com/package/amazon-quicksight-embedding-sdk)か、この URL を iframe に追加して、このコンソールセッションをウェブページに埋め込みます。固定の高さと幅の数値 (ピクセル単位) を設定した場合、Amazon Quick Sight はそれらを使用し、ウィンドウのサイズ変更に伴ってビジュアルを変更しません。相対的な高さと幅の割合を設定すると、Amazon Quick Sight はウィンドウサイズの変化に応じて変化するレスポンシブレイアウトを提供します。Amazon Quick Sight Embedding SDK を使用すると、コンソールセッション内のパラメータを制御し、ページロードの完了とエラーの観点からコールバックを受信することもできます。

次の例は生成された URL の使用方法を示しています。このコードはアプリケーションサーバー上で生成されます。

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

この例では、Amazon Quick Sight Embedding SDK を使用して、JavaScript を使用してウェブサイトに埋め込みコンソールセッションをロードします。コピーを取得するには、次のいずれかを実行します。
+ GitHub から [Amazon Quick Sight 埋め込み SDK](https://github.com/awslabs/amazon-quicksight-embedding-sdk#step-3-create-the-quicksight-session-object) をダウンロードします。このリポジトリは、Amazon Quick Sight 開発者のグループによって管理されます。
+ [https://www.npmjs.com/package/amazon-quicksight-embedding-sdk](https://www.npmjs.com/package/amazon-quicksight-embedding-sdk) から、最新の埋め込み SDK バージョンをダウンロードします。
+ JavaScript の依存関係の `npm` を使用する場合、次のコマンドを実行してダウンロードおよびインストールします。

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