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á.

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