As traduções são geradas por tradução automática. Em caso de conflito entre o conteúdo da tradução e da versão original em inglês, a versão em inglês prevalecerá.

# Incorporação com o Amazon Quick Sight APIs
<a name="embedded-analytics-api"></a>


|  | 
| --- |
|  Aplica-se a: Enterprise Edition  | 


|  | 
| --- |
|    Público-alvo: desenvolvedores do Amazon Quick  | 

Há apenas algumas etapas envolvidas no processo real de incorporação de análises usando o Amazon Quick Sight APIs. 

Antes de começar, certifique-se de ter os seguintes itens em vigor:
+ Configure as permissões necessárias do IAM para a identidade do chamador usada pelo seu aplicativo que usará o AWS SDK para fazer chamadas de API. Por exemplo, conceda permissão para possibilitar a ação `quicksight:GenerateEmbedUrlForAnonymousUser` ou `quicksight:GenerateEmbedUrlForRegisteredUser`.
+ Para incorporar para usuários registrados, compartilhe previamente os ativos do Amazon Quick Sight com eles. Para novos usuários autenticados, saiba como conceder acesso aos ativos. Uma forma de fazer isso é adicionar todos os ativos a uma pasta do Amazon Quick Sight. Se você preferir usar a API Amazon Quick Sight, use as operações de `UpdateDashboardPermissions` API `DescribeDashboardPermissions` e. Para obter mais informações, consulte [DescribeDashboardPermissions](https://docs.aws.amazon.com/quicksight/latest/APIReference/API_DescribeDashboardPermissions.html)ou [UpdateDashboardPermissions](https://docs.aws.amazon.com/quicksight/latest/APIReference/API_UpdateDashboardPermissions.html)na *Amazon Quick API Reference*. Se desejar compartilhar o painel com todos os usuários em um namespace ou em um grupo, você poderá compartilhar o painel com `namespace` ou com `group`.
+ Se você estiver realizando a incorporação de painéis, certifique-se de ter o ID dos painéis que deseja incorporar. O ID do painel corresponde ao código no URL do painel. Também é possível obtê-lo no URL do painel.
+ Um administrador do Amazon Quick Sight deve habilitar explicitamente os domínios nos quais você planeja incorporar suas análises do Amazon Quick Sight. Você pode fazer isso usando o **Manage Amazon Quick Sight**, **Domains and Embedding** no menu de perfil, ou você pode usar o `AllowedDomains` parâmetro de uma chamada de `GenerateEmbedUrlForRegisteredUser` API `GenerateEmbedUrlForAnonymousUser` ou API.

  Essa opção só é visível para administradores do Amazon Quick Sight. Você também pode adicionar subdomínios como parte de um domínio. Para obter mais informações, consulte [Permita a listagem de domínios em tempo de execução com a Amazon Quick API](manage-domains.md#embedding-run-time).

  Todos os domínios na sua lista de permissões estáticas (como desenvolvimento, preparação e produção) devem ser permitidos explicitamente e devem usar HTTPS. Você pode adicionar até cem domínios à lista de permissões. Você pode adicionar domínios em tempo de execução com as operações da API Amazon Quick Sight.

Depois que todos os pré-requisitos estiverem concluídos, a incorporação do Amazon Quick Sight envolve as seguintes etapas, que serão explicadas mais detalhadamente posteriormente: 

1. Para a autenticação, use o servidor de aplicações para autenticar o usuário. Após a autenticação em seu servidor, gere a URL do painel incorporado usando o AWS SDK de que você precisa.

1. Em seu portal web ou aplicativo, incorpore o Amazon Quick Sight usando a URL gerada. Para simplificar esse processo, você pode usar o Amazon Quick Sight Embedding SDK, disponível no [NPMJS](https://www.npmjs.com/package/amazon-quicksight-embedding-sdk) e. [GitHub](https://github.com/awslabs/amazon-quicksight-embedding-sdk) Esse JavaScript SDK personalizado foi projetado para ajudá-lo a integrar com eficiência o Amazon Quick Sight às páginas do seu aplicativo, definir padrões, conectar controles, obter retornos de chamada e lidar com erros. 

Você pode usar registros AWS CloudTrail de auditoria para obter informações sobre o número de painéis incorporados, usuários de uma experiência incorporada e taxas de acesso.

**Topics**
+ [

# Incorporação de painéis do Amazon Quick Sight com a API do Amazon Quick Sight
](embedding-dashboards.md)
+ [

# Incorporando imagens do Amazon Quick Sight com o Amazon Quick Sight APIs
](embedding-visuals.md)
+ [

# Incorporando a funcionalidade completa do console Amazon Quick Sight para usuários registrados
](embedded-analytics-full-console-for-authenticated-users.md)
+ [

# Incorporando o Amazon Q na experiência generativa de perguntas e respostas do Amazon Quick Sight
](embedding-gen-bi.md)
+ [

# Incorporando a barra de pesquisa Amazon Quick Sight Q (Classic)
](embedding-quicksight-q.md)
+ [

# Como incorporar analytics usando as operações de API GetDashboardEmbedURL e GetSessionEmbedURL
](embedded-analytics-deprecated.md)

# Incorporação de painéis do Amazon Quick Sight com a API do Amazon Quick Sight
<a name="embedding-dashboards"></a>

Use os tópicos a seguir para aprender sobre a incorporação de painéis com a API Amazon Quick Sight.

**Topics**
+ [

# Incorporação de painéis do Amazon Quick Sight para usuários registrados
](embedded-analytics-dashboards-for-authenticated-users.md)
+ [

# Incorporação de painéis do Amazon Quick Sight para usuários anônimos (não registrados)
](embedded-analytics-dashboards-for-everyone.md)
+ [

# Como habilitar resumos executivos em painéis incorporados
](embedded-analytics-genbi-executive-summaries-dashboard.md)

# Incorporação de painéis do Amazon Quick Sight para usuários registrados
<a name="embedded-analytics-dashboards-for-authenticated-users"></a>

**Importante**  
O Amazon Quick Sight tem novas operações de API para incorporar análises: `GenerateEmbedUrlForAnonymousUser` e. `GenerateEmbedUrlForRegisteredUser`  
Você ainda pode usar as operações de `GetSessionEmbedUrl` API `GetDashboardEmbedUrl` e as operações de API para incorporar painéis e o console do Amazon Quick Sight, mas elas não contêm os recursos de incorporação mais recentes. Para obter mais informações sobre incorporação usando as operações de API antigas, consulte [Incorporação de análises usando as operações de GetSessionEmbedURL API GetDashboardEmbedURL e](https://docs.aws.amazon.com/quicksight/latest/user/embedded-analytics-deprecated.html).


|  | 
| --- |
|  Aplica-se a: Enterprise Edition  | 


|  | 
| --- |
|    Público-alvo: desenvolvedores do Amazon Quick  | 

Nas seções a seguir, você encontrará informações detalhadas sobre como configurar painéis incorporados do Amazon Quick Sight para usuários registrados do Amazon Quick Sight.

**Topics**
+ [

## Etapa 1: configurar permissões
](#embedded-dashboards-for-authenticated-users-step-1)
+ [

## Etapa 2: gerar o URL com o código de autenticação anexado
](#embedded-dashboards-for-authenticated-users-step-2)
+ [

## Etapa 3: incorporar o URL do painel
](#embedded-dashboards-for-authenticated-users-step-3)

## Etapa 1: configurar permissões
<a name="embedded-dashboards-for-authenticated-users-step-1"></a>

Na seção a seguir, você descobrirá como configurar permissões para a aplicação de back-end ou para o servidor Web. Essa tarefa requer acesso administrativo à IAM.

Cada usuário que acessa um painel assume uma função que lhe dá acesso e permissões ao Amazon Quick Sight para o painel. Para tornar isso possível, crie uma função do IAM em seu Conta da AWS. Associe uma política do IAM à função, para fornecer permissões a qualquer usuário que a assumir. A função do IAM precisa fornecer permissões para recuperar a incorporação de um URLs grupo de usuários específico. Com a ajuda do caractere curinga *\$1*, é possível conceder as permissões para a geração de um URL para todos os usuários em um namespace específico ou para um subconjunto de usuários em namespaces específicos. Para isso, você adiciona `quicksight:GenerateEmbedUrlForRegisteredUser`.

É possível criar uma condição na política do IAM que limite os domínios que os desenvolvedores podem listar no parâmetro `AllowedDomains` de uma operação de API `GenerateEmbedUrlForRegisteredUser`. O parâmetro `AllowedDomains` é opcional. Ele concede a você, como desenvolvedor, a opção de substituir os domínios estáticos que estão configurados no menu Manage **Amazon Quick Sight**. Em vez disso, é possível listar até três domínios ou subdomínios que podem acessar o URL gerado. Em seguida, este URL será incorporado ao site que você criar. Somente os domínios que estão listados no parâmetro podem acessar o elemento visual incorporado. Sem essa condição, você pode listar qualquer domínio da Internet no parâmetro `AllowedDomains`. 

Para limitar os domínios que os desenvolvedores podem usar com esse parâmetro, adicione uma condição `AllowedEmbeddingDomains` à política do IAM. Para obter mais informações sobre o `AllowedDomains` parâmetro, consulte [GenerateEmbedUrlForRegisteredUser](https://docs.aws.amazon.com//quicksight/latest/APIReference/API_GenerateEmbedUrlForRegisteredUser.html)a *Amazon Quick Sight API Reference*.

**Prática recomendada de segurança para operadores de condições do IAM**  
Operadores de condição do IAM configurados incorretamente podem permitir acesso não autorizado aos seus recursos incorporados do Quick por meio de variações de URL. Ao usar a chave de `quicksight:AllowedEmbeddingDomains` condição em suas políticas do IAM, use operadores de condição que permitem domínios específicos ou negam todos os domínios que não são especificamente permitidos. Para obter mais informações sobre operadores de condição do IAM, consulte [Elementos de política JSON do IAM: operadores de condição](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_elements_condition_operators.html) no Guia do usuário do IAM.  
Muitas variações diferentes de URL podem apontar para o mesmo recurso. Por exemplo, URLs todos os itens a seguir têm o mesmo conteúdo:  
`https://example.com`
`https://example.com/`
`https://Example.com`
Se sua política usa operadores que não levam em conta essas variações de URL, um invasor pode contornar suas restrições fornecendo variações de URL equivalentes.  
Você deve validar se sua política do IAM usa operadores de condição apropriados para evitar ignorar vulnerabilidades e garantir que somente os domínios pretendidos possam acessar seus recursos incorporados.

O modelo de política a seguir fornece essas permissões.

Além disso, se você estiver criando usuários iniciantes que serão leitores do Amazon Quick Sight, certifique-se de adicionar a `quicksight:RegisterUser` permissão na política.

O exemplo de política a seguir fornece permissão para recuperar uma URL de incorporação para usuários iniciantes que serão leitores do Amazon Quick Sight.

Por fim, a identidade do IAM da sua aplicação deve ter uma política de confiança associada a ela, para permitir acesso ao perfil que você acabou de criar. Isso significa que, quando um usuário acessa seu aplicativo, ele pode assumir a função em nome do usuário e provisionar o usuário no Amazon Quick Sight. O exemplo apresentado a seguir mostra um exemplo de política de confianç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"
        }
    ]
}
```

------

Para mais informações sobre as políticas de confiança para autenticação SAML ou OpenId Connect, consulte as seguintes seções do *Guia do usuário do IAM: *
+ [Criação de uma função para identidades da Web ou federação do OpenID Connect (Console)](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_create_for-idp_oidc.html)
+ [Criação de uma função para uma federação do SAML 2.0 (console)](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_create_for-idp_saml.html)

## Etapa 2: gerar o URL com o código de autenticação anexado
<a name="embedded-dashboards-for-authenticated-users-step-2"></a>

Na seção apresentada a seguir, você descobrirá como realizar a autenticação do usuário e obter o URL do painel incorporável em seu servidor de aplicações. Se você planeja incorporar painéis para os tipos de identidade IAM ou Amazon Quick Sight, compartilhe o painel com os usuários.

Quando um usuário acessa a aplicação, ela assume o perfil do IAM em nome do usuário. Em seguida, ele adiciona o usuário ao Amazon Quick Sight, se esse usuário ainda não existir. Depois disso, ela transfere um identificador como o ID exclusivo de sessão do usuário. 

A execução dessas etapas garante que cada visualizador do painel seja provisionado de forma exclusiva no Amazon Quick Sight. Ele também aplica as configurações por usuário, como a segurança em nível de linha e padrões dinâmicos para os parâmetros.

Os exemplos a seguir executam a autenticação do IAM em nome do usuário. Este código é executado no servidor da aplicação.

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

O exemplo a seguir mostra o JavaScript (Node.js) que você pode usar no servidor do aplicativo para gerar a URL para o painel incorporado. Você pode usar esse URL no seu site ou aplicativo para exibir o painel. 

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

O exemplo a seguir mostra o código em .NET/C\$1 que você pode usar no servidor de aplicações para gerar o URL para o painel incorporado. Você pode usar esse URL no seu site ou aplicativo para exibir o painel. 

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

Para assumir a função, escolha uma das seguintes operações de API AWS Security Token Service (AWS STS):
+ [AssumeRole](https://docs.aws.amazon.com/STS/latest/APIReference/API_AssumeRole.html)— Use essa operação quando estiver usando uma identidade do IAM para assumir a função.
+ [AssumeRoleWithWebIdentity](https://docs.aws.amazon.com/STS/latest/APIReference/API_AssumeRoleWithWebIdentity.html)— Use essa operação quando estiver usando um provedor de identidade da web para autenticar seu usuário. 
+ [AssumeRoleWithSaml](https://docs.aws.amazon.com/STS/latest/APIReference/API_AssumeRoleWithSAML.html)— Use essa operação quando estiver usando SAML para autenticar seus usuários.

O exemplo a seguir mostra o comando da CLI que define a função do IAM. O perfil precisa ter permissões habilitadas para `quicksight:GenerateEmbedUrlForRegisteredUser`. Se você estiver adotando uma just-in-time abordagem para adicionar usuários quando eles abrem um painel pela primeira vez, a função também precisa de permissões habilitadas`quicksight:RegisterUser`.

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

A operação `assume-role` retorna três parâmetros de saída: a chave de acesso, a chave secreta e o token da sessão. 

**nota**  
Se você receber um erro `ExpiredToken` ao chamar a operação `AssumeRole`, isso provavelmente ocorre porque o `SESSION TOKEN` anterior ainda está nas variáveis de ambiente. Resolva isso definindo as seguintes variáveis:  
*AWS\$1ACCESS\$1KEY\$1ID* 
*AWS\$1SECRET\$1CHAVE DE ACESSO* 
*AWS\$1SESSION\$1TOKEN* 

O exemplo a seguir mostra como definir esses três parâmetros na CLI. Se você estiver usando uma máquina com Microsoft Windows, use `set` em vez de `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"
```

Executar esses comandos define o ID da sessão da função do usuário que está acessando o site `embedding_quicksight_dashboard_role/john.doe@example.com`. O ID da sessão da função é composto pelo nome da função a partir de `role-arn` e o valor de `role-session-name`. Usando o ID único da sessão da função para cada usuário garante que as permissões apropriadas sejam definidas para cada usuário. Isso também impede qualquer limitação do acesso do usuário. *A limitação* é um recurso de segurança que impede que o mesmo usuário acesse o Amazon Quick Sight de vários locais. 

O ID da sessão da função também se torna o nome de usuário no Amazon Quick Sight. Você pode usar esse padrão para provisionar seus usuários no Amazon Quick Sight com antecedência ou para provisioná-los na primeira vez que acessarem o painel. 

O exemplo a seguir mostra o comando da CLI que você pode usar para provisionar um usuário. Para obter mais informações sobre [RegisterUser](https://docs.aws.amazon.com/quicksight/latest/APIReference/API_RegisterUser.html), [DescribeUser](https://docs.aws.amazon.com/quicksight/latest/APIReference/API_DescribeUser.html), e outras operações da API Amazon Quick Sight, consulte a [Referência da 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_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
```

Se o seu usuário for autenticado por meio do Microsoft AD, você não precisará usar `RegisterUser` para configurá-lo. Em vez disso, eles devem ser automaticamente inscritos na primeira vez que acessarem o Amazon Quick Sight. Para usuários do Microsoft AD, você pode usar o `DescribeUser` para obter o ARN do usuário.

Na primeira vez que um usuário acessa o Amazon Quick Sight, você também pode adicionar esse usuário ao grupo com o qual o painel é compartilhado. O exemplo a seguir mostra o comando da CLI para adicionar um usuário a um grupo.

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

Agora você tem um usuário do seu aplicativo que também é usuário do Amazon Quick Sight e que tem acesso ao painel. 

Por fim, obtenha um signed URL para o painel, chame o `generate-embed-url-for-registered-user` partir do servidor de aplicativo. Isso retorna o URL do painel incorporável. O exemplo a seguir mostra como gerar a URL para um painel incorporado usando uma chamada do lado do servidor para usuários autenticados por meio de um login único ( AWS Managed Microsoft AD 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 Dashboard={InitialDashboardId=1a1ac2b2-3fc3-4b44-5e5d-c6db6778df89}
```

Para obter mais informações sobre o uso dessa operação, consulte [https://docs.aws.amazon.com/quicksight/latest/APIReference/API_GenerateEmbedUrlForRegisteredUser.html](https://docs.aws.amazon.com/quicksight/latest/APIReference/API_GenerateEmbedUrlForRegisteredUser.html). Você pode usar essa e outras operações de API no seu próprio código.

## Etapa 3: incorporar o URL do painel
<a name="embedded-dashboards-for-authenticated-users-step-3"></a>

Na seção a seguir, você pode descobrir como usar o [Amazon Quick Sight Embedding SDK](https://www.npmjs.com/package/amazon-quicksight-embedding-sdk) (JavaScript) para incorporar a URL do painel a partir da etapa 3 em seu site ou página de aplicativo. Com o SDK, você pode fazer o seguinte: 
+ Coloque o painel em uma página HTML.
+ Adicione parâmetros ao painel.
+ Corrija os estados de erro com mensagens que são personalizados para seu aplicativo.

Chame a operação de API `GenerateEmbedUrlForRegisteredUser` para gerar o URL que você pode incorporar à aplicação. Esse URL é válido por cinco minutos e a sessão resultante é válida por, no máximo, dez horas. A operação de API fornece ao URL um `auth_code` que possibilita uma sessão de logon único. 

Veja a seguir uma resposta de exemplo de `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"
    }
```

Incorpore esse painel em sua página da web usando o [Amazon Quick Sight Embedding SDK](https://www.npmjs.com/package/amazon-quicksight-embedding-sdk) ou adicionando essa URL em um iframe. Se você definir um número fixo de altura e largura (em pixels), o Amazon Quick Sight os usará e não alterará seu visual à medida que sua janela é redimensionada. Se você definir uma porcentagem relativa de altura e largura, o Amazon Quick Sight fornece um layout responsivo que é modificado à medida que o tamanho da janela muda. Ao usar o Amazon Quick Sight Embedding SDK, você também pode controlar os parâmetros no painel e receber retornos de chamada em termos de conclusão do carregamento da página e erros. 

O domínio que hospedará os painéis incorporados deverá estar na *lista de permissão*, a lista de domínios aprovados para a sua assinatura do Quick . Esse requisito protege seus dados, impedindo que domínios não aprovados hospedem painéis incorporados. Para obter mais informações sobre a adição de domínios para painéis incorporados, consulte [Permitir a listagem de domínios em tempo de execução com a API Amazon Quick](https://docs.aws.amazon.com/quicksight/latest/user/embedding-run-time.html) Sight.

O exemplo a seguir mostra como usar o URL gerado. Este código é gerado no seu servidor de aplicações.

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

Para que este exemplo funcione, certifique-se de usar o Amazon Quick Sight Embedding SDK para carregar o painel incorporado em seu site usando. JavaScript Para obter sua cópia, siga um destes procedimentos:
+ Baixe o [Amazon Quick Sight Embedding SDK](https://github.com/awslabs/amazon-quicksight-embedding-sdk#step-3-create-the-quicksight-session-object) em. GitHub Esse repositório é mantido por um grupo de desenvolvedores do Amazon Quick Sight.
+ Baixe a versão mais recente do SDK de incorporação em. [https://www.npmjs.com/package/amazon-quicksight-embedding-sdk](https://www.npmjs.com/package/amazon-quicksight-embedding-sdk)
+ Se você usa `npm` para JavaScript dependências, faça o download e instale-o executando o comando a seguir.

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

# Incorporação de painéis do Amazon Quick Sight para usuários anônimos (não registrados)
<a name="embedded-analytics-dashboards-for-everyone"></a>

**Importante**  
O Amazon Quick Sight tem novas operações de API para incorporar análises: `GenerateEmbedUrlForAnonymousUser` e. `GenerateEmbedUrlForRegisteredUser`  
Você ainda pode usar as operações de `GetSessionEmbedUrl` API `GetDashboardEmbedUrl` e as operações de API para incorporar painéis e o console do Amazon Quick Sight, mas elas não contêm os recursos de incorporação mais recentes. Para obter mais informações sobre incorporação usando as operações de API antigas, consulte [Incorporação de análises usando as operações de GetSessionEmbedURL API GetDashboardEmbedURL e](https://docs.aws.amazon.com/quicksight/latest/user/embedded-analytics-deprecated.html).


|  | 
| --- |
|  Aplica-se a: Enterprise Edition  | 


|  | 
| --- |
|    Público-alvo: desenvolvedores do Amazon Quick  | 

Nas seções a seguir, você encontrará informações detalhadas sobre como configurar painéis incorporados do Amazon Quick Sight para usuários anônimos (não registrados).

**Topics**
+ [

## Etapa 1: configurar permissões
](#embedded-analytics-dashboards-with-anonymous-users-step-1)
+ [

## Etapa 2: gerar o URL com o código de autenticação anexado
](#embedded-analytics-dashboards-with-anonymous-users-step-2)
+ [

## Etapa 3: incorporar o URL do painel
](#embedded-analytics-dashboards-with-anonymous-users-step-3)

## Etapa 1: configurar permissões
<a name="embedded-analytics-dashboards-with-anonymous-users-step-1"></a>


|  | 
| --- |
|  Aplica-se a: Enterprise Edition  | 


|  | 
| --- |
|    Público-alvo: desenvolvedores do Amazon Quick  | 

Na seção a seguir, você descobrirá como configurar permissões para a aplicação de back-end ou para o servidor Web. Essa tarefa requer acesso administrativo à IAM.

Cada usuário que acessa um painel assume uma função que lhe dá acesso e permissões ao Amazon Quick Sight para o painel. Para tornar isso possível, crie uma função do IAM em seu Conta da AWS. Associe uma política do IAM à função, para fornecer permissões a qualquer usuário que a assumir.

É possível criar uma condição na política do IAM que limite os domínios que os desenvolvedores podem listar no parâmetro `AllowedDomains` de uma operação de API `GenerateEmbedUrlForAnonymousUser`. O parâmetro `AllowedDomains` é opcional. Ele concede a você, como desenvolvedor, a opção de substituir os domínios estáticos que estão configurados no menu Manage **Amazon Quick Sight**. Em vez disso, é possível listar até três domínios ou subdomínios que podem acessar um URL gerado. Em seguida, este URL será incorporado ao site que você criar. Somente os domínios listados no parâmetro podem acessar o painel incorporado. Sem essa condição, você pode listar qualquer domínio da Internet no parâmetro `AllowedDomains`. 

Para limitar os domínios que os desenvolvedores podem usar com esse parâmetro, adicione uma condição `AllowedEmbeddingDomains` à política do IAM. Para obter mais informações sobre o `AllowedDomains` parâmetro, consulte [GenerateEmbedUrlForAnonymousUser](https://docs.aws.amazon.com//quicksight/latest/APIReference/API_GenerateEmbedUrlForAnonymousUser.html)a *Amazon Quick Sight API Reference*.

**Prática recomendada de segurança para operadores de condições do IAM**  
Operadores de condição do IAM configurados incorretamente podem permitir acesso não autorizado aos seus recursos incorporados do Quick por meio de variações de URL. Ao usar a chave de `quicksight:AllowedEmbeddingDomains` condição em suas políticas do IAM, use operadores de condição que permitem domínios específicos ou negam todos os domínios que não são especificamente permitidos. Para obter mais informações sobre operadores de condição do IAM, consulte [Elementos de política JSON do IAM: operadores de condição](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_elements_condition_operators.html) no Guia do usuário do IAM.  
Muitas variações diferentes de URL podem apontar para o mesmo recurso. Por exemplo, URLs todos os itens a seguir têm o mesmo conteúdo:  
`https://example.com`
`https://example.com/`
`https://Example.com`
Se sua política usa operadores que não levam em conta essas variações de URL, um invasor pode contornar suas restrições fornecendo variações de URL equivalentes.  
Você deve validar se sua política do IAM usa operadores de condição apropriados para evitar ignorar vulnerabilidades e garantir que somente os domínios pretendidos possam acessar seus recursos incorporados.

O exemplo de política apresentado a seguir fornece essas permissões para uso com `GenerateEmbedUrlForAnonymousUser`. Para que essa abordagem funcione, você também precisa de um pacote de sessões, ou de uma definição de preço da capacidade de sessão, para sua Conta da AWS. Caso contrário, quando um usuário tentar acessar o painel, o erro `UnsupportedPricingPlanException` será retornado. 

A identidade do IAM da sua aplicação deve ter uma política de confiança associada a ela, para permitir acesso ao perfil que você acabou de criar. Isso significa que, quando um usuário acessar a aplicação, ele poderá assumir o perfil em nome do usuário para abrir o painel. O exemplo apresentado a seguir mostra um exemplo de política de confianç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"
    }
]
}
```

------

Para obter mais informações sobre as políticas de confiança, consulte [Credenciais de segurança temporárias no IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_temp.html) no *Guia do usuário do IAM*.

## Etapa 2: gerar o URL com o código de autenticação anexado
<a name="embedded-analytics-dashboards-with-anonymous-users-step-2"></a>


|  | 
| --- |
|  Aplica-se a: Enterprise Edition  | 


|  | 
| --- |
|    Público-alvo: desenvolvedores do Amazon Quick  | 

Na seção apresentada a seguir, você descobrirá como realizar a autenticação em nome do visitante anônimo e obter o URL do painel incorporável em seu servidor de aplicações. 

Quando um usuário acessa a aplicação, ela assume o perfil do IAM em nome do usuário. Em seguida, ele adiciona o usuário ao Amazon Quick Sight, se esse usuário ainda não existir. Depois disso, ela transfere um identificador como o ID exclusivo de sessão do usuário. 

Os exemplos a seguir executam a autenticação do IAM em nome do usuário. Um identificador é transferido como o ID exclusivo de sessão do usuário. Este código é executado no servidor da aplicação.

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

O exemplo a seguir mostra o JavaScript (Node.js) que você pode usar no servidor do aplicativo para gerar a URL para o painel incorporado. Você pode usar esse URL no seu site ou aplicativo para exibir o painel. 

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

O exemplo a seguir mostra o código em .NET/C\$1 que você pode usar no servidor de aplicações para gerar o URL para o painel incorporado. Você pode usar esse URL no seu site ou aplicativo para exibir o painel. 

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

Para assumir a função, escolha uma das seguintes operações de API AWS Security Token Service (AWS STS):
+ [AssumeRole](https://docs.aws.amazon.com/STS/latest/APIReference/API_AssumeRole.html)— Use essa operação quando estiver usando uma identidade do IAM para assumir a função.
+ [AssumeRoleWithWebIdentity](https://docs.aws.amazon.com/STS/latest/APIReference/API_AssumeRoleWithWebIdentity.html)— Use essa operação quando estiver usando um provedor de identidade da web para autenticar seu usuário. 
+ [AssumeRoleWithSaml](https://docs.aws.amazon.com/STS/latest/APIReference/API_AssumeRoleWithSAML.html)— Use essa operação quando estiver usando a Security Assertion Markup Language (SAML) para autenticar seus usuários.

O exemplo a seguir mostra o comando da CLI que define a função do IAM. O perfil precisa ter permissões habilitadas para `quicksight:GenerateEmbedUrlForAnonymousUser`. 

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

A operação `assume-role` retorna três parâmetros de saída: a chave de acesso, a chave secreta e o token da sessão. 

**nota**  
Se você receber um erro `ExpiredToken` ao chamar a operação `AssumeRole`, isso provavelmente ocorre porque o `SESSION TOKEN` anterior ainda está nas variáveis de ambiente. Resolva isso definindo as seguintes variáveis:  
*AWS\$1ACCESS\$1KEY\$1ID* 
*AWS\$1SECRET\$1CHAVE DE ACESSO* 
*AWS\$1SESSION\$1TOKEN* 

O exemplo a seguir mostra como definir esses três parâmetros na CLI. Se você estiver usando uma máquina com Microsoft Windows, use `set` em vez de `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"
```

Executar esses comandos define o ID da sessão da função do usuário que está acessando o site `embedding_quicksight_dashboard_role/QuickSightEmbeddingAnonymousPolicy`. O ID da sessão da função é composto pelo nome da função a partir de `role-arn` e o valor de `role-session-name`. Usar o ID exclusivo de sessão do perfil para cada usuário garante que as permissões apropriadas sejam definidas para todos os usuários visitantes. Essa ação também mantém cada sessão separada e distinta. Se você estiver usando uma série de servidores Web, por exemplo, para balanceamento de carga, e uma sessão for reconectada a um servidor diferente, uma nova sessão será iniciada.

Para obter um URL assinado para o painel, chame `generate-embed-url-for-anynymous-user` usando o servidor de aplicações. Isso retorna o URL do painel incorporável. O exemplo a seguir mostra como gerar o URL para um painel incorporado usando uma chamada do lado do servidor para usuários que estão fazendo visitas anônimas ao seu portal da Web ou à sua aplicação.

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

Para obter mais informações sobre o uso dessa operação, consulte [https://docs.aws.amazon.com/quicksight/latest/APIReference/API_GenerateEmbedUrlForAnonymousUser.html](https://docs.aws.amazon.com/quicksight/latest/APIReference/API_GenerateEmbedUrlForAnonymousUser.html). Você pode usar essa e outras operações de API no seu próprio código. 

## Etapa 3: incorporar o URL do painel
<a name="embedded-analytics-dashboards-with-anonymous-users-step-3"></a>


|  | 
| --- |
|  Aplica-se a: Enterprise Edition  | 


|  | 
| --- |
|    Público-alvo: desenvolvedores do Amazon Quick  | 

Na seção a seguir, você pode descobrir como usar o [Amazon Quick Sight Embedding SDK](https://www.npmjs.com/package/amazon-quicksight-embedding-sdk) (JavaScript) para incorporar a URL do painel a partir da etapa 2 em seu site ou página de aplicativo. Com o SDK, você pode fazer o seguinte: 
+ Coloque o painel em uma página HTML.
+ Adicione parâmetros ao painel.
+ Corrija os estados de erro com mensagens que são personalizados para seu aplicativo.

Chame a operação de API `GenerateEmbedUrlForAnynymousUser` para gerar o URL que você pode incorporar à aplicação. Este URL é válido por 5 minutos, e a sessão resultante é válida por 10 horas. A operação de API fornece ao URL um `auth_code` que possibilita uma sessão de logon único. 

Veja a seguir uma resposta de exemplo de `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"
        }
```

Incorpore esse painel em sua página da web usando o [Amazon Quick Sight Embedding SDK](https://www.npmjs.com/package/amazon-quicksight-embedding-sdk) ou adicionando essa URL em um iframe. Se você definir um número fixo de altura e largura (em pixels), o Amazon Quick Sight os usará e não alterará seu visual à medida que sua janela é redimensionada. Se você definir uma porcentagem relativa de altura e largura, o Amazon Quick Sight fornece um layout responsivo que é modificado conforme o tamanho da janela muda. Ao usar o Amazon Quick Sight Embedding SDK, você também pode controlar os parâmetros no painel e receber retornos de chamada em termos de conclusão do carregamento da página e erros. 

O domínio que hospedará os painéis incorporados deverá estar na *lista de permissão*, a lista de domínios aprovados para a sua assinatura do Quick . Esse requisito protege seus dados, impedindo que domínios não aprovados hospedem painéis incorporados. Para obter mais informações sobre a adição de domínios para painéis incorporados, consulte [Permitir a listagem de domínios em tempo de execução com a API Amazon Quick](https://docs.aws.amazon.com/quicksight/latest/user/embedding-run-time.html) Sight.

O exemplo a seguir mostra como usar o URL gerado. Este código reside no seu servidor de aplicações.

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

Para que este exemplo funcione, certifique-se de usar o Amazon Quick Sight Embedding SDK para carregar o painel incorporado em seu site usando. JavaScript Para obter sua cópia, siga um destes procedimentos:
+ Baixe o [Amazon Quick Sight Embedding SDK](https://github.com/awslabs/amazon-quicksight-embedding-sdk#step-3-create-the-quicksight-session-object) em. GitHub Esse repositório é mantido por um grupo de desenvolvedores do Amazon Quick Sight.
+ Baixe a versão mais recente do Amazon Quick Sight Embedding SDK em. [https://www.npmjs.com/package/amazon-quicksight-embedding-sdk](https://www.npmjs.com/package/amazon-quicksight-embedding-sdk)
+ Se você usa `npm` para JavaScript dependências, faça o download e instale-o executando o comando a seguir.

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

# Como habilitar resumos executivos em painéis incorporados
<a name="embedded-analytics-genbi-executive-summaries-dashboard"></a>


|  | 
| --- |
|  Aplica-se a: Enterprise Edition  | 


|  | 
| --- |
|    Público-alvo: desenvolvedores do Amazon Quick  | 

Você pode habilitar resumos executivos em seus painéis incorporados. Quando ativados, os usuários registrados podem gerar resumos executivos que fornecem um resumo de todos os insights que o Amazon Quick Sight gerou para o painel. Os resumos executivos permitem que os leitores encontrem com mais facilidade os principais insights e informações sobre um painel. Para obter mais informações sobre como os usuários geram um resumo executivo de um painel, consulte [Gerar um resumo executivo de um painel do Amazon Quick Sight](https://docs.aws.amazon.com/quicksight/latest/user/use-executive-summaries.html).

**nota**  
Os resumos executivos só estão disponíveis em painéis incorporados para usuários registrados e não podem ser habilitados em painéis incorporados para usuários anônimos ou não registrados.

**Para habilitar resumos executivos em painéis incorporados para usuários registrados**
+ Siga as etapas em [Incorporação de painéis do Amazon Quick Sight para que usuários registrados incorporem](https://docs.aws.amazon.com/quicksight/latest/user/embedded-analytics-dashboards-for-authenticated-users.html) um painel com as seguintes alterações:

  1. Ao gerar o URL na Etapa 2, `Enabled: true` defina o `ExecutiveSummary` parâmetro no [GenerateEmbedUrlForRegisteredUser](https://docs.aws.amazon.com/quicksight/latest/APIReference/API_GenerateEmbedUrlForRegisteredUser.html)ou [GenerateEmbedUrlForRegisteredUserWithIdentity](https://docs.aws.amazon.com/quicksight/latest/APIReference/API_GenerateEmbedUrlForRegisteredUserWithIdentity.html)conforme mostrado no exemplo a seguir:

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

  1. Ao incorporar o URL do painel com o Amazon Quick Sight Embedding SDK na Etapa 3, configure-o`contentOptions`, conforme mostrado `executiveSummary: true` no exemplo a seguir:

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

# Incorporando imagens do Amazon Quick Sight com o Amazon Quick Sight APIs
<a name="embedding-visuals"></a>

Você pode incorporar imagens individuais que fazem parte de um painel publicado em seu aplicativo com a API Amazon Quick Sight.

**Topics**
+ [

# Incorporação de imagens do Amazon Quick Sight para usuários registrados
](embedded-analytics-visuals-for-authenticated-users.md)
+ [

# Incorporação de imagens do Amazon Quick Sight para usuários anônimos (não registrados)
](embedded-analytics-visuals-for-everyone.md)

# Incorporação de imagens do Amazon Quick Sight para usuários registrados
<a name="embedded-analytics-visuals-for-authenticated-users"></a>


|  | 
| --- |
|  Aplica-se a: Enterprise Edition  | 


|  | 
| --- |
|    Público-alvo: desenvolvedores do Amazon Quick  | 

Nas seções a seguir, você encontrará informações detalhadas sobre como configurar imagens incorporadas do Amazon Quick Sight para usuários registrados do Amazon Quick Sight.

**Topics**
+ [

## Etapa 1: configurar permissões
](#embedded-visuals-for-authenticated-users-step-1)
+ [

## Etapa 2: gerar o URL com o código de autenticação anexado
](#embedded-visuals-for-authenticated-users-step-2)
+ [

## Etapa 3: incorporar o URL de um elemento visual
](#embedded-visuals-for-authenticated-users-step-3)

## Etapa 1: configurar permissões
<a name="embedded-visuals-for-authenticated-users-step-1"></a>

Na seção a seguir, você descobrirá como configurar permissões para a aplicação de back-end ou para o servidor Web. Essa tarefa requer acesso administrativo à IAM.

Cada usuário que acessa um visual assume uma função que lhe dá acesso e permissões ao Amazon Quick Sight para o visual. Para tornar isso possível, crie uma função do IAM em seu Conta da AWS. Associe uma política do IAM à função, para fornecer permissões a qualquer usuário que a assumir. A função do IAM precisa fornecer permissões para recuperar a incorporação de um URLs grupo de usuários específico. Com a ajuda do caractere curinga *\$1*, é possível conceder as permissões para a geração de um URL para todos os usuários em um namespace específico ou para um subconjunto de usuários em namespaces específicos. Para isso, você adiciona `quicksight:GenerateEmbedUrlForRegisteredUser`.

É possível criar uma condição na política do IAM que limite os domínios que os desenvolvedores podem listar no parâmetro `AllowedDomains` de uma operação de API `GenerateEmbedUrlForAnonymousUser`. O parâmetro `AllowedDomains` é opcional. Ele concede a você, como desenvolvedor, a opção de substituir os domínios estáticos que estão configurados no menu Manage **Amazon Quick Sight**. Em vez disso, é possível listar até três domínios ou subdomínios que podem acessar um URL gerado. Em seguida, este URL será incorporado ao site que você criar. Somente os domínios listados no parâmetro podem acessar o painel incorporado. Sem essa condição, você pode listar qualquer domínio da Internet no parâmetro `AllowedDomains`. 

Para limitar os domínios que os desenvolvedores podem usar com esse parâmetro, adicione uma condição `AllowedEmbeddingDomains` à política do IAM. Para obter mais informações sobre o `AllowedDomains` parâmetro, consulte [GenerateEmbedUrlForRegisteredUser](https://docs.aws.amazon.com//quicksight/latest/APIReference/API_GenerateEmbedUrlForRegisteredUser.html)a *Amazon Quick Sight API Reference*.

**Prática recomendada de segurança para operadores de condições do IAM**  
Operadores de condição do IAM configurados incorretamente podem permitir acesso não autorizado aos seus recursos incorporados do Quick por meio de variações de URL. Ao usar a chave de `quicksight:AllowedEmbeddingDomains` condição em suas políticas do IAM, use operadores de condição que permitem domínios específicos ou negam todos os domínios que não são especificamente permitidos. Para obter mais informações sobre operadores de condição do IAM, consulte [Elementos de política JSON do IAM: operadores de condição](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_elements_condition_operators.html) no Guia do usuário do IAM.  
Muitas variações diferentes de URL podem apontar para o mesmo recurso. Por exemplo, URLs todos os itens a seguir têm o mesmo conteúdo:  
`https://example.com`
`https://example.com/`
`https://Example.com`
Se sua política usa operadores que não levam em conta essas variações de URL, um invasor pode contornar suas restrições fornecendo variações de URL equivalentes.  
Você deve validar se sua política do IAM usa operadores de condição apropriados para evitar ignorar vulnerabilidades e garantir que somente os domínios pretendidos possam acessar seus recursos incorporados.

O modelo de política a seguir fornece essas permissões.

Além disso, se você estiver criando usuários iniciantes que serão leitores do Amazon Quick Sight, certifique-se de adicionar a `quicksight:RegisterUser` permissão na política.

O exemplo de política a seguir fornece permissão para recuperar uma URL de incorporação para usuários iniciantes que serão leitores do Amazon Quick Sight.

Por fim, a identidade do IAM da sua aplicação deve ter uma política de confiança associada a ela, para permitir acesso ao perfil que você acabou de criar. Isso significa que quando um usuário acessa seu aplicativo, seu aplicativo pode assumir a função em nome do usuário e provisionar o usuário no Amazon Quick Sight. O exemplo apresentado a seguir mostra um exemplo de política de confianç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"
        }
    ]
}
```

------

Para mais informações sobre as políticas de confiança para autenticação SAML ou OpenId Connect, consulte as seguintes seções do *Guia do usuário do IAM: *
+ [Criação de uma função para identidades da Web ou federação do OpenID Connect (Console)](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_create_for-idp_oidc.html)
+ [Criação de uma função para uma federação do SAML 2.0 (console)](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_create_for-idp_saml.html)

## Etapa 2: gerar o URL com o código de autenticação anexado
<a name="embedded-visuals-for-authenticated-users-step-2"></a>

Na seção a seguir, você pode descobrir como autenticar seu usuário do Amazon Quick Sight e obter a URL visual incorporável em seu servidor de aplicativos. Se você planeja incorporar elementos visuais para os tipos de identidade IAM ou Amazon Quick Sight, compartilhe o visual com os usuários do Amazon Quick Sight.

Quando um usuário do Amazon Quick Sight acessa seu aplicativo, o aplicativo assume a função do IAM em nome do usuário do Amazon Quick Sight. Em seguida, ele adiciona o usuário ao Amazon Quick Sight, se esse usuário do Amazon Quick Sight ainda não existir. Depois disso, ela transfere um identificador como o ID exclusivo de sessão do usuário. 

A execução das etapas descritas garante que cada visualizador do visual seja provisionado de forma exclusiva no Amazon Quick Sight. Ele também aplica as configurações por usuário, como a segurança em nível de linha e padrões dinâmicos para os parâmetros.

Os exemplos a seguir realizam a autenticação do IAM em nome do usuário do Amazon Quick Sight. Este código é executado no servidor da aplicação.

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

O exemplo a seguir mostra o JavaScript (Node.js) que você pode usar no servidor do aplicativo para gerar a URL para o painel incorporado. Você pode usar esse URL no seu site ou aplicativo para exibir o painel. 

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

O exemplo a seguir mostra o código em .NET/C\$1 que você pode usar no servidor de aplicações para gerar o URL para o painel incorporado. Você pode usar esse URL no seu site ou aplicativo para exibir o painel. 

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

Para assumir a função, escolha uma das seguintes operações de API AWS Security Token Service (AWS STS):
+ [AssumeRole](https://docs.aws.amazon.com/STS/latest/APIReference/API_AssumeRole.html)— Use essa operação quando estiver usando uma identidade do IAM para assumir a função.
+ [AssumeRoleWithWebIdentity](https://docs.aws.amazon.com/STS/latest/APIReference/API_AssumeRoleWithWebIdentity.html)— Use essa operação quando estiver usando um provedor de identidade da web para autenticar seu usuário. 
+ [AssumeRoleWithSaml](https://docs.aws.amazon.com/STS/latest/APIReference/API_AssumeRoleWithSAML.html)— Use essa operação quando estiver usando SAML para autenticar seus usuários.

O exemplo a seguir mostra o comando da CLI que define a função do IAM. O perfil precisa ter permissões habilitadas para `quicksight:GenerateEmbedUrlForRegisteredUser`. Se você estiver adotando uma just-in-time abordagem para adicionar usuários quando eles abrem um painel pela primeira vez, a função também precisa de permissões habilitadas`quicksight:RegisterUser`.

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

A operação `assume-role` retorna três parâmetros de saída: a chave de acesso, a chave secreta e o token da sessão. 

**nota**  
Se você receber um erro `ExpiredToken` ao chamar a operação `AssumeRole`, isso provavelmente ocorre porque o `SESSION TOKEN` anterior ainda está nas variáveis de ambiente. Resolva isso definindo as seguintes variáveis:  
*AWS\$1ACCESS\$1KEY\$1ID* 
*AWS\$1SECRET\$1CHAVE DE ACESSO* 
*AWS\$1SESSION\$1TOKEN* 

O exemplo a seguir mostra como definir esses três parâmetros na CLI. Se você estiver usando uma máquina com Microsoft Windows, use `set` em vez de `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"
```

Executar esses comandos define o ID da sessão da função do usuário que está acessando o site `embedding_quicksight_visual_role/john.doe@example.com`. O ID da sessão da função é composto pelo nome da função a partir de `role-arn` e o valor de `role-session-name`. Usando o ID único da sessão da função para cada usuário garante que as permissões apropriadas sejam definidas para cada usuário. Isso também impede qualquer limitação do acesso do usuário. *A limitação* é um recurso de segurança que impede que o mesmo usuário acesse o Amazon Quick Sight de vários locais. 

O ID da sessão da função também se torna o nome de usuário no Amazon Quick Sight. Você pode usar esse padrão para provisionar seus usuários no Amazon Quick Sight com antecedência ou para provisioná-los na primeira vez que acessarem o painel. 

O exemplo a seguir mostra o comando da CLI que você pode usar para provisionar um usuário. Para obter mais informações sobre [RegisterUser](https://docs.aws.amazon.com/quicksight/latest/APIReference/API_RegisterUser.html), [DescribeUser](https://docs.aws.amazon.com/quicksight/latest/APIReference/API_DescribeUser.html), e outras operações da API Amazon Quick Sight, consulte a [Referência da 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
```

