Terjemahan disediakan oleh mesin penerjemah. Jika konten terjemahan yang diberikan bertentangan dengan versi bahasa Inggris aslinya, utamakan versi bahasa Inggris.

# Menyematkan visual Amazon Quick Sight untuk pengguna terdaftar
<a name="embedded-analytics-visuals-for-authenticated-users"></a>


|  | 
| --- |
|  Berlaku untuk: Enterprise Edition  | 


|  | 
| --- |
|    Pemirsa yang dituju: Pengembang Amazon Quick  | 

Di bagian berikut, Anda dapat menemukan informasi terperinci tentang cara mengatur visual Amazon Quick Sight yang disematkan untuk pengguna terdaftar Amazon Quick Sight.

**Topics**
+ [Langkah 1: Siapkan izin](#embedded-visuals-for-authenticated-users-step-1)
+ [Langkah 2: Hasilkan URL dengan kode otentikasi terlampir](#embedded-visuals-for-authenticated-users-step-2)
+ [Langkah 3: Sematkan URL visual](#embedded-visuals-for-authenticated-users-step-3)

## Langkah 1: Siapkan izin
<a name="embedded-visuals-for-authenticated-users-step-1"></a>

Di bagian berikut, Anda dapat mengetahui cara mengatur izin untuk aplikasi backend atau server web. Tugas ini membutuhkan akses administratif ke IAM.

Setiap pengguna yang mengakses visual mengambil peran yang memberi mereka akses Amazon Quick Sight dan izin ke visual. Untuk memungkinkan ini, buat peran IAM di Anda Akun AWS. Kaitkan kebijakan IAM dengan peran untuk memberikan izin kepada pengguna mana pun yang mengasumsikannya. Peran IAM perlu memberikan izin untuk mengambil penyematan untuk kumpulan pengguna URLs tertentu. Dengan bantuan karakter *wildcard\$1*, Anda dapat memberikan izin untuk menghasilkan URL untuk semua pengguna di namespace tertentu, atau untuk subset pengguna di ruang nama tertentu. Untuk ini, Anda menambahkan`quicksight:GenerateEmbedUrlForRegisteredUser`.

Anda dapat membuat kondisi dalam kebijakan IAM yang membatasi domain yang dapat dicantumkan developer dalam `AllowedDomains` parameter operasi `GenerateEmbedUrlForAnonymousUser` API. `AllowedDomains`Parameter adalah parameter opsional. Ini memberi Anda sebagai pengembang opsi untuk mengganti domain statis yang dikonfigurasi di menu Kelola Penglihatan **Cepat Amazon**. Sebagai gantinya, Anda dapat mencantumkan hingga tiga domain atau subdomain yang dapat mengakses URL yang dihasilkan. URL ini kemudian disematkan di situs web yang Anda buat. Hanya domain yang tercantum dalam parameter yang dapat mengakses dasbor yang disematkan. Tanpa kondisi ini, Anda dapat membuat daftar domain apa pun di internet dalam `AllowedDomains` parameter. 

Untuk membatasi domain yang dapat digunakan pengembang dengan parameter ini, tambahkan `AllowedEmbeddingDomains` kondisi ke kebijakan IAM Anda. Untuk informasi selengkapnya tentang `AllowedDomains` parameter, lihat [GenerateEmbedUrlForRegisteredUser](https://docs.aws.amazon.com//quicksight/latest/APIReference/API_GenerateEmbedUrlForRegisteredUser.html)di *Referensi API Amazon Quick Sight*.

**Praktik terbaik keamanan untuk operator kondisi IAM**  
Operator kondisi IAM yang tidak dikonfigurasi dengan benar dapat mengizinkan akses tidak sah ke sumber daya Cepat yang disematkan Anda melalui variasi URL. Saat menggunakan kunci `quicksight:AllowedEmbeddingDomains` kondisi dalam kebijakan IAM Anda, gunakan operator kondisi yang mengizinkan domain tertentu atau menolak semua domain yang tidak diizinkan secara khusus. Untuk informasi selengkapnya tentang operator kondisi IAM, lihat [elemen kebijakan IAM JSON: Operator kondisi di Panduan](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_elements_condition_operators.html) Pengguna IAM.  
Banyak variasi URL yang berbeda dapat menunjuk ke sumber daya yang sama. Misalnya, berikut ini URLs semua menyelesaikan konten yang sama:  
`https://example.com`
`https://example.com/`
`https://Example.com`
Jika kebijakan Anda menggunakan operator yang tidak memperhitungkan variasi URL ini, penyerang dapat melewati batasan Anda dengan memberikan variasi URL yang setara.  
Anda harus memvalidasi bahwa kebijakan IAM Anda menggunakan operator kondisi yang sesuai untuk mencegah kerentanan bypass dan memastikan bahwa hanya domain yang Anda inginkan yang dapat mengakses sumber daya yang disematkan.

Kebijakan contoh berikut memberikan izin ini.

Selain itu, jika Anda membuat pengguna pertama kali yang akan menjadi pembaca Amazon Quick Sight, pastikan untuk menambahkan `quicksight:RegisterUser` izin dalam kebijakan.

Kebijakan contoh berikut memberikan izin untuk mengambil URL penyematan bagi pengguna pertama kali yang akan menjadi pembaca Amazon Quick Sight.

Terakhir, identitas IAM aplikasi Anda harus memiliki kebijakan kepercayaan yang terkait dengannya untuk memungkinkan akses ke peran yang baru saja Anda buat. Ini berarti bahwa ketika pengguna mengakses aplikasi Anda, aplikasi Anda dapat mengambil peran atas nama pengguna dan menyediakan pengguna di Amazon Quick Sight. Contoh berikut menunjukkan contoh kebijakan kepercayaan.

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

------

*Untuk informasi selengkapnya mengenai kebijakan kepercayaan untuk OpenID Connect atau otentikasi SAM, lihat bagian berikut dari Panduan Pengguna IAM:*
+ [Membuat Peran untuk Web Identity atau OpenID Connect Federation (Console)](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_create_for-idp_oidc.html)
+ [Membuat Peran untuk Federasi SAM 2.0 (Konsol)](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_create_for-idp_saml.html)

## Langkah 2: Hasilkan URL dengan kode otentikasi terlampir
<a name="embedded-visuals-for-authenticated-users-step-2"></a>

Di bagian berikut, Anda dapat mengetahui cara mengautentikasi pengguna Amazon Quick Sight Anda dan mendapatkan URL visual yang dapat disematkan di server aplikasi Anda. Jika Anda berencana untuk menyematkan visual untuk tipe identitas IAM atau Amazon Quick Sight, bagikan visual dengan pengguna Amazon Quick Sight.

Saat pengguna Amazon Quick Sight mengakses aplikasi Anda, aplikasi akan mengambil peran IAM atas nama pengguna Amazon Quick Sight. Kemudian menambahkan pengguna ke Amazon Quick Sight, jika pengguna Amazon Quick Sight itu belum ada. Selanjutnya, ia melewati pengenal sebagai ID sesi peran unik. 

Melakukan langkah-langkah yang dijelaskan memastikan bahwa setiap penampil visual disediakan secara unik di Amazon Quick Sight. Ini juga memberlakukan pengaturan per pengguna, seperti keamanan tingkat baris dan default dinamis untuk parameter.

Contoh berikut melakukan otentikasi IAM atas nama pengguna Amazon Quick Sight. Kode ini berjalan di server aplikasi Anda.

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

Contoh berikut menunjukkan JavaScript (Node.js) yang dapat Anda gunakan di server aplikasi untuk menghasilkan URL untuk dasbor yang disematkan. Anda dapat menggunakan URL ini di situs web atau aplikasi Anda untuk menampilkan dasbor. 

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

Contoh berikut menunjukkan kode.NET/C\$1 yang dapat Anda gunakan di server aplikasi untuk membuat URL dasbor yang disematkan. Anda dapat menggunakan URL ini di situs web atau aplikasi Anda untuk menampilkan dasbor. 

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

Untuk mengambil peran, pilih salah satu operasi API AWS Security Token Service (AWS STS) berikut:
+ [AssumeRole](https://docs.aws.amazon.com/STS/latest/APIReference/API_AssumeRole.html)— Gunakan operasi ini ketika Anda menggunakan identitas IAM untuk mengambil peran.
+ [AssumeRoleWithWebIdentity](https://docs.aws.amazon.com/STS/latest/APIReference/API_AssumeRoleWithWebIdentity.html)— Gunakan operasi ini saat Anda menggunakan penyedia identitas web untuk mengautentikasi pengguna Anda. 
+ [AssumeRoleWithSaml](https://docs.aws.amazon.com/STS/latest/APIReference/API_AssumeRoleWithSAML.html)— Gunakan operasi ini saat Anda menggunakan SALL untuk mengautentikasi pengguna Anda.

Contoh berikut menunjukkan perintah CLI untuk mengatur peran IAM. Peran harus mengaktifkan izin untuk`quicksight:GenerateEmbedUrlForRegisteredUser`. Jika Anda mengambil just-in-time pendekatan untuk menambahkan pengguna saat mereka pertama kali membuka dasbor, peran tersebut juga memerlukan izin yang diaktifkan. `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`Operasi mengembalikan tiga parameter output: kunci akses, kunci rahasia, dan token sesi. 

**catatan**  
Jika Anda mendapatkan `ExpiredToken` kesalahan saat memanggil `AssumeRole` operasi, ini mungkin karena sebelumnya `SESSION TOKEN` masih dalam variabel lingkungan. Hapus ini dengan mengatur variabel berikut:  
*AWS\$1ACCESS\$1KEY\$1ID* 
*AWS\$1SECRET\$1ACCESS\$1KEY* 
*AWS\$1SESSION\$1TOKEN* 

Contoh berikut menunjukkan cara mengatur ketiga parameter ini di CLI. Jika Anda menggunakan mesin Microsoft Windows, gunakan `set` sebagai gantinya`export`.

```
export AWS_ACCESS_KEY_ID     = "access_key_from_assume_role"
    export AWS_SECRET_ACCESS_KEY = "secret_key_from_assume_role"
    export AWS_SESSION_TOKEN     = "session_token_from_assume_role"
```

Menjalankan perintah ini akan menetapkan ID sesi peran pengguna yang mengunjungi situs web Anda`embedding_quicksight_visual_role/john.doe@example.com`. ID sesi peran terdiri dari nama peran dari `role-arn` dan `role-session-name` nilainya. Menggunakan ID sesi peran unik untuk setiap pengguna memastikan bahwa izin yang sesuai ditetapkan untuk setiap pengguna. Ini juga mencegah pembatasan akses pengguna. *Throttling* adalah fitur keamanan yang mencegah pengguna yang sama mengakses Amazon Quick Sight dari beberapa lokasi. 

ID sesi peran juga menjadi nama pengguna di Amazon Quick Sight. Anda dapat menggunakan pola ini untuk menyediakan pengguna Anda di Amazon Quick Sight sebelumnya, atau untuk menyediakannya saat pertama kali mereka mengakses dasbor. 

Contoh berikut menunjukkan perintah CLI yang dapat Anda gunakan untuk menyediakan pengguna. Untuk informasi selengkapnya tentang [RegisterUser](https://docs.aws.amazon.com/quicksight/latest/APIReference/API_RegisterUser.html), [DescribeUser](https://docs.aws.amazon.com/quicksight/latest/APIReference/API_DescribeUser.html), dan operasi Amazon Quick Sight API lainnya, lihat [Referensi API Amazon Quick Sight](https://docs.aws.amazon.com/quicksight/latest/APIReference/Welcome.html).

```
aws quicksight register-user \
    --aws-account-id 111122223333 \
    --namespace default \
    --identity-type IAM \
    --iam-arn "arn:aws:iam::111122223333:role/embedding_quicksight_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
```

Jika pengguna diautentikasi melalui Microsoft AD, Anda tidak perlu menggunakannya `RegisterUser` untuk mengaturnya. Sebagai gantinya, mereka harus berlangganan secara otomatis saat pertama kali mengakses Amazon Quick Sight. Untuk pengguna Microsoft AD, Anda dapat menggunakan `DescribeUser` untuk mendapatkan ARN pengguna.

Saat pertama kali pengguna mengakses Amazon Quick Sight, Anda juga dapat menambahkan pengguna ini ke grup tempat visual dibagikan. Contoh berikut menunjukkan perintah CLI untuk menambahkan pengguna ke grup.

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

Anda sekarang memiliki pengguna aplikasi Anda yang juga pengguna Amazon Quick Sight, dan yang memiliki akses ke visual. 

Terakhir, untuk mendapatkan URL yang ditandatangani untuk visual, panggil `generate-embed-url-for-registered-user` dari server aplikasi. Ini mengembalikan URL visual yang dapat disematkan. Contoh berikut menunjukkan cara menghasilkan URL untuk visual yang disematkan menggunakan panggilan sisi server untuk pengguna yang diautentikasi melalui AWS Managed Microsoft AD atau single sign-on (IAM Identity Center).

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

Untuk informasi lebih lanjut tentang penggunaan operasi ini, lihat [https://docs.aws.amazon.com/quicksight/latest/APIReference/API_GenerateEmbedUrlForRegisteredUser.html](https://docs.aws.amazon.com/quicksight/latest/APIReference/API_GenerateEmbedUrlForRegisteredUser.html). Anda dapat menggunakan ini dan operasi API lainnya dalam kode Anda sendiri.

## Langkah 3: Sematkan URL visual
<a name="embedded-visuals-for-authenticated-users-step-3"></a>

Di bagian berikut, Anda dapat mengetahui bagaimana Anda dapat menggunakan [Amazon Quick Sight Embedding SDK](https://www.npmjs.com/package/amazon-quicksight-embedding-sdk) (JavaScript) untuk menyematkan URL visual dari langkah 3 di situs web atau halaman aplikasi Anda. Dengan SDK, Anda dapat melakukan hal berikut: 
+ Tempatkan visual pada halaman HTML.
+ Masukkan parameter ke dalam visual.
+ Menangani status kesalahan dengan pesan yang disesuaikan dengan aplikasi Anda.

Panggil operasi `GenerateEmbedUrlForRegisteredUser` API untuk menghasilkan URL yang dapat disematkan di aplikasi. URL ini berlaku selama 5 menit, dan sesi yang dihasilkan berlaku hingga 10 jam. Operasi API menyediakan URL dengan sebuah `auth_code` yang memungkinkan sesi masuk tunggal. 

Berikut ini menunjukkan contoh respons dari`generate-embed-url-for-registered-user`. `quicksightdomain`Dalam contoh ini adalah URL yang Anda gunakan untuk mengakses akun Amazon Quick Sight Anda.

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

Sematkan visual ini di halaman web Anda dengan menggunakan [Amazon Quick Sight Embedding SDK](https://www.npmjs.com/package/amazon-quicksight-embedding-sdk) atau dengan menambahkan URL ini ke dalam iframe. Jika Anda menetapkan nomor tinggi dan lebar tetap (dalam piksel), Amazon Quick Sight menggunakannya dan tidak mengubah visual Anda saat jendela Anda berubah ukuran. Jika Anda menetapkan tinggi dan lebar persen relatif, Amazon Quick Sight menyediakan tata letak responsif yang dimodifikasi saat ukuran jendela Anda berubah. Dengan menggunakan Amazon Quick Sight Embedding SDK, Anda juga dapat mengontrol parameter dalam visual dan menerima callback dalam hal penyelesaian dan kesalahan pemuatan halaman. 

Domain yang akan meng-host visual dan dasbor yang disematkan harus ada di *daftar izinkan, daftar* domain yang disetujui untuk langganan Anda. Quick Persyaratan ini melindungi data Anda dengan menjaga domain yang tidak disetujui dari hosting visual dan dasbor yang disematkan. Untuk informasi selengkapnya tentang menambahkan domain untuk visual dan dasbor yang disematkan, lihat [Mengizinkan domain daftar saat runtime dengan Amazon Quick Sight](https://docs.aws.amazon.com/quicksight/latest/user/embedding-run-time.html) API.

Contoh berikut menunjukkan cara menggunakan URL yang dihasilkan. Kode ini dibuat di server aplikasi Anda.

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

Agar contoh ini berfungsi, pastikan untuk menggunakan Amazon Quick Sight Embedding SDK untuk memuat visual yang disematkan di situs web Anda menggunakan. JavaScript Untuk mendapatkan salinan Anda, lakukan salah satu hal berikut:
+ Unduh [Amazon Quick Sight Embedding SDK](https://github.com/awslabs/amazon-quicksight-embedding-sdk#step-3-create-the-quicksight-session-object) dari. GitHub Repositori ini dikelola oleh sekelompok pengembang Amazon Quick Sight.
+ Unduh versi SDK penyematan terbaru dari. [https://www.npmjs.com/package/amazon-quicksight-embedding-sdk](https://www.npmjs.com/package/amazon-quicksight-embedding-sdk)
+ Jika Anda menggunakan `npm` untuk JavaScript dependensi, unduh dan instal dengan menjalankan perintah berikut.

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