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

# 登録済みユーザー向けの 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
         }
     };
     ```