Se o usuário for autenticado por meio do Microsoft AD, você não precisará usar o `RegisterUser` para configurá-lo. Em vez disso, eles devem ser automaticamente inscritos na primeira vez que acessarem o Amazon Quick Sight. Para usuários do Microsoft AD, você pode usar o `DescribeUser` para obter o ARN do usuário.

Na primeira vez que um usuário acessa o Amazon Quick Sight, você também pode adicionar esse usuário ao grupo com o qual o visual é compartilhado. O exemplo a seguir mostra o comando da CLI para adicionar um usuário a um grupo.

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

Agora você tem um usuário do seu aplicativo que também é usuário do Amazon Quick Sight e que tem acesso ao visual. 

Por fim, para obter um URL assinado para o elemento visual, chame `generate-embed-url-for-registered-user` usando o servidor de aplicações. Isso retorna o URL do elemento visual incorporável. O exemplo a seguir mostra como gerar a URL para um visual incorporado usando uma chamada do lado do servidor para usuários autenticados por meio de um login único ( AWS Managed Microsoft AD 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}}'
```

Para obter mais informações sobre o uso dessa operação, consulte [https://docs.aws.amazon.com/quicksight/latest/APIReference/API_GenerateEmbedUrlForRegisteredUser.html](https://docs.aws.amazon.com/quicksight/latest/APIReference/API_GenerateEmbedUrlForRegisteredUser.html). Você pode usar essa e outras operações de API no seu próprio código.

## Etapa 3: incorporar o URL de um elemento visual
<a name="embedded-visuals-for-authenticated-users-step-3"></a>

Na seção a seguir, você pode descobrir como usar o [Amazon Quick Sight Embedding SDK](https://www.npmjs.com/package/amazon-quicksight-embedding-sdk) (JavaScript) para incorporar a URL visual da etapa 3 em seu site ou página de aplicativo. Com o SDK, você pode fazer o seguinte: 
+ Estabeleça o elemento visual em uma página HTML.
+ Adicione os parâmetros para o elemento visual.
+ Corrija os estados de erro com mensagens que são personalizados para seu aplicativo.

Chame a operação de API `GenerateEmbedUrlForRegisteredUser` para gerar o URL que você pode incorporar à aplicação. Esse URL é válido por cinco minutos e a sessão resultante é válida por, no máximo, dez horas. A operação de API fornece ao URL um `auth_code` que possibilita uma sessão de logon único. 

Veja a seguir uma resposta de exemplo de `generate-embed-url-for-registered-user`. `quicksightdomain`Neste exemplo, é a URL que você usa para acessar sua conta do Amazon Quick Sight.

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

Incorpore esse visual em sua página da web usando o [Amazon Quick Sight Embedding SDK](https://www.npmjs.com/package/amazon-quicksight-embedding-sdk) ou adicionando essa URL em um iframe. Se você definir um número fixo de altura e largura (em pixels), o Amazon Quick Sight os usará e não alterará seu visual à medida que sua janela é redimensionada. Se você definir uma porcentagem relativa de altura e largura, o Amazon Quick Sight fornece um layout responsivo que é modificado conforme o tamanho da janela muda. Ao usar o Amazon Quick Sight Embedding SDK, você também pode controlar parâmetros dentro do visual e receber retornos de chamada em termos de conclusão do carregamento da página e erros. 

O domínio que hospedará recursos visuais e painéis incorporados deve estar na lista de *permissões, a lista* de domínios aprovados para sua assinatura. Quick Este requisito protege seus dados, impedindo que domínios não aprovados hospedem elementos visuais e painéis incorporados. Para obter mais informações sobre a adição de domínios para recursos visuais e painéis incorporados, consulte [Permitir a listagem de domínios em tempo de execução com a API Amazon](https://docs.aws.amazon.com/quicksight/latest/user/embedding-run-time.html) Quick Sight.

O exemplo a seguir mostra como usar o URL gerado. Este código é gerado no seu servidor de aplicações.

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

Para que este exemplo funcione, certifique-se de usar o Amazon Quick Sight Embedding SDK para carregar o visual incorporado em seu site usando. JavaScript Para obter sua cópia, siga um destes procedimentos:
+ Baixe o [Amazon Quick Sight Embedding SDK](https://github.com/awslabs/amazon-quicksight-embedding-sdk#step-3-create-the-quicksight-session-object) em. GitHub Esse repositório é mantido por um grupo de desenvolvedores do Amazon Quick Sight.
+ Baixe a versão mais recente do SDK de incorporação em. [https://www.npmjs.com/package/amazon-quicksight-embedding-sdk](https://www.npmjs.com/package/amazon-quicksight-embedding-sdk)
+ Se você usa `npm` para JavaScript dependências, faça o download e instale-o executando o comando a seguir.

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

# Incorporação de imagens do Amazon Quick Sight para usuários anônimos (não registrados)
<a name="embedded-analytics-visuals-for-everyone"></a>


|  | 
| --- |
|  Aplica-se a: Enterprise Edition  | 


|  | 
| --- |
|    Público-alvo: desenvolvedores do Amazon Quick  | 

Nas seções a seguir, você encontrará informações detalhadas sobre como configurar imagens incorporadas do Amazon Quick Sight para usuários anônimos (não registrados).

**Topics**
+ [

## Etapa 1: configurar permissões
](#embedded-analytics-visuals-with-anonymous-users-step-1)
+ [

## Etapa 2: gerar o URL com o código de autenticação anexado
](#embedded-analytics-visuals-with-anonymous-users-step-2)
+ [

## Etapa 3: incorporar o URL de um elemento visual
](#embedded-analytics-visuals-with-anonymous-users-step-3)

## Etapa 1: configurar permissões
<a name="embedded-analytics-visuals-with-anonymous-users-step-1"></a>


|  | 
| --- |
|  Aplica-se a: Enterprise Edition  | 


|  | 
| --- |
|    Público-alvo: desenvolvedores do Amazon Quick  | 

Na seção a seguir, você descobrirá como configurar permissões para a aplicação de back-end ou para o servidor Web. Essa tarefa requer acesso administrativo à IAM.

Cada usuário que acessa um visual assume uma função que lhe dá acesso e permissões ao Amazon Quick Sight para o visual. Para tornar isso possível, crie uma função do IAM em seu Conta da AWS. Associe uma política do IAM à função, para fornecer permissões a qualquer usuário que a assumir.

É possível criar uma condição na política do IAM que limite os domínios que os desenvolvedores podem listar no parâmetro `AllowedDomains` de uma operação de API `GenerateEmbedUrlForAnonymousUser`. O parâmetro `AllowedDomains` é opcional. Ele concede a você, como desenvolvedor, a opção de substituir os domínios estáticos que estão configurados no menu Manage **Amazon Quick Sight**. Em vez disso, é possível listar até três domínios ou subdomínios que podem acessar um URL gerado. Em seguida, este URL será incorporado ao site que você criar. Somente os domínios listados no parâmetro podem acessar o painel incorporado. Sem essa condição, você pode listar qualquer domínio da Internet no parâmetro `AllowedDomains`. 

Para limitar os domínios que os desenvolvedores podem usar com esse parâmetro, adicione uma condição `AllowedEmbeddingDomains` à política do IAM. Para obter mais informações sobre o `AllowedDomains` parâmetro, consulte [GenerateEmbedUrlForAnonymousUser](https://docs.aws.amazon.com//quicksight/latest/APIReference/API_GenerateEmbedUrlForAnonymousUser.html)a *Amazon Quick Sight API Reference*.

**Prática recomendada de segurança para operadores de condições do IAM**  
Operadores de condição do IAM configurados incorretamente podem permitir acesso não autorizado aos recursos incorporados do Quick por meio de variações de URL. Ao usar a chave de `quicksight:AllowedEmbeddingDomains` condição em suas políticas do IAM, use operadores de condição que permitem domínios específicos ou negam todos os domínios que não são especificamente permitidos. Para obter mais informações sobre operadores de condição do IAM, consulte [Elementos de política JSON do IAM: operadores de condição](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_elements_condition_operators.html) no Guia do usuário do IAM.  
Muitas variações diferentes de URL podem apontar para o mesmo recurso. Por exemplo, URLs todos os itens a seguir têm o mesmo conteúdo:  
`https://example.com`
`https://example.com/`
`https://Example.com`
Se sua política usa operadores que não levam em conta essas variações de URL, um invasor pode contornar suas restrições fornecendo variações de URL equivalentes.  
Você deve validar se sua política do IAM usa operadores de condição apropriados para evitar ignorar vulnerabilidades e garantir que somente os domínios pretendidos possam acessar seus recursos incorporados.

