Etapa 2: obter o URL com o código de autenticação anexado

Importante

O Amazon QuickSight tem novas APIs para incorporar analytics: GenerateEmbedUrlForAnonymousUser e GenerateEmbedUrlForRegisteredUser.

Você ainda pode usar as APIs GetDashboardEmbedUrl e GetSessionEmbedUrl para incorporar os painéis e o console do QuickSight, mas elas não contêm as funcionalidades de incorporação mais recentes. Para obter a experiência de incorporação mais recente e atualizada, consulte Incorporação de analytics do QuickSight nas aplicações.

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, a aplicação adiciona o usuário ao QuickSight, 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 exclusivamente no QuickSight. 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 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 a sessão do console.


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);
            });


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

O exemplo a seguir mostra o código em .NET/C# 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.



            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 do AWS Security Token Service (AWS STS):

AssumeRole: use esta operação quando estiver usando uma identidade do IAM para assumir o perfil.
AssumeRoleWithWebIdentity: use esta operação quando estiver usando um provedor de identidades da Web para autenticar seu usuário.
AssumeRoleWithSaml: use esta operação quando estiver usando a 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ê estiver adotando uma abordagem just-in-time para adicionar usuários quando eles abrirem o QuickSight pela primeira vez, o perfil também precisará de permissões habilitadas para 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_ACCESS_KEY_ID
AWS_SECRET_ACCESS_KEY
AWS_SESSION_TOKEN

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. O controle de utilização corresponde a um recurso de segurança que impede que o mesmo usuário acesse o QuickSight de vários locais.

Além disso, o ID da sessão do perfil se torna o nome do usuário no QuickSight. Você pode usar esse padrão para provisionar os usuários no QuickSight antecipadamente ou para provisioná-los na primeira vez em que acessarem uma sessão do 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, DescribeUser e outras operações de API do QuickSight, consulte a Referência da API do QuickSight.


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, os usuários devem ser inscritos automaticamente na primeira vez que acessarem o QuickSight. 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 QuickSight, você também pode adicioná-lo 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 da sua aplicação que também é um usuário do QuickSight e tem acesso à sessão do console do QuickSight.

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 o URL para uma sessão do console incorporada usando uma chamada do lado do servidor para usuários autenticados por meio do AWS Managed Microsoft AD ou do Single Sign-On (Centro de Identidade do IAM).


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 GetSessionEmbedUrl. Você pode usar essa e outras operações de API no seu próprio código.

Atenção O Javascript está desativado ou não está disponível no seu navegador.

Para usar a documentação da AWS, o Javascript deve estar ativado. Consulte as páginas de Ajuda do navegador para obter instruções.

Convenções do documento

Etapa 1: configurar permissões

Etapa 3: incorporar o URL