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

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