A identidade do IAM da sua aplicação deve ter uma política de confiança associada a ela, para permitir acesso ao perfil que você acabou de criar. Isso significa que, quando um usuário acessar a aplicação, ele poderá assumir o perfil em nome do usuário para abrir o elemento visual. O exemplo apresentado a seguir mostra um exemplo de política de confianç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"
        }
    ]
}
```

------

Para obter mais informações sobre as políticas de confiança, consulte [Credenciais de segurança temporárias no IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_temp.html) no *Guia do usuário do IAM*.

## Etapa 2: gerar o URL com o código de autenticação anexado
<a name="embedded-analytics-visuals-with-anonymous-users-step-2"></a>


|  | 
| --- |
|  Aplica-se a: Enterprise Edition  | 


|  | 
| --- |
|    Público-alvo: desenvolvedores do Amazon Quick  | 

Na seção apresentada a seguir, você descobrirá como realizar a autenticação em nome do visitante anônimo e obter o URL do elemento visual incorporável em seu servidor de aplicações.

Quando um usuário acessa a aplicação, ela assume o perfil do IAM em nome do usuário. Em seguida, ele adiciona o usuário ao Amazon Quick Sight, se esse usuário ainda não existir. Depois disso, ela transfere um identificador como o ID exclusivo de sessão do usuário. 

Os exemplos a seguir executam a autenticação do IAM em nome do usuário. Um identificador é transferido como o ID exclusivo de sessão do usuário. Este código é executado no servidor da aplicação.

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

O exemplo a seguir mostra o JavaScript (Node.js) que você pode usar no servidor do aplicativo para gerar a URL para o painel incorporado. Você pode usar esse URL no seu site ou aplicativo para exibir o painel. 

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

O exemplo a seguir mostra o código em .NET/C\$1 que você pode usar no servidor de aplicações para gerar o URL para o painel incorporado. Você pode usar esse URL no seu site ou aplicativo para exibir o painel. 

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

Para assumir a função, escolha uma das seguintes operações de API AWS Security Token Service (AWS STS):
+ [AssumeRole](https://docs.aws.amazon.com/STS/latest/APIReference/API_AssumeRole.html)— Use essa operação quando estiver usando uma identidade do IAM para assumir a função.
+ [AssumeRoleWithWebIdentity](https://docs.aws.amazon.com/STS/latest/APIReference/API_AssumeRoleWithWebIdentity.html)— Use essa operação quando estiver usando um provedor de identidade da web para autenticar seu usuário. 
+ [AssumeRoleWithSaml](https://docs.aws.amazon.com/STS/latest/APIReference/API_AssumeRoleWithSAML.html)— Use essa operação quando estiver usando a Security Assertion Markup Language (SAML) para autenticar seus usuários.

O exemplo a seguir mostra o comando da CLI que define a função do IAM. O perfil precisa ter permissões habilitadas para `quicksight:GenerateEmbedUrlForAnonymousUser`. 

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

A operação `assume-role` retorna três parâmetros de saída: a chave de acesso, a chave secreta e o token da sessão. 

**nota**  
Se você receber um erro `ExpiredToken` ao chamar a operação `AssumeRole`, isso provavelmente ocorre porque o `SESSION TOKEN` anterior ainda está nas variáveis de ambiente. Resolva isso definindo as seguintes variáveis:  
*AWS\$1ACCESS\$1KEY\$1ID* 
*AWS\$1SECRET\$1CHAVE DE ACESSO* 
*AWS\$1SESSION\$1TOKEN* 

O exemplo a seguir mostra como definir esses três parâmetros na CLI. Se você estiver usando uma máquina com Microsoft Windows, use `set` em vez de `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"
```

Executar esses comandos define o ID da sessão da função do usuário que está acessando o site `embedding_quicksight_visual_role/QuickSightEmbeddingAnonymousPolicy`. O ID da sessão da função é composto pelo nome da função a partir de `role-arn` e o valor de `role-session-name`. Usar o ID exclusivo de sessão do perfil para cada usuário garante que as permissões apropriadas sejam definidas para todos os usuários visitantes. Essa ação também mantém cada sessão separada e distinta. Se você estiver usando uma série de servidores Web, por exemplo, para balanceamento de carga, e uma sessão for reconectada a um servidor diferente, uma nova sessão será iniciada.

Para obter um URL assinado para o elemento visual, chame `generate-embed-url-for-anynymous-user` usando o servidor de aplicações. Isso retorna o URL do elemento visual incorporável. O exemplo a seguir mostra como gerar o URL para um elemento visual incorporado usando uma chamada do lado do servidor para usuários que estão fazendo visitas anônimas ao seu portal da Web ou à sua aplicação.

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

Para obter mais informações sobre o uso dessa operação, consulte [https://docs.aws.amazon.com/quicksight/latest/APIReference/API_GenerateEmbedUrlForAnonymousUser.html](https://docs.aws.amazon.com/quicksight/latest/APIReference/API_GenerateEmbedUrlForAnonymousUser.html). Você pode usar essa e outras operações de API no seu próprio código. 

## Etapa 3: incorporar o URL de um elemento visual
<a name="embedded-analytics-visuals-with-anonymous-users-step-3"></a>


|  | 
| --- |
|  Aplica-se a: Enterprise Edition  | 


|  | 
| --- |
|    Público-alvo: desenvolvedores do Amazon Quick  | 

Na seção a seguir, você pode descobrir como usar o [Amazon Quick Sight Embedding SDK](https://www.npmjs.com/package/amazon-quicksight-embedding-sdk) (JavaScript) para incorporar a URL visual da etapa 2 em seu site ou página de aplicativo. Com o SDK, você pode fazer o seguinte: 
+ Estabeleça o elemento visual em uma página HTML.
+ Adicione os parâmetros para o elemento visual.
+ Corrija os estados de erro com mensagens que são personalizados para seu aplicativo.

Chame a operação de API `GenerateEmbedUrlForAnonymousUser` para gerar o URL que você pode incorporar à aplicação. Este URL é válido por 5 minutos, e a sessão resultante é válida por 10 horas. A operação de API fornece ao URL um código de autorização (auth) que possibilita uma sessão de logon único. 

Veja a seguir uma resposta de exemplo de `generate-embed-url-for-anonymous-user`. `quicksightdomain`Neste exemplo, é a URL que você usa para acessar sua conta do Amazon Quick Sight.

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

Incorpore esse visual em sua página da web usando o Amazon Quick Sight [Embedding SDK](https://www.npmjs.com/package/amazon-quicksight-embedding-sdk) ou adicionando essa URL em um iframe. Se você definir um número fixo de altura e largura (em pixels), o Amazon Quick Sight os usará e não alterará seu visual à medida que sua janela é redimensionada. Se você definir uma porcentagem relativa de altura e largura, o Amazon Quick Sight fornece um layout responsivo que é modificado conforme o tamanho da janela muda. Ao usar o Amazon Quick Sight Embedding SDK, você também pode controlar parâmetros dentro do visual e receber retornos de chamada em termos de conclusão de carga visual e erros. 

O domínio que hospedará os elementos visuais incorporados deverá estar na *lista de permissão*, a lista de domínios aprovados para a sua assinatura do Quick . Este requisito protege seus dados, impedindo que domínios não aprovados hospedem elementos visuais e painéis incorporados. Para obter mais informações sobre a adição de domínios para recursos visuais e painéis incorporados, consulte [Permitir a listagem de domínios em tempo de execução com a API Amazon](https://docs.aws.amazon.com/quicksight/latest/user/embedding-run-time.html) Quick Sight.

O exemplo a seguir mostra como usar o URL gerado. Este código reside no seu servidor de aplicações.

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

Para que este exemplo funcione, certifique-se de usar o Amazon Quick Sight Embedding SDK para carregar o visual incorporado em seu site usando. JavaScript Para obter sua cópia, siga um destes procedimentos:
+ Baixe o [Amazon Quick Sight Embedding SDK](https://github.com/awslabs/amazon-quicksight-embedding-sdk#step-3-create-the-quicksight-session-object) em. GitHub Esse repositório é mantido por um grupo de desenvolvedores do Amazon Quick Sight.
+ Baixe a versão mais recente do SDK QuickSight de incorporação em. [https://www.npmjs.com/package/amazon-quicksight-embedding-sdk](https://www.npmjs.com/package/amazon-quicksight-embedding-sdk)
+ Se você usa `npm` para JavaScript dependências, faça o download e instale-o executando o comando a seguir.

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

# Incorporando a funcionalidade completa do console Amazon Quick Sight para usuários registrados
<a name="embedded-analytics-full-console-for-authenticated-users"></a>

**Importante**  
O Amazon Quick Sight tem novas operações de API para incorporar análises: `GenerateEmbedUrlForAnonymousUser` e. `GenerateEmbedUrlForRegisteredUser`  
Você ainda pode usar as operações de `GetSessionEmbedUrl` API `GetDashboardEmbedUrl` e as operações de API para incorporar painéis e o console do Amazon Quick Sight, mas elas não contêm os recursos de incorporação mais recentes. Para obter mais informações sobre incorporação usando as operações de API antigas, consulte [Incorporação de análises usando as operações de GetSessionEmbedURL API GetDashboardEmbedURL e](https://docs.aws.amazon.com/quicksight/latest/user/embedded-analytics-deprecated.html).


|  | 
| --- |
|  Aplica-se a: Enterprise Edition  | 


|  | 
| --- |
|    Público-alvo: desenvolvedores do Amazon Quick  | 

Com a edição Enterprise, além de fornecer painéis somente para leitura, você também pode fornecer a experiência de console do Amazon Quick Sight em um portal de criação de marca personalizada. Ao usar essa abordagem, você permite que os usuários criem fontes de dados, conjuntos de dados e análises. Na mesma interface, eles podem criar, publicar e visualizar painéis. Se desejar restringir algumas dessas permissões, você também pode fazer isso.

Os usuários que acessam o Amazon Quick Sight por meio de um console incorporado precisam pertencer ao grupo de segurança do autor ou administrador. Os leitores não têm acesso suficiente para usar o console Amazon Quick Sight para criação, independentemente de ele estar incorporado ou fazer parte do Console de gerenciamento da AWS. No entanto, autores e administradores ainda podem acessar painéis incorporados. Se quiser restringir as permissões para alguns dos recursos de criação, você pode adicionar um perfil de permissões personalizado ao usuário com a operação da [UpdateUser](https://docs.aws.amazon.com/quicksight/latest/APIReference/API_UpdateUser.html)API. Use a operação [RegisterUser](https://docs.aws.amazon.com/quicksight/latest/APIReference/API_RegisterUser.html)da API para adicionar um novo usuário com um perfil de permissão personalizado anexado. Para obter mais informações, consulte as seções a seguir:
+ Para obter informações sobre a criação de funções personalizadas por meio da definição de permissões personalizadas do console, consulte [Personalização do acesso ao console do Amazon Quick Sight](https://docs.aws.amazon.com/quicksight/latest/user/customizing-permissions-to-the-quicksight-console.html).
+ [Para obter informações sobre o uso de namespaces para isolar usuários, grupos e ativos do Amazon Quick Sight com multilocação, consulte Amazon Quick Sight Namespaces.](https://docs.aws.amazon.com/quicksight/latest/APIReference/controlling-access.html#namespaces.html)
+ Para obter informações sobre como adicionar sua própria marca a um console incorporado do Amazon Quick Sight, consulte [Uso de temas no Amazon Quick Sight](https://docs.aws.amazon.com/quicksight/latest/user/themes-in-quicksight.html) e as [operações da API de QuickSight temas](https://docs.aws.amazon.com/quicksight/latest/APIReference/qs-assets.html#themes). 

Nas seções a seguir, você encontrará informações detalhadas sobre como configurar painéis incorporados do Amazon Quick Sight para usuários registrados.

**Topics**
+ [

## Etapa 1: configurar permissões
](#embedded-analytics-full-console-for-authenticated-users-step-1)
+ [

## Etapa 2: gerar o URL com o código de autenticação anexado
](#embedded-analytics-full-console-for-authenticated-users-step-2)
+ [

## Etapa 3: incorporar o URL da sessão do console
](#embedded-analytics-full-console-for-authenticated-users-step-3)
+ [

# Como habilitar recursos de BI generativo em consoles incorporados para usuários registrados
](embedding-consoles-genbi.md)

## Etapa 1: configurar permissões
<a name="embedded-analytics-full-console-for-authenticated-users-step-1"></a>

Na seção a seguir, você descobrirá como configurar permissões para a aplicação de back-end ou para o servidor Web. Essa tarefa requer acesso administrativo à IAM.

Cada usuário que acessa um Amazon Quick Sight assume uma função que lhe dá acesso e permissões ao Amazon Quick Sight para a sessão do console. Para tornar isso possível, crie uma função do IAM em sua AWS conta. Associe uma política do IAM à função, para fornecer permissões a qualquer usuário que a assumir. Adicione `quicksight:RegisterUser` permissões para garantir que o leitor possa acessar o Amazon Quick Sight somente para leitura e não tenha acesso a nenhum outro recurso de dados ou criação. A função do IAM também precisa fornecer permissões para recuperar a sessão URLs do console. Para isso, você adiciona `quicksight:GenerateEmbedUrlForRegisteredUser`.

É possível criar uma condição na política do IAM que limite os domínios que os desenvolvedores podem listar no parâmetro `AllowedDomains` de uma operação de API `GenerateEmbedUrlForAnonymousUser`. O parâmetro `AllowedDomains` é opcional. Ele concede a você, como desenvolvedor, a opção de substituir os domínios estáticos que estão configurados no menu Manage **Amazon Quick Sight**. Em vez disso, é possível listar até três domínios ou subdomínios que podem acessar um URL gerado. Em seguida, este URL será incorporado ao site que você criar. Somente os domínios listados no parâmetro podem acessar o painel incorporado. Sem essa condição, você pode listar qualquer domínio da Internet no parâmetro `AllowedDomains`. 

**Prática recomendada de segurança para operadores de condições do IAM**  
Operadores de condição do IAM configurados incorretamente podem permitir acesso não autorizado aos recursos incorporados do Quick por meio de variações de URL. Ao usar a chave de `quicksight:AllowedEmbeddingDomains` condição em suas políticas do IAM, use operadores de condição que permitem domínios específicos ou negam todos os domínios que não são especificamente permitidos. Para obter mais informações sobre operadores de condição do IAM, consulte [Elementos de política JSON do IAM: operadores de condição](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_elements_condition_operators.html) no Guia do usuário do IAM.  
Muitas variações diferentes de URL podem apontar para o mesmo recurso. Por exemplo, URLs todos os itens a seguir têm o mesmo conteúdo:  
`https://example.com`
`https://example.com/`
`https://Example.com`
Se sua política usa operadores que não levam em conta essas variações de URL, um invasor pode contornar suas restrições fornecendo variações de URL equivalentes.  
Você deve validar se sua política do IAM usa operadores de condição apropriados para evitar ignorar vulnerabilidades e garantir que somente os domínios pretendidos possam acessar seus recursos incorporados.

O modelo de política a seguir fornece essas permissões. 

O exemplo de política a seguir fornece permissão para recuperar um URL da sessão do console. Você pode usar a política sem `quicksight:RegisterUser`, se estiver criando usuários antes que eles acessem uma sessão incorporada.

Por fim, a identidade do IAM da sua aplicação deve ter uma política de confiança associada a ela, para permitir acesso ao perfil que você acabou de criar. Isso significa que, quando um usuário acessa seu aplicativo, ele pode assumir a função em nome do usuário e provisioná-lo no Amazon Quick Sight. O exemplo apresentado a seguir mostra um exemplo de política de confianç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"
        }
    ]
}
```

------

Para mais informações sobre as políticas de confiança para autenticação SAML ou OpenId Connect, consulte as seguintes seções do *Guia do usuário do IAM: *
+ [Criação de uma função para identidades da Web ou federação do OpenID Connect (Console)](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_create_for-idp_oidc.html)
+ [Criação de uma função para uma federação do SAML 2.0 (console)](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_create_for-idp_saml.html)

## Etapa 2: gerar o URL com o código de autenticação anexado
<a name="embedded-analytics-full-console-for-authenticated-users-step-2"></a>

Na seção apresentada a seguir, você descobrirá como realizar a autenticação do usuário e obter o URL da sessão do console incorporável em seu servidor de aplicações. 

Quando um usuário acessa a aplicação, ela assume o perfil do IAM em nome do usuário. Em seguida, ele adiciona o usuário ao Amazon Quick Sight, se esse usuário ainda não existir. Depois disso, ela transfere um identificador como o ID exclusivo de sessão do usuário. 

A execução das etapas descritas garante que cada visualizador da sessão do console seja provisionado de forma exclusiva no Amazon Quick Sight. Ele também aplica as configurações por usuário, como a segurança em nível de linha e padrões dinâmicos para os parâmetros.

Os exemplos a seguir executam a autenticação do IAM em nome do usuário. Este código é executado no servidor da aplicação.

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

O exemplo a seguir mostra o JavaScript (Node.js) que você pode usar no servidor do aplicativo para gerar a URL para a sessão do console incorporado. É possível usar esse URL em seu site ou em sua aplicação para exibir a sessão do console. 

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

O exemplo a seguir mostra o código em .NET/C\$1 que você pode usar no servidor de aplicações para gerar o URL para a sessão do console incorporada. É possível usar esse URL em seu site ou em sua aplicação para exibir o console. 

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

Para assumir a função, escolha uma das seguintes operações de API AWS Security Token Service (AWS STS):
+ [AssumeRole](https://docs.aws.amazon.com/STS/latest/APIReference/API_AssumeRole.html)— Use essa operação quando estiver usando uma identidade do IAM para assumir a função.
+ [AssumeRoleWithWebIdentity](https://docs.aws.amazon.com/STS/latest/APIReference/API_AssumeRoleWithWebIdentity.html)— Use essa operação quando estiver usando um provedor de identidade da web para autenticar seu usuário. 
+ [AssumeRoleWithSaml](https://docs.aws.amazon.com/STS/latest/APIReference/API_AssumeRoleWithSAML.html)— Use essa operação quando estiver usando SAML para autenticar seus usuários.

O exemplo a seguir mostra o comando da CLI que define a função do IAM. O perfil precisa ter permissões habilitadas para `quicksight:GenerateEmbedUrlForRegisteredUser`. Se você está adotando uma just-in-time abordagem para adicionar usuários quando eles abrem o Amazon Quick Sight pela primeira vez, a função também precisa de permissões habilitadas`quicksight:RegisterUser`.

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

A operação `assume-role` retorna três parâmetros de saída: a chave de acesso, a chave secreta e o token da sessão. 

**nota**  
Se você receber um erro `ExpiredToken` ao chamar a operação `AssumeRole`, isso provavelmente ocorre porque o `SESSION TOKEN` anterior ainda está nas variáveis de ambiente. Resolva isso definindo as seguintes variáveis:  
*AWS\$1ACCESS\$1KEY\$1ID* 
*AWS\$1SECRET\$1CHAVE DE ACESSO* 
*AWS\$1SESSION\$1TOKEN* 

O exemplo a seguir mostra como definir esses três parâmetros na CLI. Se você estiver usando uma máquina com Microsoft Windows, use `set` em vez de `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"
```

Executar esses comandos define o ID da sessão da função do usuário que está acessando o site `embedding_quicksight_console_session_role/john.doe@example.com`. O ID da sessão da função é composto pelo nome da função a partir de `role-arn` e o valor de `role-session-name`. Usando o ID único da sessão da função para cada usuário garante que as permissões apropriadas sejam definidas para cada usuário. Isso também impede qualquer limitação do acesso do usuário. A limitação é um recurso de segurança que impede que o mesmo usuário acesse o Amazon Quick Sight de vários locais. 

O ID da sessão da função também se torna o nome de usuário no Amazon Quick Sight. Você pode usar esse padrão para provisionar seus usuários no Amazon Quick Sight com antecedência ou para provisioná-los na primeira vez que acessarem uma sessão de console. 

O exemplo a seguir mostra o comando da CLI que você pode usar para provisionar um usuário. Para obter mais informações sobre [RegisterUser](https://docs.aws.amazon.com/quicksight/latest/APIReference/API_RegisterUser.html), [DescribeUser](https://docs.aws.amazon.com/quicksight/latest/APIReference/API_DescribeUser.html), e outras operações da API Amazon Quick Sight, consulte a [Referência da 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_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
```

Se o usuário for autenticado por meio do Microsoft AD, você não precisará usar o `RegisterUser` para configurá-lo. Em vez disso, eles devem ser automaticamente inscritos na primeira vez que acessarem o Amazon Quick Sight. Para usuários do Microsoft AD, você pode usar o `DescribeUser` para obter o ARN do usuário.

Na primeira vez que um usuário acessa o Amazon Quick Sight, você também pode adicionar esse usuário ao grupo apropriado. O exemplo a seguir mostra o comando da CLI para adicionar um usuário a um grupo.

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

Agora você tem um usuário do seu aplicativo que também é usuário do Amazon Quick Sight e que tem acesso à sessão do console do Amazon Quick Sight. 

Por fim, para obter um URL assinado para a sessão do console, chame `generate-embed-url-for-registered-user` usando o servidor de aplicações. Isso retorna o URL da sessão do console incorporável. O exemplo a seguir mostra como gerar a URL para uma sessão de console incorporada usando uma chamada do lado do servidor para usuários autenticados por meio de login único ( AWS Managed Microsoft AD IAM Identity Center).

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

Para obter mais informações sobre o uso dessa operação, consulte [https://docs.aws.amazon.com/quicksight/latest/APIReference/API_GenerateEmbedUrlForRegisteredUser.html](https://docs.aws.amazon.com/quicksight/latest/APIReference/API_GenerateEmbedUrlForRegisteredUser.html). Você pode usar essa e outras operações de API no seu próprio código. 

## Etapa 3: incorporar o URL da sessão do console
<a name="embedded-analytics-full-console-for-authenticated-users-step-3"></a>

Na seção a seguir, você pode descobrir como usar o [Amazon Quick Sight Embedding SDK](https://www.npmjs.com/package/amazon-quicksight-embedding-sdk) (JavaScript) para incorporar o URL da sessão do console a partir da etapa 3 em seu site ou página do aplicativo. Com o SDK, você pode fazer o seguinte: 
+ Estabeleça a sessão do console em uma página HTML.
+ Adicione os parâmetros para a sessão do console.
+ Corrija os estados de erro com mensagens que são personalizados para seu aplicativo.

Chame a operação de API `GenerateEmbedUrlForRegisteredUser` para gerar o URL que você pode incorporar à aplicação. Esse URL é válido por cinco minutos e a sessão resultante é válida por, no máximo, dez horas. A operação de API fornece ao URL um `auth_code` que possibilita uma sessão de logon único. 

Veja a seguir uma resposta de exemplo de `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"
}
```

Incorpore essa sessão de console em sua página da web usando o Amazon Quick Sight [Embedding SDK](https://www.npmjs.com/package/amazon-quicksight-embedding-sdk) ou adicionando essa URL em um iframe. Se você definir um número fixo de altura e largura (em pixels), o Amazon Quick Sight os usará e não alterará seu visual à medida que sua janela é redimensionada. Se você definir uma porcentagem relativa de altura e largura, o Amazon Quick Sight fornece um layout responsivo que é modificado conforme o tamanho da janela muda. Ao usar o Amazon Quick Sight Embedding SDK, você também pode controlar os parâmetros na sessão do console e receber retornos de chamada em termos de conclusão do carregamento da página e erros. 

O domínio que hospedará painéis incorporados deve estar na lista de *permissões, a lista* de domínios aprovados para sua Quick assinatura. Esse requisito protege seus dados, impedindo que domínios não aprovados hospedem painéis incorporados. Para obter mais informações sobre a adição de domínios a um console incorporado, consulte [Permitir a listagem de domínios em tempo de execução com a API Amazon Quick Sight](https://docs.aws.amazon.com/quicksight/latest/user/embedding-run-time.html).

O exemplo a seguir mostra como usar o URL gerado. Este código é gerado no seu servidor de aplicações.

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

Para que esse exemplo funcione, certifique-se de usar o Amazon Quick Sight Embedding SDK para carregar a sessão do console incorporado em seu site usando. JavaScript Para obter sua cópia, siga um destes procedimentos:
+ Baixe o [Amazon Quick Sight Embedding SDK](https://github.com/awslabs/amazon-quicksight-embedding-sdk#step-3-create-the-quicksight-session-object) em. GitHub Esse repositório é mantido por um grupo de desenvolvedores do Amazon Quick Sight.
+ Baixe a versão mais recente do SDK de incorporação em. [https://www.npmjs.com/package/amazon-quicksight-embedding-sdk](https://www.npmjs.com/package/amazon-quicksight-embedding-sdk)
+ Se você usa `npm` para JavaScript dependências, faça o download e instale-o executando o comando a seguir.

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

# Como habilitar recursos de BI generativo em consoles incorporados para usuários registrados
<a name="embedding-consoles-genbi"></a>


|  | 
| --- |
|  Aplica-se a: Enterprise Edition  | 


|  | 
| --- |
|    Público-alvo: desenvolvedores do Amazon Quick  | 

Você pode habilitar os seguintes recursos de BI generativo no seu console incorporado:
+ Resumos executivos: quando ativados, os usuários registrados do Author Pro e do Reader Pro podem gerar resumos executivos que fornecem um resumo de todos os insights que o Amazon Quick Sight gerou para que o painel descubra facilmente os principais insights.
+ Criação: quando habilitado, os usuários do Author Pro podem usar BI generativo para desenvolver campos calculados e criar e refinar os elementos visuais.
+ Perguntas e respostas: quando habilitadas, os usuários do Author Pro e do Reader Pro podem usar as perguntas e respostas baseadas em IA para sugerir e responder a perguntas relacionadas aos seus dados.
+ Narrativas analíticas: quando ativadas, os usuários do Author Pro e do Reader Pro podem fornecer detalhes para gerar rapidamente um primeiro rascunho da sua narrativa analítica.

**Para habilitar recursos de BI generativo em consoles incorporados para usuários registrados**
+ Siga as etapas em [Incorporação da funcionalidade completa do console Amazon Quick Sight para que usuários registrados incorporem](https://docs.aws.amazon.com/quicksight/latest/user/embedded-analytics-full-console-for-authenticated-users.html) um console com as seguintes alterações:

  1. Ao gerar o URL na Etapa 2, `Enabled: true` defina o `FeatureConfigurations` parâmetro para cada um dos recursos que você deseja ativar no [GenerateEmbedUrlForRegisteredUser](https://docs.aws.amazon.com/quicksight/latest/APIReference/API_GenerateEmbedUrlForRegisteredUser.html)ou [GenerateEmbedUrlForRegisteredUserWithIdentity](https://docs.aws.amazon.com/quicksight/latest/APIReference/API_GenerateEmbedUrlForRegisteredUserWithIdentity.html) APIs, conforme mostrado no exemplo a seguir. Se nenhuma configuração for fornecida, os recursos serão desabilitados por padrão.

     ```
     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. Ao incorporar a URL do console com o Amazon Quick Sight Embedding SDK na Etapa 3, defina os valores no exemplo a seguir conforme desejado. Se nenhuma configuração for fornecida, os recursos serão desabilitados por padrão.
**nota**  
Não há nenhuma opção de SDK para habilitar narrativas analíticas. Se as narrativas analíticas forem habilitadas com a API, conforme mostrado na etapa anterior, elas estarão disponíveis para usuários registrados.

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

# Incorporando o Amazon Q na experiência generativa de perguntas e respostas do Amazon Quick Sight
<a name="embedding-gen-bi"></a>


|  | 
| --- |
|    Público-alvo: desenvolvedores do Amazon Quick  | 

Nas seções a seguir, você encontrará informações detalhadas sobre como configurar uma experiência de perguntas e respostas generativas incorporada que usa recursos aprimorados de NLQ fornecidos pelo. LLMs A experiência de perguntas e respostas generativas é a substituição recomendada para a barra de pesquisa Q incorporada e fornece uma experiência de BI atualizada para os usuários.

**Topics**
+ [

## Incorporando o Amazon Q na experiência generativa de perguntas e respostas do Amazon Quick Sight para usuários registrados
](#embedded-analytics-gen-bi-authenticated-users)
+ [

## Incorporando o Amazon Q na experiência Quick Generative Q&A para usuários anônimos (não registrados)
](#embedded-analytics-gen-bi-anonymous-users)

## Incorporando o Amazon Q na experiência generativa de perguntas e respostas do Amazon Quick Sight para usuários registrados
<a name="embedded-analytics-gen-bi-authenticated-users"></a>

Nas seções a seguir, você encontrará informações detalhadas sobre como configurar uma experiência de perguntas e respostas generativas incorporada para usuários registrados do Amazon Quick Sight.

**Topics**
+ [

### Etapa 1: configurar permissões
](#embedded-analytics-gen-bi-authenticated-users-step-1)
+ [

### Etapa 2: gerar o URL com o código de autenticação anexado
](#embedded-analytics-gen-bi-authenticated-users-step-2)
+ [

### Etapa 3: incorporar o URL da experiência de perguntas e respostas generativas
](#embedded-analytics-gen-bi-authenticated-users-step-3)
+ [

### Funcionalidades opcionais da experiência de perguntas e respostas generativas incorporada
](#embedded-analytics-gen-bi-authenticated-users-step-4)

### Etapa 1: configurar permissões
<a name="embedded-analytics-gen-bi-authenticated-users-step-1"></a>

Na seção apresentada a seguir, você encontrará informações sobre como configurar as permissões para a aplicação de backend ou para o servidor Web com a finalidade de incorporar a experiência de perguntas e respostas generativas. Essa tarefa requer acesso administrativo ao AWS Identity and Access Management (IAM).

Cada usuário que acessa uma experiência generativa de perguntas e respostas assume uma função que lhe dá acesso e permissões ao Amazon Quick Sight. Para tornar isso possível, crie um perfil do IAM em sua Conta da AWS. Associe uma política do IAM à função, para fornecer permissões a qualquer usuário que a assumir. A função do IAM precisa fornecer permissões para recuperar a incorporação de um URLs grupo de usuários específico. 

Com a ajuda do caractere curinga *\$1*, é possível conceder as permissões para a geração de um URL para todos os usuários em um namespace específico. Como alternativa, você pode conceder as permissões para a geração de um URL para um subconjunto de usuários em namespaces específicos. Para isso, você adiciona `quicksight:GenerateEmbedUrlForRegisteredUser`.

É possível criar uma condição na política do IAM que limite os domínios que os desenvolvedores podem listar no parâmetro `AllowedDomains` de uma operação de API `GenerateEmbedUrlForRegisteredUser`. O parâmetro `AllowedDomains` é opcional. Ele concede aos desenvolvedores a opção de substituir os domínios estáticos que estão configurados no menu Gerenciar **Amazon Quick Sight** e, em vez disso, listar até três domínios ou subdomínios que podem acessar uma URL gerada. Em seguida, esse URL é incorporado ao site do desenvolvedor. Somente os domínios listados no parâmetro podem acessar a experiência de perguntas e respostas generativas incorporada. Sem essa condição, os desenvolvedores podem listar qualquer domínio da Internet no parâmetro `AllowedDomains`. 

Para limitar os domínios que os desenvolvedores podem usar com esse parâmetro, adicione uma condição `AllowedEmbeddingDomains` à política do IAM. Para obter mais informações sobre o `AllowedDomains` parâmetro, consulte [GenerateEmbedUrlForRegisteredUser](https://docs.aws.amazon.com//quicksight/latest/APIReference/API_GenerateEmbedUrlForRegisteredUser.html)a *Amazon Quick Sight API Reference*.

**Prática recomendada de segurança para operadores de condições do IAM**  
Operadores de condição do IAM configurados incorretamente podem permitir acesso não autorizado aos seus recursos incorporados do Quick por meio de variações de URL. Ao usar a chave de `quicksight:AllowedEmbeddingDomains` condição em suas políticas do IAM, use operadores de condição que permitem domínios específicos ou negam todos os domínios que não são especificamente permitidos. Para obter mais informações sobre operadores de condição do IAM, consulte [Elementos de política JSON do IAM: operadores de condição](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_elements_condition_operators.html) no Guia do usuário do IAM.  
Muitas variações diferentes de URL podem apontar para o mesmo recurso. Por exemplo, URLs todos os itens a seguir têm o mesmo conteúdo:  
`https://example.com`
`https://example.com/`
`https://Example.com`
Se sua política usa operadores que não levam em conta essas variações de URL, um invasor pode contornar suas restrições fornecendo variações de URL equivalentes.  
Você deve validar se sua política do IAM usa operadores de condição apropriados para evitar ignorar vulnerabilidades e garantir que somente os domínios pretendidos possam acessar seus recursos incorporados.

O modelo de política a seguir fornece essas permissões.

Além disso, se você estiver criando usuários iniciantes que serão leitores do Amazon Quick Sight, certifique-se de adicionar a `quicksight:RegisterUser` permissão na política.

O exemplo de política a seguir fornece permissão para recuperar uma URL de incorporação para usuários iniciantes que serão leitores do Amazon Quick Sight.

Por fim, a identidade do IAM da sua aplicação deve ter uma política de confiança associada a ela, para permitir acesso ao perfil que você acabou de criar. Isso significa que quando um usuário acessa seu aplicativo, seu aplicativo pode assumir a função em nome do usuário e provisionar o usuário no Amazon Quick Sight. 

O exemplo apresentado a seguir mostra um exemplo de política de confianç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"
            }
        ]
    }
```

------

Para obter mais informações sobre as políticas de confiança para a autenticação do OpenID Connect ou para a Security Assertion Markup Language (SAML), consulte as seguintes seções do *Guia do usuário do IAM*:
+ [Como criar um perfil para identidades da Web ou federação do OpenID Connect (console)](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_create_for-idp_oidc.html)
+ [Como criar um perfil para uma federação do SAML 2.0 (console)](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_create_for-idp_saml.html)

### Etapa 2: gerar o URL com o código de autenticação anexado
<a name="embedded-analytics-gen-bi-authenticated-users-step-2"></a>

Na seção apresentada a seguir, você descobrirá como realizar a autenticação do usuário e obter o URL do tópico do Q incorporável em seu servidor de aplicações. Se você planeja incorporar a experiência generativa de perguntas e respostas para os tipos de identidade IAM ou Amazon Quick Sight, compartilhe o tópico de perguntas com os usuários.

Quando um usuário acessa a aplicação, ela assume o perfil do IAM em nome do usuário. Em seguida, o aplicativo adiciona o usuário ao Amazon Quick Sight, caso esse usuário ainda não exista. Depois disso, ela transfere um identificador como o ID exclusivo de sessão do usuário. 

A execução das etapas descritas garante que cada visualizador do tópico Q seja provisionado de forma exclusiva no Amazon Quick Sight. Ele também aplica as configurações por usuário, como a segurança em nível de linha e padrões dinâmicos para os parâmetros. A segurança em nível de linha baseada em tags pode ser usada para a incorporação de usuários anônimos na barra Q.

Os exemplos a seguir executam a autenticação do IAM em nome do usuário. Este código é executado no servidor da aplicação.

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

**nota**  
A geração de URL incorporada APIs não pode ser chamada diretamente dos navegadores. Em vez disso, consulte o exemplo que usa 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>

O exemplo a seguir mostra o JavaScript (Node.js) que você pode usar no servidor do aplicativo para gerar a URL para o painel incorporado. Você pode usar esse URL no seu site ou aplicativo para exibir o painel. 

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

O exemplo a seguir mostra o código em .NET/C\$1 que você pode usar no servidor de aplicações para gerar o URL para a barra de pesquisa Q incorporada. É possível usar esse URL em seu site ou em sua aplicação para exibir a barra de pesquisa do 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>

Para assumir a função, escolha uma das seguintes operações de API AWS Security Token Service (AWS STS):
+ [AssumeRole](https://docs.aws.amazon.com/STS/latest/APIReference/API_AssumeRole.html)— Use essa operação quando estiver usando uma identidade do IAM para assumir a função.
+ [AssumeRoleWithWebIdentity](https://docs.aws.amazon.com/STS/latest/APIReference/API_AssumeRoleWithWebIdentity.html)— Use essa operação quando estiver usando um provedor de identidade da web para autenticar seu usuário. 
+ [AssumeRoleWithSaml](https://docs.aws.amazon.com/STS/latest/APIReference/API_AssumeRoleWithSAML.html)— Use essa operação quando estiver usando o SAML para autenticar seus usuários.

O exemplo a seguir mostra o comando da CLI que define a função do IAM. O perfil precisa ter permissões habilitadas para `quicksight:GenerateEmbedUrlForRegisteredUser`. Se você estiver adotando uma just-in-time abordagem para adicionar usuários quando eles usam um tópico na barra de pesquisa Q, a função também precisa de permissões ativadas`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
```

A operação `assume-role` retorna três parâmetros de saída: a chave de acesso, a chave secreta e o token da sessão. 

**nota**  
Se você receber um erro `ExpiredToken` ao chamar a operação `AssumeRole`, isso provavelmente ocorre porque o `SESSION TOKEN` anterior ainda está nas variáveis de ambiente. Resolva isso definindo as seguintes variáveis:  
*AWS\$1ACCESS\$1KEY\$1ID* 
*AWS\$1SECRET\$1CHAVE DE ACESSO* 
*AWS\$1SESSION\$1TOKEN* 

O exemplo a seguir mostra como definir esses três parâmetros na CLI. Para uma máquina com Microsoft Windows, use `set` em vez de `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"
```

Executar esses comandos define o ID da sessão da função do usuário que está acessando o site `embedding_quicksight_q_search_bar_role/john.doe@example.com`. O ID da sessão da função é composto pelo nome da função a partir de `role-arn` e o valor de `role-session-name`. Usando o ID único da sessão da função para cada usuário garante que as permissões apropriadas sejam definidas para cada usuário. Isso também impede qualquer limitação do acesso do usuário. *A limitação* é um recurso de segurança que impede que o mesmo usuário acesse o Amazon Quick Sight de vários locais. 

O ID da sessão da função também se torna o nome de usuário no Amazon Quick Sight. Você pode usar esse padrão para provisionar seus usuários no Amazon Quick Sight com antecedência ou para provisioná-los na primeira vez que acessarem a experiência generativa de perguntas e respostas. 

O exemplo a seguir mostra o comando da CLI que você pode usar para provisionar um usuário. Para obter mais informações sobre [RegisterUser](https://docs.aws.amazon.com/quicksight/latest/APIReference/API_RegisterUser.html), [DescribeUser](https://docs.aws.amazon.com/quicksight/latest/APIReference/API_DescribeUser.html), e outras operações da API Amazon Quick Sight, consulte a [referência da 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_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
```

Se o usuário for autenticado por meio do Microsoft AD, você não precisará usar o `RegisterUser` para configurá-lo. Em vez disso, eles devem ser automaticamente inscritos na primeira vez que acessarem o Amazon Quick Sight. Para os usuários do Microsoft AD, você pode usar `DescribeUser` para obter o nome do recurso da Amazon (ARN) do usuário.

Na primeira vez que um usuário acessa o Amazon Quick Sight, você também pode adicionar esse usuário ao grupo com o qual o painel é compartilhado. O exemplo a seguir mostra o comando da CLI para adicionar um usuário a um grupo.

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

Agora você tem um usuário do seu aplicativo que também é usuário do Amazon Quick Sight e que tem acesso ao painel. 

Por fim, obtenha um signed URL para o painel, chame o `generate-embed-url-for-registered-user` partir do servidor de aplicativo. Isso retorna o URL do painel incorporável. O exemplo a seguir mostra como gerar a URL para um painel incorporado usando uma chamada do lado do servidor para usuários autenticados por meio de um login único ( AWS Managed Microsoft AD IAM Identity Center).

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

Para obter mais informações sobre o uso dessa operação, consulte [https://docs.aws.amazon.com/quicksight/latest/APIReference/API_GenerateEmbedUrlForRegisteredUser.html](https://docs.aws.amazon.com/quicksight/latest/APIReference/API_GenerateEmbedUrlForRegisteredUser.html). Você pode usar essa e outras operações de API no seu próprio código.

### Etapa 3: incorporar o URL da experiência de perguntas e respostas generativas
<a name="embedded-analytics-gen-bi-authenticated-users-step-3"></a>

Na seção apresentada a seguir, você encontrará como incorporar o URL da experiência de perguntas e respostas generativas em seu site ou na página da sua aplicação. Você faz isso com o [SDK de incorporação do Amazon Quick Sight](https://www.npmjs.com/package/amazon-quicksight-embedding-sdk) ()JavaScript. Com o SDK, você pode fazer o seguinte: 
+ Adicionar a experiência de perguntas e respostas generativas a uma página HTML.
+ Personalizar o layout e a aparência da experiência incorporada para atender às necessidades de aplicação.
+ Corrija os estados de erro com mensagens que são personalizados para seu aplicativo.

Para gerar o URL que você pode incorporar à aplicação, chame a operação de API `GenerateEmbedUrlForRegisteredUser`. Esse URL é válido por cinco minutos e a sessão resultante é válida por, no máximo, dez horas. A operação de API fornece ao URL um valor `auth_code` que possibilita uma sessão de logon único. 

Veja a seguir uma resposta de exemplo de `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"
}
```

Incorpore a experiência generativa de perguntas e respostas em sua página da web usando o [SDK de incorporação do Amazon Quick Sight](https://www.npmjs.com/package/amazon-quicksight-embedding-sdk) ou adicionando essa URL a um iframe. Se você definir um número fixo de altura e largura (em pixels), o Amazon Quick Sight os usará e não alterará seu visual à medida que sua janela é redimensionada. Se você definir uma porcentagem relativa de altura e largura, o Amazon Quick Sight fornece um layout responsivo que é modificado conforme o tamanho da janela muda. 

Certifique-se de que o domínio para hospedar a experiência de perguntas e respostas generativas incorporada esteja na lista de *permissões, a lista* de domínios aprovados para sua assinatura do Amazon Quick Sight. Esse requisito protege seus dados, impedindo que domínios não aprovados hospedem painéis incorporados. Para obter mais informações sobre como adicionar domínios para uma experiência de perguntas e respostas generativas incorporada, consulte [Gerenciando domínios](manage-domains.md).

Você pode usar o Amazon Quick Sight Embedding SDK para personalizar o layout e a aparência da experiência de perguntas e respostas generativas incorporada de acordo com seu aplicativo. Use a propriedade `panelType` para configurar o estado inicial da experiência de perguntas e respostas generativas no momento em que ela é renderizada na aplicação. Defina a propriedade `panelType` como `'FULL'` para renderizar o painel completo da experiência de perguntas e respostas generativas. Esse painel é semelhante à experiência que os usuários do Amazon Quick Sight têm no console do Amazon Quick Sight. A altura do quadro do painel não é alterada com base na interação do usuário e respeita o valor definido na propriedade `frameOptions.height`. A imagem apresentada abaixo ilustra o painel da experiência de perguntas e respostas generativas renderizado quando o valor de `panelType` está definido como `'FULL'`.

Defina a propriedade `panelType` como `'SEARCH_BAR'` para renderizar a experiência de perguntas e respostas generativas como uma barra de pesquisa. Esta barra de pesquisa se assemelha à forma como a barra de pesquisa do Q é renderizada quando ocorre a incorporação com uma aplicação. A barra de pesquisa da experiência de perguntas e respostas generativas pode se expandir para um painel maior, que exibe as opções de seleção de tópicos, a lista de sugestões de perguntas, o painel de respostas ou o painel de avisos.

A altura mínima padrão da barra de pesquisa para as perguntas e respostas generativas é aplicada quando o recurso incorporado é carregado. É recomendável definir o valor de `frameOptions.height` como `"38px"` para otimizar a experiência da barra de pesquisa. Use a propriedade `focusedHeight` para definir o tamanho ideal do menu suspenso de seleção de tópicos e da lista de sugestões de perguntas. Use a propriedade `expandedHeight` para definir o tamanho ideal do painel de respostas e do painel de avisos. Caso você escolha a opção `'SEARCH_BAR'`, é recomendável alterar o estilo do contêiner principal com a propriedade “position: absolute” para evitar o deslocamento indesejado do conteúdo na aplicação. A imagem apresentada abaixo ilustra a barra de pesquisa da experiência de perguntas e respostas generativas renderizado quando o valor de `panelType` está definido como `'SEARCH_BAR'`.

Depois de configurar a `panelType` propriedade, use o SDK de incorporação do Amazon Quick Sight para personalizar as seguintes propriedades da experiência generativa de perguntas e respostas.
+ O título do painel de perguntas e respostas generativas (aplicável somente à opção `panelType: FULL`). 
+ O texto exibido no espaço reservado da barra de pesquisa.
+ Se a seleção de tópicos é permitida.
+ Se os nomes dos tópicos devem ser exibidos ou ocultos.
+ Se o ícone do Amazon Q deve ser exibido ou oculto (aplicável somente à opção `panelType: FULL`).
+ Se o painel de avisos deve ser exibido ou oculto.
+ Se os usuários têm a opção de maximizar o painel de perguntas e respostas generativas para o modo de tela cheia.
+ O tema do painel de perguntas e respostas generativas. É possível fornecer um ARN com tema personalizado no SDK para alterar a aparência do conteúdo do quadro. Os temas iniciais do Amazon Quick Sight não são compatíveis com painéis de BI generativo incorporados. Para usar um tema inicial do Amazon Quick Sight, salve-o como um tema personalizado no Amazon Quick Sight.

Quando você usa o Amazon Quick Sight Embedding SDK, a experiência generativa de perguntas e respostas em sua página é redimensionada dinamicamente com base no estado. Ao usar o Amazon Quick Sight Embedding SDK, você também pode controlar parâmetros na experiência generativa de perguntas e respostas e receber retornos de chamada em termos de conclusão do carregamento da página, alterações de estado e erros. 

O exemplo a seguir mostra como usar o URL gerado. Este código é gerado no seu servidor de aplicações.

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

Para que esse exemplo funcione, certifique-se de usar o Amazon Quick Sight Embedding SDK para carregar a experiência de perguntas e respostas generativas incorporada em seu site com. JavaScript Para obter sua cópia, siga um destes procedimentos:
+ Baixe o [SDK de incorporação do Amazon Quick Sight](https://github.com/awslabs/amazon-quicksight-embedding-sdk#step-3-create-the-quicksight-session-object) em. GitHub Esse repositório é mantido por um grupo de desenvolvedores do Amazon Quick Sight.
+ Baixe a versão mais recente do SDK de incorporação em. [https://www.npmjs.com/package/amazon-quicksight-embedding-sdk](https://www.npmjs.com/package/amazon-quicksight-embedding-sdk)
+ Se você usa `npm` para JavaScript dependências, faça o download e instale-o executando o comando a seguir.

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

### Funcionalidades opcionais da experiência de perguntas e respostas generativas incorporada
<a name="embedded-analytics-gen-bi-authenticated-users-step-4"></a>

As funcionalidades opcionais apresentadas a seguir estão disponíveis para a experiência de perguntas e respostas generativas incorporada com o SDK de incorporação. 

#### Invocar ações da barra de pesquisa para perguntas e respostas generativas
<a name="w2aac35c27c21c43c29b9c21b5"></a>
+ Elaborar uma pergunta: esse recurso envia uma pergunta para a experiência de perguntas e respostas generativas e realiza a consulta imediatamente.

  ```
  embeddedGenerativeQnExperience.setQuestion('show me monthly revenue');
  ```
+ Fechar o painel de respostas (aplicável à opção da barra de pesquisa para perguntas e respostas generativas): esse recurso fecha o painel de respostas e retorna o iframe ao estado original da barra de pesquisa.

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

Para obter mais informações, consulte o [SDK de incorporação do Amazon Quick Sight](https://github.com/awslabs/amazon-quicksight-embedding-sdk).

## Incorporando o Amazon Q na experiência Quick Generative Q&A para usuários anônimos (não registrados)
<a name="embedded-analytics-gen-bi-anonymous-users"></a>


|  | 
| --- |
|    Público-alvo: desenvolvedores do Amazon Quick  | 

Nas seções apresentadas a seguir, você encontrará informações detalhadas sobre como configurar uma experiência de perguntas e respostas generativas incorporada para usuários anônimos (não registrados).

**Topics**
+ [

### Etapa 1: configurar permissões
](#embedded-analytics-gen-bi-anonymous-users-step-1)
+ [

### Etapa 2: gerar o URL com o código de autenticação anexado
](#embedded-analytics-gen-bi-anonymous-users-step-2)
+ [

### Etapa 3: incorporar o URL da experiência de perguntas e respostas generativas
](#embedded-analytics-gen-bi-anonymous-users-step-3)
+ [

### Funcionalidades opcionais da experiência de perguntas e respostas generativas incorporada
](#embedded-analytics-gen-bi-anonymous-users-step-4)

### Etapa 1: configurar permissões
<a name="embedded-analytics-gen-bi-anonymous-users-step-1"></a>

Na seção apresentada a seguir, você encontrará informações sobre como configurar as permissões para a aplicação de backend ou para o servidor Web com a finalidade de incorporar a experiência de perguntas e respostas generativas. Essa tarefa requer acesso administrativo ao AWS Identity and Access Management (IAM).

Cada usuário que acessa uma experiência generativa de perguntas e respostas assume uma função que lhe dá acesso e permissões ao Amazon Quick Sight. Para tornar isso possível, crie um perfil do IAM em sua Conta da AWS. Associe uma política do IAM à função, para fornecer permissões a qualquer usuário que a assumir. A função do IAM precisa fornecer permissões para recuperar a incorporação de um URLs grupo de usuários específico. 

Com a ajuda do caractere curinga *\$1*, é possível conceder as permissões para a geração de um URL para todos os usuários em um namespace específico. Como alternativa, você pode conceder as permissões para a geração de um URL para um subconjunto de usuários em namespaces específicos. Para isso, você adiciona `quicksight:GenerateEmbedUrlForAnonymousUser`.

É possível criar uma condição na política do IAM que limite os domínios que os desenvolvedores podem listar no parâmetro `AllowedDomains` de uma operação de API `GenerateEmbedUrlForAnonymousUser`. O parâmetro `AllowedDomains` é opcional. Ele concede aos desenvolvedores a opção de substituir os domínios estáticos que estão configurados no menu Gerenciar **Amazon Quick Sight** e, em vez disso, listar até três domínios ou subdomínios que podem acessar uma URL gerada. Em seguida, esse URL é incorporado ao site do desenvolvedor. Somente os domínios que estão listados no parâmetro podem acessar a barra de pesquisa Q incorporada. Sem essa condição, os desenvolvedores podem listar qualquer domínio da Internet no parâmetro `AllowedDomains`. 

Para limitar os domínios que os desenvolvedores podem usar com esse parâmetro, adicione uma condição `AllowedEmbeddingDomains` à política do IAM. Para obter mais informações sobre o `AllowedDomains` parâmetro, consulte [GenerateEmbedUrlForAnonymousUser](https://docs.aws.amazon.com//quicksight/latest/APIReference/API_GenerateEmbedUrlForAnonymousUser.html)a *Amazon Quick Sight API Reference*.

**Prática recomendada de segurança para operadores de condições do IAM**  
Operadores de condição do IAM configurados incorretamente podem permitir acesso não autorizado aos seus recursos incorporados do Quick por meio de variações de URL. Ao usar a chave de `quicksight:AllowedEmbeddingDomains` condição em suas políticas do IAM, use operadores de condição que permitem domínios específicos ou negam todos os domínios que não são especificamente permitidos. Para obter mais informações sobre operadores de condição do IAM, consulte [Elementos de política JSON do IAM: operadores de condição](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_elements_condition_operators.html) no Guia do usuário do IAM.  
Muitas variações diferentes de URL podem apontar para o mesmo recurso. Por exemplo, URLs todos os itens a seguir têm o mesmo conteúdo:  
`https://example.com`
`https://example.com/`
`https://Example.com`
Se sua política usa operadores que não levam em conta essas variações de URL, um invasor pode contornar suas restrições fornecendo variações de URL equivalentes.  
Você deve validar se sua política do IAM usa operadores de condição apropriados para evitar ignorar vulnerabilidades e garantir que somente os domínios pretendidos possam acessar seus recursos incorporados.

A identidade do IAM da sua aplicação deve ter uma política de confiança associada a ela, para permitir acesso ao perfil que você acabou de criar. Isso significa que, quando um usuário acessar a aplicação, ela poderá assumir o perfil em nome do usuário para carregar a experiência de perguntas e respostas generativas. O exemplo apresentado a seguir mostra um exemplo de política de confianç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"
        }
    ]
}
```

------

Para obter mais informações sobre as políticas de confiança, consulte [Credenciais de segurança temporárias no IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_temp.html) no *Guia do usuário do IAM*.

### Etapa 2: gerar o URL com o código de autenticação anexado
<a name="embedded-analytics-gen-bi-anonymous-users-step-2"></a>

Na seção apresentada a seguir, você descobrirá como realizar a autenticação do usuário e obter o URL do tópico do Q incorporável em seu servidor de aplicações.

Quando um usuário acessa a aplicação, ela assume o perfil do IAM em nome do usuário. Em seguida, o aplicativo adiciona o usuário ao Amazon Quick Sight, caso esse usuário ainda não exista. Depois disso, ela transfere um identificador como o ID exclusivo de sessão do usuário. 

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

**nota**  
A geração de URL incorporada APIs não pode ser chamada diretamente dos navegadores. Em vez disso, consulte o exemplo que usa 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>

O exemplo a seguir mostra o JavaScript (Node.js) que você pode usar no servidor do aplicativo para gerar a URL para o painel incorporado. Você pode usar esse URL no seu site ou aplicativo para exibir o painel. 

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

O exemplo a seguir mostra o código em .NET/C\$1 que você pode usar no servidor de aplicações para gerar o URL para a barra de pesquisa Q incorporada. É possível usar esse URL em seu site ou em sua aplicação para exibir a barra de pesquisa do 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>

Para assumir a função, escolha uma das seguintes operações de API AWS Security Token Service (AWS STS):
+ [AssumeRole](https://docs.aws.amazon.com/STS/latest/APIReference/API_AssumeRole.html)— Use essa operação quando estiver usando uma identidade do IAM para assumir a função.
+ [AssumeRoleWithWebIdentity](https://docs.aws.amazon.com/STS/latest/APIReference/API_AssumeRoleWithWebIdentity.html)— Use essa operação quando estiver usando um provedor de identidade da web para autenticar seu usuário. 
+ [AssumeRoleWithSaml](https://docs.aws.amazon.com/STS/latest/APIReference/API_AssumeRoleWithSAML.html)— Use essa operação quando estiver usando o SAML para autenticar seus usuários.

O exemplo a seguir mostra o comando da CLI que define a função do IAM. O perfil precisa ter permissões habilitadas para `quicksight:GenerateEmbedUrlForAnonymousUser`.

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

A operação `assume-role` retorna três parâmetros de saída: a chave de acesso, a chave secreta e o token da sessão. 

**nota**  
Se você receber um erro `ExpiredToken` ao chamar a operação `AssumeRole`, isso provavelmente ocorre porque o `SESSION TOKEN` anterior ainda está nas variáveis de ambiente. Resolva isso definindo as seguintes variáveis:  
*AWS\$1ACCESS\$1KEY\$1ID* 
*AWS\$1SECRET\$1CHAVE DE ACESSO* 
*AWS\$1SESSION\$1TOKEN* 

O exemplo a seguir mostra como definir esses três parâmetros na CLI. Para uma máquina com Microsoft Windows, use `set` em vez de `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"
```

Executar esses comandos define o ID da sessão da função do usuário que está acessando o site `embedding_quicksight_q_search_bar_role/QuickSightEmbeddingAnonymousPolicy`. O ID da sessão da função é composto pelo nome da função a partir de `role-arn` e o valor de `role-session-name`. Usando o ID único da sessão da função para cada usuário garante que as permissões apropriadas sejam definidas para cada usuário. Isso também impede qualquer limitação do acesso do usuário. *A limitação* é um recurso de segurança que impede que o mesmo usuário acesse o Amazon Quick Sight de vários locais. Além disso, essa ação também mantém cada sessão separada e distinta. Se você estiver usando uma série de servidores Web, por exemplo, para balanceamento de carga, e uma sessão for reconectada a um servidor diferente, uma nova sessão será iniciada.

Para obter um URL assinado para o painel, chame `generate-embed-url-for-anynymous-user` usando o servidor de aplicações. Isso retorna o URL do painel incorporável. O exemplo a seguir mostra como gerar o URL para um painel incorporado usando uma chamada do lado do servidor para usuários que estão fazendo visitas anônimas ao seu portal da Web ou à sua aplicação.

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

Para obter mais informações sobre o uso dessa operação, consulte [https://docs.aws.amazon.com/quicksight/latest/APIReference/API_GenerateEmbedUrlForAnonymousUser.html](https://docs.aws.amazon.com/quicksight/latest/APIReference/API_GenerateEmbedUrlForAnonymousUser.html). Você pode usar essa e outras operações de API no seu próprio código.

### Etapa 3: incorporar o URL da experiência de perguntas e respostas generativas
<a name="embedded-analytics-gen-bi-anonymous-users-step-3"></a>

Na seção apresentada a seguir, você encontrará como incorporar o URL da experiência de perguntas e respostas generativas em seu site ou na página da sua aplicação. Você faz isso com o [SDK de incorporação do Amazon Quick Sight](https://www.npmjs.com/package/amazon-quicksight-embedding-sdk) ()JavaScript. Com o SDK, você pode fazer o seguinte: 
+ Adicionar a experiência de perguntas e respostas generativas a uma página HTML.
+ Personalizar o layout e a aparência da experiência incorporada para atender às necessidades de aplicação.
+ Corrija os estados de erro com mensagens que são personalizados para seu aplicativo.

Para gerar o URL que você pode incorporar à aplicação, chame a operação de API `GenerateEmbedUrlForAnonymousUser`. Esse URL é válido por cinco minutos e a sessão resultante é válida por, no máximo, dez horas. A operação de API fornece ao URL um valor `auth_code` que possibilita uma sessão de logon único. 

Veja a seguir uma resposta de exemplo de `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"
}
```

Incorpore a experiência generativa de perguntas e respostas em sua página da web com o SDK de [incorporação do Amazon Quick Sight ou adicionando](https://www.npmjs.com/package/amazon-quicksight-embedding-sdk) essa URL a um iframe. Se você definir um número fixo de altura e largura (em pixels), o Amazon Quick Sight os usará e não alterará seu visual à medida que sua janela é redimensionada. Se você definir uma porcentagem relativa de altura e largura, o Amazon Quick Sight fornece um layout responsivo que é modificado conforme o tamanho da janela muda. 

Certifique-se de que o domínio para hospedar a experiência generativa de perguntas e respostas esteja na lista de *permissões, a lista* de domínios aprovados para sua assinatura do Amazon Quick Sight. Este requisito protege os dados ao impedir que domínios não aprovados hospedem experiências incorporadas de perguntas e respostas generativas. Para obter mais informações sobre como adicionar domínios para uma experiência de perguntas e respostas generativas incorporada, consulte [Gerenciando domínios](manage-domains.md).

Você pode usar o Amazon Quick Sight Embedding SDK para personalizar o layout e a aparência da experiência de perguntas e respostas generativas incorporada de acordo com seu aplicativo. Use a propriedade `panelType` para configurar o estado inicial da experiência de perguntas e respostas generativas no momento em que ela é renderizada na aplicação. Defina a propriedade `panelType` como `'FULL'` para renderizar o painel completo da experiência de perguntas e respostas generativas. Esse painel é semelhante à experiência que os usuários do Amazon Quick Sight têm no console do Amazon Quick Sight. A altura do quadro do painel não é alterada com base na interação do usuário e respeita o valor definido na propriedade `frameOptions.height`. A imagem apresentada abaixo ilustra o painel da experiência de perguntas e respostas generativas renderizado quando o valor de `panelType` está definido como `'FULL'`.

Defina a propriedade `panelType` como `'SEARCH_BAR'` para renderizar a experiência de perguntas e respostas generativas como uma barra de pesquisa. Esta barra de pesquisa se assemelha à forma como a barra de pesquisa do Q é renderizada quando ocorre a incorporação com uma aplicação. A barra de pesquisa da experiência de perguntas e respostas generativas pode se expandir para um painel maior, que exibe as opções de seleção de tópicos, a lista de sugestões de perguntas, o painel de respostas ou o painel de avisos.

A altura mínima padrão da barra de pesquisa para as perguntas e respostas generativas é aplicada quando o recurso incorporado é carregado. É recomendável definir o valor de `frameOptions.height` como `"38px"` para otimizar a experiência da barra de pesquisa. Use a propriedade `focusedHeight` para definir o tamanho ideal do menu suspenso de seleção de tópicos e da lista de sugestões de perguntas. Use a propriedade `expandedHeight` para definir o tamanho ideal do painel de respostas e do painel de avisos. Caso você escolha a opção `'SEARCH_BAR'`, é recomendável alterar o estilo do contêiner principal com a propriedade “position: absolute” para evitar o deslocamento indesejado do conteúdo na aplicação. A imagem apresentada abaixo ilustra a barra de pesquisa da experiência de perguntas e respostas generativas renderizado quando o valor de `panelType` está definido como `'SEARCH_BAR'`.

Depois de configurar a `panelType` propriedade, use o SDK de incorporação do Amazon Quick Sight para personalizar as seguintes propriedades da experiência generativa de perguntas e respostas.
+ O título do painel de perguntas e respostas generativas (aplicável somente à opção `panelType: FULL`). 
+ O texto exibido no espaço reservado da barra de pesquisa.
+ Se a seleção de tópicos é permitida.
+ Se os nomes dos tópicos devem ser exibidos ou ocultos.
+ Se o ícone do Amazon Q deve ser exibido ou oculto (aplicável somente à opção `panelType: FULL`).
+ Se o painel de avisos deve ser exibido ou oculto.
+ Se os usuários têm a opção de maximizar o painel de perguntas e respostas generativas para o modo de tela cheia.
+ O tema do painel de perguntas e respostas generativas. É possível fornecer um ARN com tema personalizado no SDK para alterar a aparência do conteúdo do quadro. Os temas iniciais do Amazon Quick Sight não são compatíveis com painéis de BI generativo incorporados. Para usar um tema inicial do Amazon Quick Sight, salve-o como um tema personalizado no Amazon Quick Sight.

Quando você usa o Amazon Quick Sight Embedding SDK, a experiência generativa de perguntas e respostas em sua página é redimensionada dinamicamente com base no estado. Com o Amazon Quick Sight Embedding SDK, você também pode controlar parâmetros na experiência generativa de perguntas e respostas e receber retornos de chamada em termos de conclusão do carregamento da página, alterações de estado e erros. 

O exemplo a seguir mostra como usar o URL gerado. Este código é gerado no seu servidor de aplicações.

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

Para que esse exemplo funcione, certifique-se de usar o Amazon Quick Sight Embedding SDK para carregar a experiência de perguntas e respostas generativas incorporada em seu site com. JavaScript Para obter sua cópia, siga um destes procedimentos:
+ Baixe o [SDK de incorporação do Amazon Quick Sight](https://github.com/awslabs/amazon-quicksight-embedding-sdk#step-3-create-the-quicksight-session-object) em. GitHub Esse repositório é mantido por um grupo de desenvolvedores do Amazon Quick Sight.
+ Baixe a versão mais recente do SDK de incorporação em. [https://www.npmjs.com/package/amazon-quicksight-embedding-sdk](https://www.npmjs.com/package/amazon-quicksight-embedding-sdk)
+ Se você usa `npm` para JavaScript dependências, faça o download e instale-o executando o comando a seguir.

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

### Funcionalidades opcionais da experiência de perguntas e respostas generativas incorporada
<a name="embedded-analytics-gen-bi-anonymous-users-step-4"></a>

As funcionalidades opcionais apresentadas a seguir estão disponíveis para a experiência de perguntas e respostas generativas incorporada com o SDK de incorporação. 

#### Invocar ações da barra de pesquisa para perguntas e respostas generativas
<a name="w2aac35c27c21c43c29c13c25b5"></a>
+ Elaborar uma pergunta: esse recurso envia uma pergunta para a experiência de perguntas e respostas generativas e realiza a consulta imediatamente.

  ```
  embeddedGenerativeQnExperience.setQuestion('show me monthly revenue');
  ```
+ Fechar o painel de respostas (aplicável à opção da barra de pesquisa para perguntas e respostas generativas): esse recurso fecha o painel de respostas e retorna o iframe ao estado original da barra de pesquisa.

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

Para obter mais informações, consulte o [SDK de incorporação do Amazon Quick Sight](https://github.com/awslabs/amazon-quicksight-embedding-sdk).

# Incorporando a barra de pesquisa Amazon Quick Sight Q (Classic)
<a name="embedding-quicksight-q"></a>


|  | 
| --- |
|    Público-alvo: desenvolvedores do Amazon Quick  | 

**nota**  
A barra de pesquisa incorporada do Amazon Quick Sight Q oferece a experiência clássica de perguntas e respostas do Amazon Quick Sight. O Amazon Quick Sight se integra ao Amazon Q Business para lançar uma nova experiência generativa de perguntas e respostas. Recomenda-se que os desenvolvedores usem a nova experiência de perguntas e respostas generativas. Para obter mais informações sobre a experiência incorporada de perguntas e respostas generativas, consulte [Incorporando o Amazon Q na experiência de perguntas e respostas generativas do Amazon Quick Sight](https://docs.aws.amazon.com/quicksight/latest/user/embedding-gen-bi.html).

Use os tópicos a seguir para aprender como incorporar a barra de pesquisa do Amazon Quick Sight Q ao Amazon Quick Sight APIs.

**Topics**
+ [

# Incorporando a barra de pesquisa Amazon Quick Sight Q para usuários registrados
](embedded-analytics-q-search-bar-for-authenticated-users.md)
+ [

# Incorporação da barra de pesquisa Amazon Quick Sight Q para usuários anônimos (não registrados)
](embedded-analytics-q-search-bar-for-anonymous-users.md)

# Incorporando a barra de pesquisa Amazon Quick Sight Q para usuários registrados
<a name="embedded-analytics-q-search-bar-for-authenticated-users"></a>


|  | 
| --- |
|  Aplica-se a: Enterprise Edition  | 


|  | 
| --- |
|    Público-alvo: desenvolvedores do Amazon Quick  | 

**nota**  
A barra de pesquisa incorporada do Amazon Quick Sight Q oferece a experiência clássica de perguntas e respostas do Amazon Quick Sight. O Amazon Quick Sight se integra ao Amazon Q Business para lançar uma nova experiência generativa de perguntas e respostas. Recomenda-se que os desenvolvedores usem a nova experiência de perguntas e respostas generativas. Para obter mais informações sobre a experiência incorporada de perguntas e respostas generativas, consulte [Incorporando o Amazon Q na experiência de perguntas e respostas generativas do Amazon Quick Sight](https://docs.aws.amazon.com/quicksight/latest/user/embedding-gen-bi.html).

Nas seções a seguir, você encontrará informações detalhadas sobre como configurar uma barra de pesquisa incorporada do Amazon Quick Sight Q para usuários registrados do Amazon Quick Sight.

**Topics**
+ [

## Etapa 1: configurar permissões
](#embedded-q-bar-for-authenticated-users-step-1)
+ [

## Etapa 2: gerar o URL com o código de autenticação anexado
](#embedded-q-bar-for-authenticated-users-step-2)
+ [

## Etapa 3: incorporar o URL da barra de pesquisa do Q
](#embedded-q-bar-for-authenticated-users-step-3)
+ [

## Funcionalidades opcionais de incorporação da barra de pesquisa do Amazon Quick Sight Q
](#embedded-q-bar-for-authenticated-users-step-4)

## Etapa 1: configurar permissões
<a name="embedded-q-bar-for-authenticated-users-step-1"></a>

**nota**  
A barra de pesquisa incorporada do Amazon Quick Sight Q oferece a experiência clássica de perguntas e respostas do Amazon Quick Sight. O Amazon Quick Sight se integra ao Amazon Q Business para lançar uma nova experiência generativa de perguntas e respostas. Recomenda-se que os desenvolvedores usem a nova experiência de perguntas e respostas generativas. Para obter mais informações sobre a experiência incorporada de perguntas e respostas generativas, consulte [Incorporando o Amazon Q na experiência de perguntas e respostas generativas do Amazon Quick Sight](https://docs.aws.amazon.com/quicksight/latest/user/embedding-gen-bi.html).

Na seção a seguir, você descobrirá como configurar permissões para sua aplicação de back-end ou para o servidor Web incorporar a barra de pesquisa do Q. Essa tarefa requer acesso administrativo ao AWS Identity and Access Management (IAM).

Cada usuário que acessa um painel assume uma função que lhe dá acesso e permissões ao Amazon Quick Sight para o painel. Para tornar isso possível, crie uma função do IAM em seu Conta da AWS. Associe uma política do IAM à função, para fornecer permissões a qualquer usuário que a assumir. A função do IAM precisa fornecer permissões para recuperar a incorporação de um URLs grupo de usuários específico. 

Com a ajuda do caractere curinga *\$1*, é possível conceder as permissões para a geração de um URL para todos os usuários em um namespace específico. Como alternativa, você pode conceder as permissões para a geração de um URL para um subconjunto de usuários em namespaces específicos. Para isso, você adiciona `quicksight:GenerateEmbedUrlForRegisteredUser`.

É possível criar uma condição na política do IAM que limite os domínios que os desenvolvedores podem listar no parâmetro `AllowedDomains` de uma operação de API `GenerateEmbedUrlForRegisteredUser`. O parâmetro `AllowedDomains` é opcional. Ele concede aos desenvolvedores a opção de substituir os domínios estáticos que estão configurados no menu Gerenciar **Amazon Quick Sight** e, em vez disso, listar até três domínios ou subdomínios que podem acessar uma URL gerada. Em seguida, esse URL é incorporado ao site do desenvolvedor. Somente os domínios que estão listados no parâmetro podem acessar a barra de pesquisa Q incorporada. Sem essa condição, os desenvolvedores podem listar qualquer domínio da Internet no parâmetro `AllowedDomains`. 

Para limitar os domínios que os desenvolvedores podem usar com esse parâmetro, adicione uma condição `AllowedEmbeddingDomains` à política do IAM. Para obter mais informações sobre o `AllowedDomains` parâmetro, consulte [GenerateEmbedUrlForRegisteredUser](https://docs.aws.amazon.com//quicksight/latest/APIReference/API_GenerateEmbedUrlForRegisteredUser.html)a *Amazon Quick Sight API Reference*.

**Prática recomendada de segurança para operadores de condições do IAM**  
Operadores de condição do IAM configurados incorretamente podem permitir acesso não autorizado aos seus recursos incorporados do Quick por meio de variações de URL. Ao usar a chave de `quicksight:AllowedEmbeddingDomains` condição em suas políticas do IAM, use operadores de condição que permitem domínios específicos ou negam todos os domínios que não são especificamente permitidos. Para obter mais informações sobre operadores de condição do IAM, consulte [Elementos de política JSON do IAM: operadores de condição](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_elements_condition_operators.html) no Guia do usuário do IAM.  
Muitas variações diferentes de URL podem apontar para o mesmo recurso. Por exemplo, URLs todos os itens a seguir têm o mesmo conteúdo:  
`https://example.com`
`https://example.com/`
`https://Example.com`
Se sua política usa operadores que não levam em conta essas variações de URL, um invasor pode contornar suas restrições fornecendo variações de URL equivalentes.  
Você deve validar se sua política do IAM usa operadores de condição apropriados para evitar ignorar vulnerabilidades e garantir que somente os domínios pretendidos possam acessar seus recursos incorporados.

O modelo de política a seguir fornece essas permissões.

Além disso, se você estiver criando usuários iniciantes que serão leitores do Amazon Quick Sight, certifique-se de adicionar a `quicksight:RegisterUser` permissão na política.

O exemplo de política a seguir fornece permissão para recuperar uma URL de incorporação para usuários iniciantes que serão leitores do Amazon Quick Sight.

Por fim, a identidade do IAM da sua aplicação deve ter uma política de confiança associada a ela, para permitir acesso ao perfil que você acabou de criar. Isso significa que, quando um usuário acessa seu aplicativo, ele pode assumir a função em nome do usuário e provisioná-lo no Amazon Quick Sight. 

O exemplo apresentado a seguir mostra um exemplo de política de confianç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"
        }
    ]
}
```

------

Para obter mais informações sobre as políticas de confiança para a autenticação do OpenID Connect ou para a Security Assertion Markup Language (SAML), consulte as seguintes seções do *Guia do usuário do IAM*:
+ [Como criar um perfil para identidades da Web ou federação do OpenID Connect (console)](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_create_for-idp_oidc.html)
+ [Como criar um perfil para uma federação do SAML 2.0 (console)](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_create_for-idp_saml.html)

## Etapa 2: gerar o URL com o código de autenticação anexado
<a name="embedded-q-bar-for-authenticated-users-step-2"></a>

**nota**  
A barra de pesquisa incorporada do Amazon Quick Sight Q oferece a experiência clássica de perguntas e respostas do Amazon Quick Sight. O Amazon Quick Sight se integra ao Amazon Q Business para lançar uma nova experiência generativa de perguntas e respostas. Recomenda-se que os desenvolvedores usem a nova experiência de perguntas e respostas generativas. Para obter mais informações sobre a experiência incorporada de perguntas e respostas generativas, consulte [Incorporando o Amazon Q na experiência de perguntas e respostas generativas do Amazon Quick Sight](https://docs.aws.amazon.com/quicksight/latest/user/embedding-gen-bi.html).

Na seção apresentada a seguir, você descobrirá como realizar a autenticação do usuário e obter o URL do tópico do Q incorporável em seu servidor de aplicações. Se você planeja incorporar a barra Q para os tipos de identidade IAM ou Amazon Quick Sight, compartilhe o tópico Q com os usuários.

Quando um usuário acessa a aplicação, ela assume o perfil do IAM em nome do usuário. Em seguida, o aplicativo adiciona o usuário ao Amazon Quick Sight, se esse usuário ainda não existir. Depois disso, ela transfere um identificador como o ID exclusivo de sessão do usuário. 

A execução das etapas descritas garante que cada visualizador do tópico Q seja provisionado de forma exclusiva no Amazon Quick Sight. Ele também aplica as configurações por usuário, como a segurança em nível de linha e padrões dinâmicos para os parâmetros.

Os exemplos a seguir executam a autenticação do IAM em nome do usuário. Este código é executado no servidor da aplicação.

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

O exemplo a seguir mostra o JavaScript (Node.js) que você pode usar no servidor do aplicativo para gerar a URL para o painel incorporado. Você pode usar esse URL no seu site ou aplicativo para exibir o painel. 

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

O exemplo a seguir mostra o código em .NET/C\$1 que você pode usar no servidor de aplicações para gerar o URL para a barra de pesquisa Q incorporada. É possível usar esse URL em seu site ou em sua aplicação para exibir a barra de pesquisa do 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>

Para assumir a função, escolha uma das seguintes operações de API AWS Security Token Service (AWS STS):
+ [AssumeRole](https://docs.aws.amazon.com/STS/latest/APIReference/API_AssumeRole.html)— Use essa operação quando estiver usando uma identidade do IAM para assumir a função.
+ [AssumeRoleWithWebIdentity](https://docs.aws.amazon.com/STS/latest/APIReference/API_AssumeRoleWithWebIdentity.html)— Use essa operação quando estiver usando um provedor de identidade da web para autenticar seu usuário. 
+ [AssumeRoleWithSaml](https://docs.aws.amazon.com/STS/latest/APIReference/API_AssumeRoleWithSAML.html)— Use essa operação quando estiver usando SAML para autenticar seus usuários.

O exemplo a seguir mostra o comando da CLI que define a função do IAM. O perfil precisa ter permissões habilitadas para `quicksight:GenerateEmbedUrlForRegisteredUser`. Se você estiver adotando uma just-in-time abordagem para adicionar usuários quando eles usam um tópico na barra de pesquisa Q, a função também precisa de permissões ativadas`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
```

A operação `assume-role` retorna três parâmetros de saída: a chave de acesso, a chave secreta e o token da sessão. 

**nota**  
Se você receber um erro `ExpiredToken` ao chamar a operação `AssumeRole`, isso provavelmente ocorre porque o `SESSION TOKEN` anterior ainda está nas variáveis de ambiente. Resolva isso definindo as seguintes variáveis:  
*AWS\$1ACCESS\$1KEY\$1ID* 
*AWS\$1SECRET\$1CHAVE DE ACESSO* 
*AWS\$1SESSION\$1TOKEN* 

O exemplo a seguir mostra como definir esses três parâmetros na CLI. Para uma máquina com Microsoft Windows, use `set` em vez de `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"
```

Executar esses comandos define o ID da sessão da função do usuário que está acessando o site `embedding_quicksight_q_search_bar_role/john.doe@example.com`. O ID da sessão da função é composto pelo nome da função a partir de `role-arn` e o valor de `role-session-name`. Usando o ID único da sessão da função para cada usuário garante que as permissões apropriadas sejam definidas para cada usuário. Isso também impede qualquer limitação do acesso do usuário. *A limitação* é um recurso de segurança que impede que o mesmo usuário acesse o Amazon Quick Sight de vários locais. 

O ID da sessão da função também se torna o nome de usuário no Amazon Quick Sight. Você pode usar esse padrão para provisionar seus usuários no Amazon Quick Sight com antecedência ou para provisioná-los na primeira vez que acessarem a barra de pesquisa Q. 

O exemplo a seguir mostra o comando da CLI que você pode usar para provisionar um usuário. Para obter mais informações sobre [RegisterUser](https://docs.aws.amazon.com/quicksight/latest/APIReference/API_RegisterUser.html), [DescribeUser](https://docs.aws.amazon.com/quicksight/latest/APIReference/API_DescribeUser.html), e outras operações da API Amazon Quick Sight, consulte a [referência da 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_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
```

Se o usuário for autenticado por meio do Microsoft AD, você não precisará usar o `RegisterUser` para configurá-lo. Em vez disso, eles devem ser automaticamente inscritos na primeira vez que acessarem o Amazon Quick Sight. Para os usuários do Microsoft AD, você pode usar `DescribeUser` para obter o nome do recurso da Amazon (ARN) do usuário.

Na primeira vez que um usuário acessa o Amazon Quick Sight, você também pode adicionar esse usuário ao grupo com o qual o painel é compartilhado. O exemplo a seguir mostra o comando da CLI para adicionar um usuário a um grupo.

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

Agora você tem um usuário do seu aplicativo que também é usuário do Amazon Quick Sight e que tem acesso ao painel. 

Por fim, obtenha um signed URL para o painel, chame o `generate-embed-url-for-registered-user` partir do servidor de aplicativo. Isso retorna o URL do painel incorporável. O exemplo a seguir mostra como gerar a URL para um painel incorporado usando uma chamada do lado do servidor para usuários autenticados por meio de um login único ( AWS Managed Microsoft AD 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_q_search_bar_role/embeddingsession
--allowed-domains '["domain1","domain2"]' \
--experience-configuration QSearchBar={InitialTopicId=U4zJMVZ2n2stZflc8Ou3iKySEb3BEV6f}
```

Para obter mais informações sobre o uso dessa operação, consulte [https://docs.aws.amazon.com/quicksight/latest/APIReference/API_GenerateEmbedUrlForRegisteredUser.html](https://docs.aws.amazon.com/quicksight/latest/APIReference/API_GenerateEmbedUrlForRegisteredUser.html). Você pode usar essa e outras operações de API no seu próprio código.

## Etapa 3: incorporar o URL da barra de pesquisa do Q
<a name="embedded-q-bar-for-authenticated-users-step-3"></a>

**nota**  
A barra de pesquisa incorporada do Amazon Quick Sight Q oferece a experiência clássica de perguntas e respostas do Amazon Quick Sight. O Amazon Quick Sight se integra ao Amazon Q Business para lançar uma nova experiência generativa de perguntas e respostas. Recomenda-se que os desenvolvedores usem a nova experiência de perguntas e respostas generativas. Para obter mais informações sobre a experiência incorporada de perguntas e respostas generativas, consulte [Incorporando o Amazon Q na experiência de perguntas e respostas generativas do Amazon Quick Sight](https://docs.aws.amazon.com/quicksight/latest/user/embedding-gen-bi.html).

Na seção apresentada a seguir, você descobrirá como incorporar o URL da barra de pesquisa Q da etapa 3 no site ou na página da aplicação. Você faz isso com o [SDK de incorporação do Amazon Quick Sight](https://www.npmjs.com/package/amazon-quicksight-embedding-sdk) ()JavaScript. Com o SDK, você pode fazer o seguinte: 
+ Coloque a barra de pesquisa Q em uma página HTML.
+ Adicione os parâmetros para a barra de pesquisa do Q.
+ Corrija os estados de erro com mensagens que são personalizados para seu aplicativo.

Para gerar o URL que você pode incorporar à aplicação, chame a operação de API `GenerateEmbedUrlForRegisteredUser`. Esse URL é válido por cinco minutos e a sessão resultante é válida por, no máximo, dez horas. A operação de API fornece ao URL um valor `auth_code` que possibilita uma sessão de logon único. 

Veja a seguir uma resposta de exemplo de `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"
}
```

Incorpore a barra de pesquisa Q em sua página da web usando o [SDK de incorporação do Amazon Quick Sight](https://www.npmjs.com/package/amazon-quicksight-embedding-sdk) ou adicionando essa URL em um iframe. Se você definir um número fixo de altura e largura (em pixels), o Amazon Quick Sight os usará e não alterará seu visual à medida que sua janela é redimensionada. Se você definir uma porcentagem relativa de altura e largura, o Amazon Quick Sight fornece um layout responsivo que é modificado conforme o tamanho da janela muda. 

Para fazer isso, certifique-se de que o domínio para hospedar a barra de pesquisa Q incorporada esteja na lista de *permissões, a lista* de domínios aprovados para sua assinatura do Amazon Quick Sight. Esse requisito protege seus dados, impedindo que domínios não aprovados hospedem painéis incorporados. Para obter mais informações sobre como adicionar domínios a uma barra de pesquisa Q incorporada, consulte [Gerenciamento de domínios e](https://docs.aws.amazon.com/quicksight/latest/user/manage-qs-domains-and-embedding.html) incorporação.

Quando você usa o Amazon Quick Sight Embedding SDK, a barra de pesquisa Q na sua página é redimensionada dinamicamente com base no estado. Ao usar o Amazon Quick Sight Embedding SDK, você também pode controlar os parâmetros na barra de pesquisa Q e receber retornos de chamada em termos de conclusão do carregamento da página e erros. 

O exemplo a seguir mostra como usar o URL gerado. Este código é gerado no seu servidor de aplicações.

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

Para que este exemplo funcione, certifique-se de usar o Amazon Quick Sight Embedding SDK para carregar o painel incorporado em seu site usando. JavaScript Para obter sua cópia, siga um destes procedimentos:
+ Baixe o [SDK de incorporação do Amazon Quick Sight](https://github.com/awslabs/amazon-quicksight-embedding-sdk#step-3-create-the-quicksight-session-object) em. GitHub Esse repositório é mantido por um grupo de desenvolvedores do Amazon Quick Sight.
+ Baixe a versão mais recente do SDK de incorporação em. [https://www.npmjs.com/package/amazon-quicksight-embedding-sdk](https://www.npmjs.com/package/amazon-quicksight-embedding-sdk)
+ Se você usa `npm` para JavaScript dependências, faça o download e instale-o executando o comando a seguir.

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

## Funcionalidades opcionais de incorporação da barra de pesquisa do Amazon Quick Sight Q
<a name="embedded-q-bar-for-authenticated-users-step-4"></a>

**nota**  
A barra de pesquisa incorporada do Amazon Quick Sight Q oferece a experiência clássica de perguntas e respostas do Amazon Quick Sight. O Amazon Quick Sight se integra ao Amazon Q Business para lançar uma nova experiência generativa de perguntas e respostas. Recomenda-se que os desenvolvedores usem a nova experiência de perguntas e respostas generativas. Para obter mais informações sobre a experiência incorporada de perguntas e respostas generativas, consulte [Incorporando o Amazon Q na experiência de perguntas e respostas generativas do Amazon Quick Sight](https://docs.aws.amazon.com/quicksight/latest/user/embedding-gen-bi.html).

As funcionalidades opcionais a seguir estão disponíveis para a barra de pesquisa Q incorporada usando o SDK de incorporação. 

### Invocar ações da barra de pesquisa do Q
<a name="w2aac35c27c21c43c31c15c21b7"></a>

As opções apresentadas a seguir são compatíveis somente para a incorporação da barra de pesquisa do Q. 
+ Definir uma pergunta na barra de pesquisa Q: este recurso envia uma pergunta para a barra de pesquisa Q e a consulta imediatamente. O recurso também abre automaticamente o pop-over do Q.

  ```
  qBar.setQBarQuestion('show me monthly revenue');
  ```
+ Fechar o pop-over do Q: este recurso fecha o pop-over do Q e retorna o iframe ao tamanho original da barra de pesquisa do Q.

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

Para obter mais informações, consulte o [SDK de incorporação do Amazon Quick Sight](https://github.com/awslabs/amazon-quicksight-embedding-sdk).

# Incorporação da barra de pesquisa Amazon Quick Sight Q para usuários anônimos (não registrados)
<a name="embedded-analytics-q-search-bar-for-anonymous-users"></a>


|  | 
| --- |
|    Público-alvo: desenvolvedores do Amazon Quick  | 

**nota**  
A barra de pesquisa incorporada do Amazon Quick Sight Q oferece a experiência clássica de perguntas e respostas do Amazon Quick Sight. O Amazon Quick Sight se integra ao Amazon Q Business para lançar uma nova experiência generativa de perguntas e respostas. Recomenda-se que os desenvolvedores usem a nova experiência de perguntas e respostas generativas. Para obter mais informações sobre a experiência incorporada de perguntas e respostas generativas, consulte [Incorporando o Amazon Q na experiência de perguntas e respostas generativas do Amazon Quick Sight](https://docs.aws.amazon.com/quicksight/latest/user/embedding-gen-bi.html).

Nas seções a seguir, você encontrará informações detalhadas sobre como configurar uma barra de pesquisa incorporada do Amazon Quick Sight Q para usuários anônimos (não registrados).

**Topics**
+ [

## Etapa 1: configurar permissões
](#embedded-q-bar-for-anonymous-users-step-1)
+ [

## Etapa 2: gerar o URL com o código de autenticação anexado
](#embedded-q-bar-for-anonymous-users-step-2)
+ [

## Etapa 3: incorporar o URL da barra de pesquisa do Q
](#embedded-q-bar-for-anonymous-users-step-3)
+ [

## Funcionalidades opcionais de incorporação da barra de pesquisa do Amazon Quick Sight Q
](#embedded-q-bar-for-anonymous-users-step-4)

## Etapa 1: configurar permissões
<a name="embedded-q-bar-for-anonymous-users-step-1"></a>

**nota**  
A barra de pesquisa incorporada do Amazon Quick Sight Q oferece a experiência clássica de perguntas e respostas do Amazon Quick Sight. O Amazon Quick Sight se integra ao Amazon Q Business para lançar uma nova experiência generativa de perguntas e respostas. Recomenda-se que os desenvolvedores usem a nova experiência de perguntas e respostas generativas. Para obter mais informações sobre a experiência incorporada de perguntas e respostas generativas, consulte [Incorporando o Amazon Q na experiência de perguntas e respostas generativas do Amazon Quick Sight](https://docs.aws.amazon.com/quicksight/latest/user/embedding-gen-bi.html).

Na seção a seguir, você descobrirá como configurar permissões para sua aplicação de back-end ou para o servidor Web incorporar a barra de pesquisa do Q. Essa tarefa requer acesso administrativo ao AWS Identity and Access Management (IAM).

Cada usuário que acessa uma barra de pesquisa Q assume uma função que lhe dá acesso ao Amazon Quick Sight e permissões para a barra de pesquisa Q. Para tornar isso possível, crie uma função do IAM em seu Conta da AWS. Associe uma política do IAM à função, para fornecer permissões a qualquer usuário que a assumir. A função do IAM precisa fornecer permissões para recuperar a incorporação de um URLs grupo de usuários específico. 

Com a ajuda do caractere curinga *\$1*, é possível conceder as permissões para a geração de um URL para todos os usuários em um namespace específico. Como alternativa, você pode conceder as permissões para a geração de um URL para um subconjunto de usuários em namespaces específicos. Para isso, você adiciona `quicksight:GenerateEmbedUrlForAnonymousUser`.

É possível criar uma condição na política do IAM que limite os domínios que os desenvolvedores podem listar no parâmetro `AllowedDomains` de uma operação de API `GenerateEmbedUrlForAnonymousUser`. O parâmetro `AllowedDomains` é opcional. Ele concede aos desenvolvedores a opção de substituir os domínios estáticos que estão configurados no menu Gerenciar **Amazon Quick Sight** e, em vez disso, listar até três domínios ou subdomínios que podem acessar uma URL gerada. Em seguida, esse URL é incorporado ao site do desenvolvedor. Somente os domínios que estão listados no parâmetro podem acessar a barra de pesquisa Q incorporada. Sem essa condição, os desenvolvedores podem listar qualquer domínio da Internet no parâmetro `AllowedDomains`. 

Para limitar os domínios que os desenvolvedores podem usar com esse parâmetro, adicione uma condição `AllowedEmbeddingDomains` à política do IAM. Para obter mais informações sobre o `AllowedDomains` parâmetro, consulte [GenerateEmbedUrlForAnonymousUser](https://docs.aws.amazon.com//quicksight/latest/APIReference/API_GenerateEmbedUrlForAnonymousUser.html)a *Amazon Quick Sight API Reference*.

**Prática recomendada de segurança para operadores de condições do IAM**  
Operadores de condição do IAM configurados incorretamente podem permitir acesso não autorizado aos seus recursos incorporados do Quick por meio de variações de URL. Ao usar a chave de `quicksight:AllowedEmbeddingDomains` condição em suas políticas do IAM, use operadores de condição que permitem domínios específicos ou negam todos os domínios que não são especificamente permitidos. Para obter mais informações sobre operadores de condição do IAM, consulte [Elementos de política JSON do IAM: operadores de condição](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_elements_condition_operators.html) no Guia do usuário do IAM.  
Muitas variações diferentes de URL podem apontar para o mesmo recurso. Por exemplo, URLs todos os itens a seguir têm o mesmo conteúdo:  
`https://example.com`
`https://example.com/`
`https://Example.com`
Se sua política usa operadores que não levam em conta essas variações de URL, um invasor pode contornar suas restrições fornecendo variações de URL equivalentes.  
Você deve validar se sua política do IAM usa operadores de condição apropriados para evitar ignorar vulnerabilidades e garantir que somente os domínios pretendidos possam acessar seus recursos incorporados.

A identidade do IAM da sua aplicação deve ter uma política de confiança associada a ela, para permitir acesso ao perfil que você acabou de criar. Isso significa que, quando um usuário acessar a aplicação, ele poderá assumir o perfil em nome do usuário para abrir a barra de pesquisa do Q. O exemplo apresentado a seguir mostra um exemplo de política de confianç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"
        }
    ]
}
```

------

Para obter mais informações sobre as políticas de confiança, consulte [Credenciais de segurança temporárias no IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_temp.html) no *Guia do usuário do IAM*.

## Etapa 2: gerar o URL com o código de autenticação anexado
<a name="embedded-q-bar-for-anonymous-users-step-2"></a>

**nota**  
A barra de pesquisa incorporada do Amazon Quick Sight Q oferece a experiência clássica de perguntas e respostas do Amazon Quick Sight. O Amazon Quick Sight se integra ao Amazon Q Business para lançar uma nova experiência generativa de perguntas e respostas. Recomenda-se que os desenvolvedores usem a nova experiência de perguntas e respostas generativas. Para obter mais informações sobre a experiência incorporada de perguntas e respostas generativas, consulte [Incorporando o Amazon Q na experiência de perguntas e respostas generativas do Amazon Quick Sight](https://docs.aws.amazon.com/quicksight/latest/user/embedding-gen-bi.html).

Na seção apresentada a seguir, você descobrirá como realizar a autenticação do usuário e obter o URL do tópico do Q incorporável em seu servidor de aplicações.

Quando um usuário acessa a aplicação, ela assume o perfil do IAM em nome do usuário. Em seguida, o aplicativo adiciona o usuário ao Amazon Quick Sight, caso esse usuário ainda não exista. Depois disso, ela transfere um identificador como o ID exclusivo de sessão do usuário. 

Para obter mais informações, consulte [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>

O exemplo a seguir mostra o JavaScript (Node.js) que você pode usar no servidor do aplicativo para gerar a URL para o painel incorporado. Você pode usar esse URL no seu site ou aplicativo para exibir o painel. 

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

O exemplo a seguir mostra o código em .NET/C\$1 que você pode usar no servidor de aplicações para gerar o URL para a barra de pesquisa Q incorporada. É possível usar esse URL em seu site ou em sua aplicação para exibir a barra de pesquisa do 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>

Para assumir a função, escolha uma das seguintes operações de API AWS Security Token Service (AWS STS):
+ [AssumeRole](https://docs.aws.amazon.com/STS/latest/APIReference/API_AssumeRole.html)— Use essa operação quando estiver usando uma identidade do IAM para assumir a função.
+ [AssumeRoleWithWebIdentity](https://docs.aws.amazon.com/STS/latest/APIReference/API_AssumeRoleWithWebIdentity.html)— Use essa operação quando estiver usando um provedor de identidade da web para autenticar seu usuário. 
+ [AssumeRoleWithSaml](https://docs.aws.amazon.com/STS/latest/APIReference/API_AssumeRoleWithSAML.html)— Use essa operação quando estiver usando o SAML para autenticar seus usuários.

O exemplo a seguir mostra o comando da CLI que define a função do IAM. O perfil precisa ter permissões habilitadas para `quicksight:GenerateEmbedUrlForAnonymousUser`.

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

A operação `assume-role` retorna três parâmetros de saída: a chave de acesso, a chave secreta e o token da sessão. 

**nota**  
Se você receber um erro `ExpiredToken` ao chamar a operação `AssumeRole`, isso provavelmente ocorre porque o `SESSION TOKEN` anterior ainda está nas variáveis de ambiente. Resolva isso definindo as seguintes variáveis:  
*AWS\$1ACCESS\$1KEY\$1ID* 
*AWS\$1SECRET\$1CHAVE DE ACESSO* 
*AWS\$1SESSION\$1TOKEN* 

O exemplo a seguir mostra como definir esses três parâmetros na CLI. Para uma máquina com Microsoft Windows, use `set` em vez de `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"
```

Executar esses comandos define o ID da sessão da função do usuário que está acessando o site `embedding_quicksight_q_search_bar_role/QuickSightEmbeddingAnonymousPolicy`. O ID da sessão da função é composto pelo nome da função a partir de `role-arn` e o valor de `role-session-name`. Usando o ID único da sessão da função para cada usuário garante que as permissões apropriadas sejam definidas para cada usuário. Isso também impede qualquer limitação do acesso do usuário. *A limitação* é um recurso de segurança que impede que o mesmo usuário acesse o Amazon Quick Sight de vários locais. Além disso, essa ação também mantém cada sessão separada e distinta. Se você estiver usando uma série de servidores Web, por exemplo, para balanceamento de carga, e uma sessão for reconectada a um servidor diferente, uma nova sessão será iniciada.

Para obter um URL assinado para o painel, chame `generate-embed-url-for-anynymous-user` usando o servidor de aplicações. Isso retorna o URL do painel incorporável. O exemplo a seguir mostra como gerar o URL para um painel incorporado usando uma chamada do lado do servidor para usuários que estão fazendo visitas anônimas ao seu portal da Web ou à sua aplicação.

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

Para obter mais informações sobre o uso dessa operação, consulte [https://docs.aws.amazon.com/quicksight/latest/APIReference/API_GenerateEmbedUrlForRegisteredUser.html](https://docs.aws.amazon.com/quicksight/latest/APIReference/API_GenerateEmbedUrlForRegisteredUser.html). Você pode usar essa e outras operações de API no seu próprio código.

## Etapa 3: incorporar o URL da barra de pesquisa do Q
<a name="embedded-q-bar-for-anonymous-users-step-3"></a>

**nota**  
A barra de pesquisa incorporada do Amazon Quick Sight Q oferece a experiência clássica de perguntas e respostas do Amazon Quick Sight. O Amazon Quick Sight se integra ao Amazon Q Business para lançar uma nova experiência generativa de perguntas e respostas. Recomenda-se que os desenvolvedores usem a nova experiência de perguntas e respostas generativas. Para obter mais informações sobre a experiência incorporada de perguntas e respostas generativas, consulte [Incorporando o Amazon Q na experiência de perguntas e respostas generativas do Amazon Quick Sight](https://docs.aws.amazon.com/quicksight/latest/user/embedding-gen-bi.html).

Na seção apresentada a seguir, você descobrirá como incorporar o URL da barra de pesquisa Q da etapa 3 no site ou na página da aplicação. Você faz isso com o [SDK de incorporação do Amazon Quick Sight](https://www.npmjs.com/package/amazon-quicksight-embedding-sdk) ()JavaScript. Com o SDK, você pode fazer o seguinte: 
+ Coloque a barra de pesquisa Q em uma página HTML.
+ Adicione os parâmetros para a barra de pesquisa do Q.
+ Corrija os estados de erro com mensagens que são personalizados para seu aplicativo.

Para gerar o URL que você pode incorporar à aplicação, chame a operação de API `GenerateEmbedUrlForAnonymousUser`. Esse URL é válido por cinco minutos e a sessão resultante é válida por, no máximo, dez horas. A operação de API fornece ao URL um valor `auth_code` que possibilita uma sessão de logon único. 

Veja a seguir uma resposta de exemplo de `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"
}
```

Incorpore a barra de pesquisa Q em sua página da web usando o [SDK de incorporação do Amazon Quick Sight](https://www.npmjs.com/package/amazon-quicksight-embedding-sdk) ou adicionando essa URL em um iframe. Se você definir um número fixo de altura e largura (em pixels), o Amazon Quick Sight os usará e não alterará seu visual à medida que sua janela é redimensionada. Se você definir uma porcentagem relativa de altura e largura, o Amazon Quick Sight fornece um layout responsivo que é modificado conforme o tamanho da janela muda. 

Para fazer isso, certifique-se de que o domínio para hospedar a barra de pesquisa Q incorporada esteja na lista de *permissões, a lista* de domínios aprovados para sua assinatura do Amazon Quick Sight. Este requisito protege seus dados, impedindo que domínios não aprovados hospedem a barra de pesquisa Q incorporada. Para obter mais informações sobre como adicionar domínios a uma barra de pesquisa Q incorporada, consulte [Gerenciamento de domínios e](https://docs.aws.amazon.com/quicksight/latest/user/manage-qs-domains-and-embedding.html) incorporação.

Quando você usa o Amazon Quick Sight Embedding SDK, a barra de pesquisa Q na sua página é redimensionada dinamicamente com base no estado. Ao usar o Amazon Quick Sight Embedding SDK, você também pode controlar os parâmetros na barra de pesquisa Q e receber retornos de chamada em termos de conclusão do carregamento da página e erros. 

O exemplo a seguir mostra como usar o URL gerado. Este código é gerado no seu servidor de aplicações.

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

Para que esse exemplo funcione, certifique-se de usar o Amazon Quick Sight Embedding SDK para carregar a barra de pesquisa Q incorporada em seu site usando. JavaScript Para obter sua cópia, siga um destes procedimentos:
+ Baixe o [SDK de incorporação do Amazon Quick Sight](https://github.com/awslabs/amazon-quicksight-embedding-sdk#step-3-create-the-quicksight-session-object) em. GitHub Esse repositório é mantido por um grupo de desenvolvedores do Amazon Quick Sight.
+ Baixe a versão mais recente do SDK de incorporação em. [https://www.npmjs.com/package/amazon-quicksight-embedding-sdk](https://www.npmjs.com/package/amazon-quicksight-embedding-sdk)
+ Se você usa `npm` para JavaScript dependências, faça o download e instale-o executando o comando a seguir.

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

## Funcionalidades opcionais de incorporação da barra de pesquisa do Amazon Quick Sight Q
<a name="embedded-q-bar-for-anonymous-users-step-4"></a>

**nota**  
A barra de pesquisa incorporada do Amazon Quick Sight Q oferece a experiência clássica de perguntas e respostas do Amazon Quick Sight. O Amazon Quick Sight se integra ao Amazon Q Business para lançar uma nova experiência generativa de perguntas e respostas. Recomenda-se que os desenvolvedores usem a nova experiência de perguntas e respostas generativas. Para obter mais informações sobre a experiência incorporada de perguntas e respostas generativas, consulte [Incorporando o Amazon Q na experiência de perguntas e respostas generativas do Amazon Quick Sight](https://docs.aws.amazon.com/quicksight/latest/user/embedding-gen-bi.html).

As funcionalidades opcionais a seguir estão disponíveis para a barra de pesquisa Q incorporada usando o SDK de incorporação. 

### Invocar ações da barra de pesquisa do Q
<a name="w2aac35c27c21c43c31c17c21b7"></a>

As opções apresentadas a seguir são compatíveis somente para a incorporação da barra de pesquisa do Q. 
+ Definir uma pergunta na barra de pesquisa Q: este recurso envia uma pergunta para a barra de pesquisa Q e a consulta imediatamente. O recurso também abre automaticamente o pop-over do Q.

  ```
  qBar.setQBarQuestion('show me monthly revenue');
  ```
+ Fechar o pop-over do Q: este recurso fecha o pop-over do Q e retorna o iframe ao tamanho original da barra de pesquisa do Q.

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

Para obter mais informações, consulte o [SDK de incorporação do Amazon Quick Sight](https://github.com/awslabs/amazon-quicksight-embedding-sdk).

# Como incorporar analytics usando as operações de API GetDashboardEmbedURL e GetSessionEmbedURL
<a name="embedded-analytics-deprecated"></a>


|  | 
| --- |
|  Aplica-se a: Enterprise Edition  | 


|  | 
| --- |
|    Público-alvo: desenvolvedores do Amazon Quick  | 

As seguintes operações de API para incorporar os painéis do Amazon Quick Sight e o console do Amazon Quick Sight foram substituídas pelas operações de GenerateEmbedUrlForRegisteredUser API GenerateEmbedUrlForAnonymousUser e. Você ainda pode usá-las para incorporar analytics em sua aplicação, mas elas não têm mais manutenção e não contêm os recursos ou as funcionalidades de incorporação mais recentes. Para obter a experiência de up-to-date incorporação mais recente, consulte [Incorporação da análise do Amazon Quick Sight em seus aplicativos](https://docs.aws.amazon.com/quicksight/latest/user/embedding-overview.html)
+ A operação [GetDashboardEmbedUrl](https://docs.aws.amazon.com/quicksight/latest/APIReference/API_GetDashboardEmbedUrl.html)da API incorpora painéis interativos.
+ A operação [GetSessionEmbedUrl](https://docs.aws.amazon.com/quicksight/latest/APIReference/API_GetSessionEmbedUrl.html)da API incorpora o console Amazon Quick Sight.

**Topics**
+ [

# Incorporação de painéis para todos os usuários de GetDashboardEmbedURL (API antiga)
](embedded-analytics-dashboards-with-anonymous-users-get.md)
+ [

# Incorporação de painéis para usuários registrados de GetDashboardEmbedUrl (API antiga)
](embedded-analytics-dashboards-for-authenticated-users-get.md)
+ [

# Incorporação do console Amazon Quick Sight usando GetSessionEmbedUrl (API antiga)
](embedded-analytics-full-console-for-authenticated-users-get.md)

# Incorporação de painéis para todos os usuários de GetDashboardEmbedURL (API antiga)
<a name="embedded-analytics-dashboards-with-anonymous-users-get"></a>

**Importante**  
O Amazon Quick Sight tem novidades APIs para incorporar análises: `GenerateEmbedUrlForAnonymousUser` e. `GenerateEmbedUrlForRegisteredUser`  
Você ainda pode usar o `GetDashboardEmbedUrl` e `GetSessionEmbedUrl` APIs para incorporar painéis e o console Amazon Quick Sight, mas eles não contêm os recursos de incorporação mais recentes. Para obter a experiência de up-to-date incorporação mais recente, consulte [Incorporação da análise do Amazon Quick Sight em seus aplicativos](https://docs.aws.amazon.com/quicksight/latest/user/embedding-overview.html).


|  | 
| --- |
|  Aplica-se a: Enterprise Edition  | 


|  | 
| --- |
|    Público-alvo: desenvolvedores do Amazon Quick  | 

Nas seções a seguir, você encontrará informações detalhadas sobre como configurar painéis incorporados do Amazon Quick Sight para todos (usuários não autenticados) usando URL. GetDashboardEmbed

**Topics**
+ [

# Etapa 1: configurar permissões
](embedded-analytics-dashboards-with-anonymous-users-get-step-1.md)
+ [

# Etapa 2: obter o URL com o código de autenticação anexado
](embedded-analytics-dashboards-with-anonymous-users-get-step-2.md)
+ [

# Etapa 3: incorporar o URL do painel
](embedded-analytics-dashboards-with-anonymous-users-get-step-3.md)

# Etapa 1: configurar permissões
<a name="embedded-analytics-dashboards-with-anonymous-users-get-step-1"></a>

**Importante**  
O Amazon Quick Sight tem novidades APIs para incorporar análises: `GenerateEmbedUrlForAnonymousUser` e. `GenerateEmbedUrlForRegisteredUser`  
Você ainda pode usar o `GetDashboardEmbedUrl` e `GetSessionEmbedUrl` APIs para incorporar painéis e o console Amazon Quick Sight, mas eles não contêm os recursos de incorporação mais recentes. Para obter a experiência de up-to-date incorporação mais recente, consulte [Incorporação da análise do Amazon Quick Sight em seus aplicativos](https://docs.aws.amazon.com/quicksight/latest/user/embedding-overview.html).


|  | 
| --- |
|  Aplica-se a: Enterprise Edition  | 


|  | 
| --- |
|    Público-alvo: desenvolvedores do Amazon Quick  | 

Na seção a seguir, você descobrirá como configurar permissões para a aplicação de back-end ou para o servidor Web. Essa tarefa requer acesso administrativo à IAM.

Cada usuário que acessa um painel assume uma função que lhe dá acesso e permissões ao Amazon Quick Sight para o painel. Para tornar isso possível, crie uma função do IAM em sua AWS conta. Associe uma política do IAM à função, para fornecer permissões a qualquer usuário que a assumir.

O exemplo de política apresentado a seguir fornece essas permissões para uso com `IdentityType=ANONYMOUS`. Para que essa abordagem funcione, você também precisa de um pacote de sessão, ou preço da capacidade da sessão, em sua AWS conta. Caso contrário, quando um usuário tentar acessar o painel, o erro `UnsupportedPricingPlanException` será retornado. 

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

****  

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

------

A identidade do IAM da sua aplicação deve ter uma política de confiança associada a ela, para permitir acesso ao perfil que você acabou de criar. Isso significa que, quando um usuário acessar a aplicação, ele poderá assumir o perfil em nome do usuário para abrir o painel. O exemplo a seguir mostra uma função chamada `QuickSightEmbeddingAnonymousPolicy`, que tem o exemplo de política antes do recurso. 

Para obter mais informações sobre as políticas de confiança, consulte [Credenciais de segurança temporárias no IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_temp.html) no *Guia do usuário do IAM*.

# Etapa 2: obter o URL com o código de autenticação anexado
<a name="embedded-analytics-dashboards-with-anonymous-users-get-step-2"></a>

**Importante**  
O Amazon Quick Sight tem novidades APIs para incorporar análises: `GenerateEmbedUrlForAnonymousUser` e. `GenerateEmbedUrlForRegisteredUser`  
Você ainda pode usar o `GetDashboardEmbedUrl` e `GetSessionEmbedUrl` APIs para incorporar painéis e o console Amazon Quick Sight, mas eles não contêm os recursos de incorporação mais recentes. Para obter a experiência de up-to-date incorporação mais recente, consulte [Incorporação da análise do Amazon Quick Sight em seus aplicativos](https://docs.aws.amazon.com/quicksight/latest/user/embedding-overview.html).


|  | 
| --- |
|  Aplica-se a: Enterprise Edition  | 


|  | 
| --- |
|    Público-alvo: desenvolvedores do Amazon Quick  | 

Na seção apresentada a seguir, você descobrirá como realizar a autenticação em nome do visitante anônimo e obter o URL do painel incorporável em seu servidor de aplicações. 

Quando um usuário acessa a aplicação, ela assume o perfil do IAM em nome do usuário. Em seguida, ele adiciona o usuário ao Amazon Quick Sight, se esse usuário ainda não existir. Depois disso, ela transfere um identificador como o ID exclusivo de sessão do usuário. 

Os exemplos a seguir executam a autenticação do IAM em nome do usuário. Um identificador é transferido como o ID exclusivo de sessão do usuário. Este código é executado no servidor da aplicação.

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

O exemplo a seguir mostra o JavaScript (Node.js) que você pode usar no servidor do aplicativo para obter a URL do painel incorporado. Você pode usar esse URL no seu site ou aplicativo para exibir o painel. 

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

O exemplo a seguir mostra o código.NET/C \$1 que você pode usar no servidor de aplicativo para obter o URL para o painel incorporado. Você pode usar esse URL no seu site ou aplicativo para exibir o painel. 

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

Para assumir a função, escolha uma das seguintes operações de API AWS Security Token Service (AWS STS):
+ [AssumeRole](https://docs.aws.amazon.com/STS/latest/APIReference/API_AssumeRole.html)— Use essa operação quando estiver usando uma identidade do IAM para assumir a função.
+ [AssumeRoleWithWebIdentity](https://docs.aws.amazon.com/STS/latest/APIReference/API_AssumeRoleWithWebIdentity.html)— Use essa operação quando estiver usando um provedor de identidade da web para autenticar seu usuário. 
+ [AssumeRoleWithSaml](https://docs.aws.amazon.com/STS/latest/APIReference/API_AssumeRoleWithSAML.html)— Use essa operação quando estiver usando o Security Assertion Markup Language (SAML) para autenticar seus usuários.

O exemplo a seguir mostra o comando da CLI que define a função do IAM. O perfil precisa ter permissões habilitadas para `quicksight:GetDashboardEmbedURL`. 

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

A operação `assume-role` retorna três parâmetros de saída: a chave de acesso, a chave secreta e o token da sessão. 

**nota**  
Se você receber um erro `ExpiredToken` ao chamar a operação `AssumeRole`, isso provavelmente ocorre porque o `SESSION TOKEN` anterior ainda está nas variáveis de ambiente. Resolva isso definindo as seguintes variáveis:  
*AWS\$1ACCESS\$1KEY\$1ID* 
*AWS\$1SECRET\$1CHAVE DE ACESSO* 
*AWS\$1SESSION\$1TOKEN* 

O exemplo a seguir mostra como definir esses três parâmetros na CLI. Se você estiver usando uma máquina com Microsoft Windows, use `set` em vez de `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"
```

Executar esses comandos define o ID da sessão da função do usuário que está acessando o site `embedding_quicksight_dashboard_role/QuickSightEmbeddingAnonymousPolicy`. O ID da sessão da função é composto pelo nome da função a partir de `role-arn` e o valor de `role-session-name`. Usar o ID exclusivo de sessão do perfil para cada usuário garante que as permissões apropriadas sejam definidas para todos os usuários visitantes. Essa ação também mantém cada sessão separada e distinta. Se você estiver usando uma série de servidores Web, por exemplo, para balanceamento de carga, e uma sessão for reconectada a um servidor diferente, uma nova sessão será iniciada.

Para obter um URL assinado para o painel, chame `get-dashboard-embed-url` usando o servidor de aplicações. Isso retorna o URL do painel incorporável. O exemplo a seguir mostra como obter o URL para um painel incorporado usando uma chamada do lado do servidor para usuários que estão fazendo visitas anônimas ao seu portal da Web ou à sua aplicação.

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

Para obter mais informações sobre essa operação, consulte [https://docs.aws.amazon.com/quicksight/latest/APIReference/API_GetDashboardEmbedUrl.html](https://docs.aws.amazon.com/quicksight/latest/APIReference/API_GetDashboardEmbedUrl.html). Você pode usar essa e outras operações de API no seu próprio código. 

------

# Etapa 3: incorporar o URL do painel
<a name="embedded-analytics-dashboards-with-anonymous-users-get-step-3"></a>

**Importante**  
O Amazon Quick Sight tem novidades APIs para incorporar análises: `GenerateEmbedUrlForAnonymousUser` e. `GenerateEmbedUrlForRegisteredUser`  
Você ainda pode usar o `GetDashboardEmbedUrl` e `GetSessionEmbedUrl` APIs para incorporar painéis e o console Amazon Quick Sight, mas eles não contêm os recursos de incorporação mais recentes. Para obter a experiência de up-to-date incorporação mais recente, consulte [Incorporação da análise do Amazon Quick Sight em seus aplicativos](https://docs.aws.amazon.com/quicksight/latest/user/embedding-overview.html).


|  | 
| --- |
|  Aplica-se a: Enterprise Edition  | 


|  | 
| --- |
|    Público-alvo: desenvolvedores do Amazon Quick  | 

Na seção a seguir, você pode descobrir como usar o [SDK de incorporação do Amazon Quick Sight (JavaScript) para incorporar](https://www.npmjs.com/package/amazon-quicksight-embedding-sdk) a URL do painel a partir da etapa 2 em seu site ou página de aplicativo. Com o SDK, você pode fazer o seguinte: 
+ Coloque o painel em uma página HTML.
+ Adicione parâmetros ao painel.
+ Corrija os estados de erro com mensagens que são personalizados para seu aplicativo.

Chame a operação de API `GetDashboardEmbedUrl` para obter o URL que você pode incorporar à aplicação. Este URL é válido por 5 minutos, e a sessão resultante é válida por 10 horas. A operação de API fornece ao URL um `auth_code` que possibilita uma sessão de logon único. 

Veja a seguir uma resposta de exemplo de `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"
}
```

Incorpore esse painel em sua página da web usando o Amazon Quick Sight [Embedding SDK](https://www.npmjs.com/package/amazon-quicksight-embedding-sdk) ou adicionando essa URL em um iframe. Se você definir um número fixo de altura e largura (em pixels), o Amazon Quick Sight os usará e não alterará seu visual à medida que sua janela é redimensionada. Se você definir uma porcentagem relativa de altura e largura, o Amazon Quick Sight fornece um layout responsivo que é modificado conforme o tamanho da janela muda. Ao usar o Amazon Quick Sight Embedding SDK, você também pode controlar os parâmetros no painel e receber retornos de chamada em termos de conclusão do carregamento da página e erros. 

O exemplo a seguir mostra como usar o URL gerado. Este código reside no seu servidor de aplicações.

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

Para que este exemplo funcione, certifique-se de usar o Amazon Quick Sight Embedding SDK para carregar o painel incorporado em seu site usando. JavaScript Para obter sua cópia, siga um destes procedimentos:
+ Baixe o [SDK de incorporação do Amazon Quick Sight](https://github.com/awslabs/amazon-quicksight-embedding-sdk#step-3-create-the-quicksight-session-object) em. GitHub Esse repositório é mantido por um grupo de desenvolvedores do Amazon Quick Sight.
+ Baixe a versão mais recente do SDK QuickSight de incorporação em. [https://www.npmjs.com/package/amazon-quicksight-embedding-sdk](https://www.npmjs.com/package/amazon-quicksight-embedding-sdk)
+ Se você usa `npm` para JavaScript dependências, faça o download e instale-o executando o comando a seguir.

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

# Incorporação de painéis para usuários registrados de GetDashboardEmbedUrl (API antiga)
<a name="embedded-analytics-dashboards-for-authenticated-users-get"></a>

**Importante**  
O Amazon Quick Sight tem novidades APIs para incorporar análises: `GenerateEmbedUrlForAnonymousUser` e. `GenerateEmbedUrlForRegisteredUser`  
Você ainda pode usar o `GetDashboardEmbedUrl` e `GetSessionEmbedUrl` APIs para incorporar painéis e o console Amazon Quick Sight, mas eles não contêm os recursos de incorporação mais recentes. Para obter a experiência de up-to-date incorporação mais recente, consulte [Incorporação da análise do Amazon Quick Sight em seus aplicativos](https://docs.aws.amazon.com/quicksight/latest/user/embedding-overview.html).

Nas seções a seguir, você encontrará informações detalhadas sobre como configurar painéis incorporados do Amazon Quick Sight para usuários registrados usando`GetDashboardEmbedUrl`.

**Topics**
+ [

# Etapa 1: configurar permissões
](embedded-dashboards-for-authenticated-users-get-step-1.md)
+ [

# Etapa 2: obter o URL com o código de autenticação anexado
](embedded-dashboards-for-authenticated-users-get-step-2.md)
+ [

# Etapa 3: incorporar o URL do painel
](embedded-dashboards-for-authenticated-users-get-step-3.md)

# Etapa 1: configurar permissões
<a name="embedded-dashboards-for-authenticated-users-get-step-1"></a>

**Importante**  
O Amazon Quick Sight tem novidades APIs para incorporar análises: `GenerateEmbedUrlForAnonymousUser` e. `GenerateEmbedUrlForRegisteredUser`  
Você ainda pode usar o `GetDashboardEmbedUrl` e `GetSessionEmbedUrl` APIs para incorporar painéis e o console Amazon Quick Sight, mas eles não contêm os recursos de incorporação mais recentes. Para obter a experiência de up-to-date incorporação mais recente, consulte [Incorporação da análise do Amazon Quick Sight em seus aplicativos](https://docs.aws.amazon.com/quicksight/latest/user/embedding-overview.html).

Na seção a seguir, você descobrirá como configurar permissões para a aplicação de back-end ou para o servidor Web. Essa tarefa requer acesso administrativo à IAM.

Cada usuário que acessa um painel assume uma função que lhe dá acesso e permissões ao Amazon Quick Sight para o painel. Para tornar isso possível, crie uma função do IAM em sua AWS conta. Associe uma política do IAM à função, para fornecer permissões a qualquer usuário que a assumir. A função do IAM precisa fornecer permissões para recuperar o painel URLs. Para isso, você adiciona `quicksight:GetDashboardEmbedUrl`.

O exemplo de política apresentado a seguir fornece essas permissões para uso com `IdentityType=IAM`. 

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

****  

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

------

O exemplo de política a seguir fornece permissão para recuperar um URL do painel. Você usa a política `quicksight:RegisterUser` se estiver criando usuários iniciantes que serão leitores do Amazon Quick Sight. 

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

****  

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

------

Se você usar `QUICKSIGHT` como `identityType` e fornecer o nome do recurso da Amazon (ARN) do usuário, também precisará permitir a ação `quicksight:GetAuthCode` em sua política. O exemplo de política a seguir fornece essa permissão.

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

****  

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

------

A identidade do IAM da sua aplicação deve ter uma política de confiança associada a ela, para permitir acesso ao perfil que você acabou de criar. Isso significa que, quando um usuário acessa seu aplicativo, ele pode assumir a função em nome do usuário e provisionar o usuário no Amazon Quick Sight. O exemplo a seguir mostra uma função chamada `embedding_quicksight_dashboard_role`, que tem o exemplo de política antes do recurso. 

Para mais informações sobre as políticas de confiança para autenticação SAML ou OpenId Connect, consulte as seguintes seções do *Guia do usuário do IAM: *
+ [Como criar um perfil para identidades da Web ou federação do OpenID Connect (console)](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_create_for-idp_oidc.html)
+ [Como criar um perfil para uma federação do SAML 2.0 (console)](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_create_for-idp_saml.html)

# Etapa 2: obter o URL com o código de autenticação anexado
<a name="embedded-dashboards-for-authenticated-users-get-step-2"></a>

**Importante**  
O Amazon Quick Sight tem novidades APIs para incorporar análises: `GenerateEmbedUrlForAnonymousUser` e. `GenerateEmbedUrlForRegisteredUser`  
Você ainda pode usar o `GetDashboardEmbedUrl` e `GetSessionEmbedUrl` APIs para incorporar painéis e o console Amazon Quick Sight, mas eles não contêm os recursos de incorporação mais recentes. Para obter a experiência de up-to-date incorporação mais recente, consulte [Incorporação da análise do Amazon Quick Sight em seus aplicativos](https://docs.aws.amazon.com/quicksight/latest/user/embedding-overview.html).

Na seção apresentada a seguir, você descobrirá como realizar a autenticação do usuário e obter o URL do painel incorporável em seu servidor de aplicações. 

Quando um usuário acessa a aplicação, ela assume o perfil do IAM em nome do usuário. Em seguida, ele adiciona o usuário ao Amazon Quick Sight, se esse usuário ainda não existir. Depois disso, ela transfere um identificador como o ID exclusivo de sessão do usuário. 

A execução das etapas descritas garante que cada visualizador do painel seja provisionado de forma exclusiva no Amazon Quick Sight. Ele também aplica as configurações por usuário, como a segurança em nível de linha e padrões dinâmicos para os parâmetros.

Os exemplos a seguir executam a autenticação do IAM em nome do usuário. Este código é executado no servidor da aplicação.

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

O exemplo a seguir mostra o JavaScript (Node.js) que você pode usar no servidor do aplicativo para obter a URL do painel incorporado. Você pode usar esse URL no seu site ou aplicativo para exibir o painel. 

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

O exemplo a seguir mostra o código.NET/C \$1 que você pode usar no servidor de aplicativo para obter o URL para o painel incorporado. Você pode usar esse URL no seu site ou aplicativo para exibir o painel. 

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

Para assumir a função, escolha uma das seguintes operações de API AWS Security Token Service (AWS STS):
+ [AssumeRole](https://docs.aws.amazon.com/STS/latest/APIReference/API_AssumeRole.html)— Use essa operação quando estiver usando uma identidade do IAM para assumir a função.
+ [AssumeRoleWithWebIdentity](https://docs.aws.amazon.com/STS/latest/APIReference/API_AssumeRoleWithWebIdentity.html)— Use essa operação quando estiver usando um provedor de identidade da web para autenticar seu usuário. 
+ [AssumeRoleWithSaml](https://docs.aws.amazon.com/STS/latest/APIReference/API_AssumeRoleWithSAML.html)— Use essa operação quando estiver usando o SAML para autenticar seus usuários.

O exemplo a seguir mostra o comando da CLI que define a função do IAM. O perfil precisa ter permissões habilitadas para `quicksight:GetDashboardEmbedURL`. Se você estiver adotando uma just-in-time abordagem para adicionar usuários quando eles abrem um painel pela primeira vez, a função também precisa de permissões habilitadas`quicksight:RegisterUser`.

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

A operação `assume-role` retorna três parâmetros de saída: a chave de acesso, a chave secreta e o token da sessão. 

**nota**  
Se você receber um erro `ExpiredToken` ao chamar a operação `AssumeRole`, isso provavelmente ocorre porque o `SESSION TOKEN` anterior ainda está nas variáveis de ambiente. Resolva isso definindo as seguintes variáveis:  
*AWS\$1ACCESS\$1KEY\$1ID* 
*AWS\$1SECRET\$1CHAVE DE ACESSO* 
*AWS\$1SESSION\$1TOKEN* 

O exemplo a seguir mostra como definir esses três parâmetros na CLI. Se você estiver usando uma máquina com Microsoft Windows, use `set` em vez de `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"
```

Executar esses comandos define o ID da sessão da função do usuário que está acessando o site `embedding_quicksight_dashboard_role/john.doe@example.com`. O ID da sessão da função é composto pelo nome da função a partir de `role-arn` e o valor de `role-session-name`. Usando o ID único da sessão da função para cada usuário garante que as permissões apropriadas sejam definidas para cada usuário. Isso também impede qualquer limitação do acesso do usuário. *A limitação* é um recurso de segurança que impede que o mesmo usuário acesse o Amazon Quick Sight de vários locais. 

O ID da sessão da função também se torna o nome de usuário no Amazon Quick Sight. Você pode usar esse padrão para provisionar seus usuários no Amazon Quick Sight com antecedência ou para provisioná-los na primeira vez que acessarem o painel. 

O exemplo a seguir mostra o comando da CLI que você pode usar para provisionar um usuário. Para obter mais informações sobre [RegisterUser](https://docs.aws.amazon.com/quicksight/latest/APIReference/API_RegisterUser.html), [DescribeUser](https://docs.aws.amazon.com/quicksight/latest/APIReference/API_DescribeUser.html), e outras operações da API Amazon Quick Sight, consulte a [referência da 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_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
```

Se o usuário for autenticado por meio do Microsoft AD, você não precisará usar o `RegisterUser` para configurá-lo. Em vez disso, eles devem ser automaticamente inscritos na primeira vez que acessarem o Amazon Quick Sight. Para usuários do Microsoft AD, você pode usar o `DescribeUser` para obter o ARN do usuário.

Na primeira vez que um usuário acessa o Amazon Quick Sight, você também pode adicionar esse usuário ao grupo com o qual o painel é compartilhado. O exemplo a seguir mostra o comando da CLI para adicionar um usuário a um grupo.

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

Agora você tem um usuário do seu aplicativo que também é usuário do Amazon Quick Sight e que tem acesso ao painel. 

Por fim, obtenha um signed URL para o painel, chame o `get-dashboard-embed-url` partir do servidor de aplicativo. Isso retorna o URL do painel incorporável. O exemplo a seguir mostra como obter a URL de um painel incorporado usando uma chamada do lado do servidor para usuários autenticados por meio AWS Managed Microsoft AD do IAM Identity Center.

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

Para obter mais informações sobre essa operação, consulte [https://docs.aws.amazon.com/quicksight/latest/APIReference/API_GetDashboardEmbedUrl.html](https://docs.aws.amazon.com/quicksight/latest/APIReference/API_GetDashboardEmbedUrl.html). Você pode usar essa e outras operações de API no seu próprio código. 

------

# Etapa 3: incorporar o URL do painel
<a name="embedded-dashboards-for-authenticated-users-get-step-3"></a>

**Importante**  
O Amazon Quick Sight tem novidades APIs para incorporar análises: `GenerateEmbedUrlForAnonymousUser` e. `GenerateEmbedUrlForRegisteredUser`  
Você ainda pode usar o `GetDashboardEmbedUrl` e `GetSessionEmbedUrl` APIs para incorporar painéis e o console Amazon Quick Sight, mas eles não contêm os recursos de incorporação mais recentes. Para obter a experiência de up-to-date incorporação mais recente, consulte [Incorporação da análise do Amazon Quick Sight em seus aplicativos](https://docs.aws.amazon.com/quicksight/latest/user/embedding-overview.html).

Na seção a seguir, você pode descobrir como usar o [SDK de incorporação do Amazon Quick Sight (JavaScript) para incorporar](https://www.npmjs.com/package/amazon-quicksight-embedding-sdk) a URL do painel a partir da etapa 3 em seu site ou página de aplicativo. Com o SDK, você pode fazer o seguinte: 
+ Coloque o painel em uma página HTML.
+ Adicione parâmetros ao painel.
+ Corrija os estados de erro com mensagens que são personalizados para seu aplicativo.

Chame a operação de API `GetDashboardEmbedUrl` para obter o URL que você pode incorporar à aplicação. Este URL é válido por 5 minutos, e a sessão resultante é válida por 10 horas. A operação de API fornece ao URL um `auth_code` que possibilita uma sessão de logon único. 

Veja a seguir uma resposta de exemplo de `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"
}
```

Incorpore esse painel em sua página da web usando o [SDK de incorporação do Amazon Quick Sight](https://www.npmjs.com/package/amazon-quicksight-embedding-sdk) ou adicionando essa URL a um iframe. Se você definir um número fixo de altura e largura (em pixels), o Amazon Quick Sight os usará e não alterará seu visual à medida que sua janela é redimensionada. Se você definir uma porcentagem relativa de altura e largura, o Amazon Quick Sight fornece um layout responsivo que é modificado conforme o tamanho da janela muda. Ao usar o Amazon Quick Sight Embedding SDK, você também pode controlar os parâmetros no painel e receber retornos de chamada em termos de conclusão do carregamento da página e erros. 

O exemplo a seguir mostra como usar o URL gerado. Este código é gerado no seu servidor de aplicações.

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

Para que este exemplo funcione, certifique-se de usar o Amazon Quick Sight Embedding SDK para carregar o painel incorporado em seu site usando. JavaScript Para obter sua cópia, siga um destes procedimentos:
+ Baixe o [SDK de incorporação do Amazon Quick Sight](https://github.com/awslabs/amazon-quicksight-embedding-sdk#step-3-create-the-quicksight-session-object) em. GitHub Esse repositório é mantido por um grupo de desenvolvedores do Amazon Quick Sight.
+ Baixe a versão mais recente do SDK de incorporação em. [https://www.npmjs.com/package/amazon-quicksight-embedding-sdk](https://www.npmjs.com/package/amazon-quicksight-embedding-sdk)
+ Se você usa `npm` para JavaScript dependências, faça o download e instale-o executando o comando a seguir.

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

# Incorporação do console Amazon Quick Sight usando GetSessionEmbedUrl (API antiga)
<a name="embedded-analytics-full-console-for-authenticated-users-get"></a>

**Importante**  
O Amazon Quick Sight tem novidades APIs para incorporar análises: `GenerateEmbedUrlForAnonymousUser` e. `GenerateEmbedUrlForRegisteredUser`  
Você ainda pode usar o `GetDashboardEmbedUrl` e `GetSessionEmbedUrl` APIs para incorporar painéis e o console Amazon Quick Sight, mas eles não contêm os recursos de incorporação mais recentes. Para obter a experiência de up-to-date incorporação mais recente, consulte [Incorporação da análise do Amazon Quick Sight em seus aplicativos](https://docs.aws.amazon.com/quicksight/latest/user/embedding-overview.html).


|  | 
| --- |
|  Aplica-se a: Enterprise Edition  | 


|  | 
| --- |
|    Público-alvo: desenvolvedores do Amazon Quick  | 

Nas seções a seguir, você encontrará informações detalhadas sobre como fornecer a experiência de console do Amazon Quick Sight em um portal de criação personalizado para usuários registrados usando a API. `GetSessionEmbedUrl` 

**Topics**
+ [

# Etapa 1: configurar permissões
](embedded-analytics-full-console-for-authenticated-users-get-step-1.md)
+ [

# Etapa 2: obter o URL com o código de autenticação anexado
](embedded-analytics-full-console-for-authenticated-users-get-step-2.md)
+ [

# Etapa 3: incorporar o URL da sessão do console
](embedded-analytics-full-console-for-authenticated-users-get-step-3.md)

# Etapa 1: configurar permissões
<a name="embedded-analytics-full-console-for-authenticated-users-get-step-1"></a>

**Importante**  
O Amazon Quick Sight tem novidades APIs para incorporar análises: `GenerateEmbedUrlForAnonymousUser` e. `GenerateEmbedUrlForRegisteredUser`  
Você ainda pode usar o `GetDashboardEmbedUrl` e `GetSessionEmbedUrl` APIs para incorporar painéis e o console Amazon Quick Sight, mas eles não contêm os recursos de incorporação mais recentes. Para obter a experiência de up-to-date incorporação mais recente, consulte [Incorporação da análise do Amazon Quick Sight em seus aplicativos](https://docs.aws.amazon.com/quicksight/latest/user/embedding-overview.html).

Na seção a seguir, você descobrirá como configurar permissões para a aplicação de back-end ou para o servidor Web. Essa tarefa requer acesso administrativo à IAM.

Cada usuário que acessa um Amazon Quick Sight assume uma função que lhe dá acesso e permissões ao Amazon Quick Sight para a sessão do console. Para tornar isso possível, crie uma função do IAM em sua AWS conta. Associe uma política do IAM à função, para fornecer permissões a qualquer usuário que a assumir. Adicione `quicksight:RegisterUser` permissões para garantir que o leitor possa acessar o Amazon Quick Sight somente para leitura e não tenha acesso a nenhum outro recurso de dados ou criação. A função do IAM também precisa fornecer permissões para recuperar a sessão URLs do console. Para isso, você adiciona `quicksight:GetSessionEmbedUrl`.

O exemplo de política apresentado a seguir fornece essas permissões para uso com `IdentityType=IAM`. 

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

****  

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

------

O exemplo de política a seguir fornece permissão para recuperar um URL da sessão do console. Você usa a política sem `quicksight:RegisterUser`, se estiver criando usuários antes que eles acessem uma sessão incorporada.

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

****  

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

------

Se você usar `QUICKSIGHT` como `identityType` e fornecer o nome do recurso da Amazon (ARN) do usuário, também precisará permitir a ação `quicksight:GetAuthCode` em sua política. O exemplo de política a seguir fornece essa permissão.

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

****  

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

------

A identidade do IAM da sua aplicação deve ter uma política de confiança associada a ela, para permitir acesso ao perfil que você acabou de criar. Isso significa que, quando um usuário acessa seu aplicativo, ele pode assumir a função em nome do usuário e provisionar o usuário no Amazon Quick Sight. O exemplo a seguir mostra uma função chamada `embedding_quicksight_console_session_role`, que tem o exemplo de política antes do recurso. 

Para mais informações sobre as políticas de confiança para autenticação SAML ou OpenId Connect, consulte as seguintes seções do *Guia do usuário do IAM: *
+ [Como criar um perfil para identidades da Web ou federação do OpenID Connect (console)](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_create_for-idp_oidc.html)
+ [Como criar um perfil para uma federação do SAML 2.0 (console)](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_create_for-idp_saml.html)

# Etapa 2: obter o URL com o código de autenticação anexado
<a name="embedded-analytics-full-console-for-authenticated-users-get-step-2"></a>

**Importante**  
O Amazon Quick Sight tem novidades APIs para incorporar análises: `GenerateEmbedUrlForAnonymousUser` e. `GenerateEmbedUrlForRegisteredUser`  
Você ainda pode usar o `GetDashboardEmbedUrl` e `GetSessionEmbedUrl` APIs para incorporar painéis e o console Amazon Quick Sight, mas eles não contêm os recursos de incorporação mais recentes. Para obter a experiência de up-to-date incorporação mais recente, consulte [Incorporação da análise do Amazon Quick Sight em seus aplicativos](https://docs.aws.amazon.com/quicksight/latest/user/embedding-overview.html).

Na seção apresentada a seguir, você descobrirá como realizar a autenticação do usuário e obter o URL da sessão do console incorporável em seu servidor de aplicações. 

Quando um usuário acessa a aplicação, ela assume o perfil do IAM em nome do usuário. Em seguida, ele adiciona o usuário ao Amazon Quick Sight, se esse usuário ainda não existir. Depois disso, ela transfere um identificador como o ID exclusivo de sessão do usuário. 

A execução das etapas descritas garante que cada visualizador da sessão do console seja provisionado de forma exclusiva no Amazon Quick Sight. Ele também aplica as configurações por usuário, como a segurança em nível de linha e padrões dinâmicos para os parâmetros.

Os exemplos a seguir executam a autenticação do IAM em nome do usuário. Este código é executado no servidor da aplicação.

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

O exemplo a seguir mostra o JavaScript (Node.js) que você pode usar no servidor do aplicativo para obter a URL da sessão do console incorporado. É possível usar esse URL em seu site ou em sua aplicação para exibir a sessão do console. 

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

O exemplo a seguir mostra o código em .NET/C\$1 que você pode usar no servidor de aplicações para obter o URL para a sessão do console incorporada. É possível usar esse URL em seu site ou em sua aplicação para exibir o console. 

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

Para assumir a função, escolha uma das seguintes operações de API AWS Security Token Service (AWS STS):
+ [AssumeRole](https://docs.aws.amazon.com/STS/latest/APIReference/API_AssumeRole.html)— Use essa operação quando estiver usando uma identidade do IAM para assumir a função.
+ [AssumeRoleWithWebIdentity](https://docs.aws.amazon.com/STS/latest/APIReference/API_AssumeRoleWithWebIdentity.html)— Use essa operação quando estiver usando um provedor de identidade da web para autenticar seu usuário. 
+ [AssumeRoleWithSaml](https://docs.aws.amazon.com/STS/latest/APIReference/API_AssumeRoleWithSAML.html)— Use essa operação quando estiver usando o SAML para autenticar seus usuários.

O exemplo a seguir mostra o comando da CLI que define a função do IAM. O perfil precisa ter permissões habilitadas para `quicksight:GetSessionEmbedUrl`. Se você está adotando uma just-in-time abordagem para adicionar usuários quando eles abrem o Amazon Quick Sight pela primeira vez, a função também precisa de permissões habilitadas`quicksight:RegisterUser`.

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

A operação `assume-role` retorna três parâmetros de saída: a chave de acesso, a chave secreta e o token da sessão. 

**nota**  
Se você receber um erro `ExpiredToken` ao chamar a operação `AssumeRole`, isso provavelmente ocorre porque o `SESSION TOKEN` anterior ainda está nas variáveis de ambiente. Resolva isso definindo as seguintes variáveis:  
*AWS\$1ACCESS\$1KEY\$1ID* 
*AWS\$1SECRET\$1CHAVE DE ACESSO* 
*AWS\$1SESSION\$1TOKEN* 

O exemplo a seguir mostra como definir esses três parâmetros na CLI. Se você estiver usando uma máquina com Microsoft Windows, use `set` em vez de `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"
```

Executar esses comandos define o ID da sessão da função do usuário que está acessando o site `embedding_quicksight_console_session_role/john.doe@example.com`. O ID da sessão da função é composto pelo nome da função a partir de `role-arn` e o valor de `role-session-name`. Usando o ID único da sessão da função para cada usuário garante que as permissões apropriadas sejam definidas para cada usuário. Isso também impede qualquer limitação do acesso do usuário. A limitação é um recurso de segurança que impede que o mesmo usuário acesse o Amazon Quick Sight de vários locais. 

O ID da sessão da função também se torna o nome de usuário no Amazon Quick Sight. Você pode usar esse padrão para provisionar seus usuários no Amazon Quick Sight com antecedência ou para provisioná-los na primeira vez que acessarem uma sessão de console. 

O exemplo a seguir mostra o comando da CLI que você pode usar para provisionar um usuário. Para obter mais informações sobre [RegisterUser](https://docs.aws.amazon.com/quicksight/latest/APIReference/API_RegisterUser.html), [DescribeUser](https://docs.aws.amazon.com/quicksight/latest/APIReference/API_DescribeUser.html), e outras operações da API Amazon Quick Sight, consulte a [referência da 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_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
```

Se o usuário for autenticado por meio do Microsoft AD, você não precisará usar o `RegisterUser` para configurá-lo. Em vez disso, eles devem ser automaticamente inscritos na primeira vez que acessarem o Amazon Quick Sight. Para usuários do Microsoft AD, você pode usar o `DescribeUser` para obter o ARN do usuário.

Na primeira vez que um usuário acessa o Amazon Quick Sight, você também pode adicionar esse usuário ao grupo apropriado. O exemplo a seguir mostra o comando da CLI para adicionar um usuário a um grupo.

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

Agora você tem um usuário do seu aplicativo que também é usuário do Amazon Quick Sight e que tem acesso à sessão do console do Amazon Quick Sight. 

Por fim, para obter um URL assinado para a sessão do console, chame `get-session-embed-url` usando o servidor de aplicações. Isso retorna o URL da sessão do console incorporável. O exemplo a seguir mostra como obter a URL de uma sessão de console incorporada usando uma chamada do lado do servidor para usuários autenticados por meio do Single Sign-on ( AWS Managed Microsoft AD IAM Identity Center).

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

Para obter mais informações sobre essa operação, consulte [https://docs.aws.amazon.com/quicksight/latest/APIReference/API_GetSessionEmbedUrl.html](https://docs.aws.amazon.com/quicksight/latest/APIReference/API_GetSessionEmbedUrl.html). Você pode usar essa e outras operações de API no seu próprio código. 

------

# Etapa 3: incorporar o URL da sessão do console
<a name="embedded-analytics-full-console-for-authenticated-users-get-step-3"></a>

**Importante**  
O Amazon Quick Sight tem novidades APIs para incorporar análises: `GenerateEmbedUrlForAnonymousUser` e. `GenerateEmbedUrlForRegisteredUser`  
Você ainda pode usar o `GetDashboardEmbedUrl` e `GetSessionEmbedUrl` APIs para incorporar painéis e o console Amazon Quick Sight, mas eles não contêm os recursos de incorporação mais recentes. Para obter a experiência de up-to-date incorporação mais recente, consulte [Incorporação da análise do Amazon Quick Sight em seus aplicativos](https://docs.aws.amazon.com/quicksight/latest/user/embedding-overview.html).

Na seção a seguir, você pode descobrir como usar o [SDK de incorporação do Amazon Quick Sight (JavaScript) para incorporar](https://www.npmjs.com/package/amazon-quicksight-embedding-sdk) o URL da sessão do console a partir da etapa 3 em seu site ou página do aplicativo. Com o SDK, você pode fazer o seguinte: 
+ Estabeleça a sessão do console em uma página HTML.
+ Adicione os parâmetros para a sessão do console.
+ Corrija os estados de erro com mensagens que são personalizados para seu aplicativo.

Chame a operação de API `GetSessionEmbedUrl` para obter o URL que você pode incorporar à aplicação. Este URL é válido por 5 minutos, e a sessão resultante é válida por 10 horas. A operação de API fornece ao URL um `auth_code` que possibilita uma sessão de logon único. 

Veja a seguir uma resposta de exemplo de `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"
}
```

Incorpore essa sessão de console em sua página da web usando o Amazon Quick Sight [Embedding SDK](https://www.npmjs.com/package/amazon-quicksight-embedding-sdk) ou adicionando essa URL em um iframe. Se você definir um número fixo de altura e largura (em pixels), o Amazon Quick Sight os usará e não alterará seu visual à medida que sua janela é redimensionada. Se você definir uma porcentagem relativa de altura e largura, o Amazon Quick Sight fornece um layout responsivo que é modificado conforme o tamanho da janela muda. Ao usar o Amazon Quick Sight Embedding SDK, você também pode controlar os parâmetros na sessão do console e receber retornos de chamada em termos de conclusão do carregamento da página e erros. 

O exemplo a seguir mostra como usar o URL gerado. Este código é gerado no seu servidor de aplicações.

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

Para que esse exemplo funcione, certifique-se de usar o Amazon Quick Sight Embedding SDK para carregar a sessão do console incorporado em seu site usando. JavaScript Para obter sua cópia, siga um destes procedimentos:
+ Baixe o [SDK de incorporação do Amazon Quick Sight](https://github.com/awslabs/amazon-quicksight-embedding-sdk#step-3-create-the-quicksight-session-object) em. GitHub Esse repositório é mantido por um grupo de desenvolvedores do Amazon Quick Sight.
+ Baixe a versão mais recente do SDK de incorporação em. [https://www.npmjs.com/package/amazon-quicksight-embedding-sdk](https://www.npmjs.com/package/amazon-quicksight-embedding-sdk)
+ Se você usa `npm` para JavaScript dependências, faça o download e instale-o executando o comando a seguir.

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