Las traducciones son generadas a través de traducción automática. En caso de conflicto entre la traducción y la version original de inglés, prevalecerá la version en inglés.

# Incorporación de paneles de Amazon Quick Sight para usuarios anónimos (no registrados)
<a name="embedded-analytics-dashboards-for-everyone"></a>

**importante**  
Amazon Quick Sight tiene nuevas operaciones de API para incorporar análisis: `GenerateEmbedUrlForAnonymousUser` y`GenerateEmbedUrlForRegisteredUser`.  
Puede seguir utilizando las operaciones `GetDashboardEmbedUrl` y las de la `GetSessionEmbedUrl` API para incrustar paneles y la consola Amazon Quick Sight, pero no incluyen las capacidades de incrustación más recientes. Para obtener más información sobre la incrustación mediante las operaciones de API antiguas, consulte [Incrustar análisis mediante las GetDashboardEmbedURL](https://docs.aws.amazon.com/quicksight/latest/user/embedded-analytics-deprecated.html) operaciones de API y. GetSessionEmbedURL


|  | 
| --- |
|  Se aplica a: Enterprise Edition  | 


|  | 
| --- |
|    Público objetivo: desarrolladores de Amazon Quick  | 

En las siguientes secciones, encontrará información detallada sobre cómo configurar los paneles de Amazon Quick Sight integrados para usuarios anónimos (no registrados).

**Topics**
+ [Paso 1: configuración de permisos](#embedded-analytics-dashboards-with-anonymous-users-step-1)
+ [Paso 2: generación de la URL con el código de autenticación adjunto](#embedded-analytics-dashboards-with-anonymous-users-step-2)
+ [Paso 3 integración de la URL del panel](#embedded-analytics-dashboards-with-anonymous-users-step-3)

## Paso 1: configuración de permisos
<a name="embedded-analytics-dashboards-with-anonymous-users-step-1"></a>


|  | 
| --- |
|  Se aplica a: Enterprise Edition  | 


|  | 
| --- |
|    Público objetivo: desarrolladores de Amazon Quick  | 

En la siguiente sección, puede encontrar cómo configurar los permisos de la aplicación de backend o del servidor web. Esta tarea requiere acceso administrativo a IAM.

Cada usuario que accede a un panel de control asume un rol que le da acceso a Amazon Quick Sight y permisos para acceder al panel. Para que esto sea posible, cree un rol de IAM en su. Cuenta de AWS Asocie una política de IAM al rol para proporcionar permisos a cualquier usuario que lo asuma.

Puede crear una condición en su política de IAM que limite los dominios que los desarrolladores pueden incluir en el parámetro `AllowedDomains` de una operación de la API `GenerateEmbedUrlForAnonymousUser`. El parámetro `AllowedDomains` es opcional. Como desarrollador, tiene la opción de anular los dominios estáticos que están configurados en el menú **Gestionar Amazon Quick Sight**. En su lugar, puede enumerar hasta tres dominios o subdominios que pueden acceder a una URL generada. A continuación, esta URL se integra en el sitio web que cree. Solo los dominios que aparecen en el parámetro pueden acceder al panel integrado. Sin esta condición, usted puede incluir cualquier dominio de Internet en el parámetro `AllowedDomains`. 

Para limitar los dominios que los desarrolladores pueden usar con este parámetro, añada una condición `AllowedEmbeddingDomains` a su política de IAM. Para obtener más información sobre el `AllowedDomains` parámetro, consulte la *referencia [GenerateEmbedUrlForAnonymousUser](https://docs.aws.amazon.com//quicksight/latest/APIReference/API_GenerateEmbedUrlForAnonymousUser.html)de la API de Amazon Quick Sight*.

**Prácticas recomendadas de seguridad para los operadores de condiciones de IAM**  
Los operadores de condiciones de IAM configurados incorrectamente pueden permitir el acceso no autorizado a los recursos rápidos integrados mediante variaciones de URL. Cuando utilices la clave de `quicksight:AllowedEmbeddingDomains` condición en tus políticas de IAM, utiliza operadores de condiciones que permitan dominios específicos o denieguen todos los dominios que no estén específicamente permitidos. Para obtener más información sobre los operadores de condiciones de IAM, consulte [Elementos de la política JSON de IAM: operadores de condiciones](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_elements_condition_operators.html) en la Guía del usuario de IAM.  
Muchas variaciones de URL diferentes pueden apuntar al mismo recurso. Por ejemplo, URLs todo lo siguiente tiene el mismo contenido:  
`https://example.com`
`https://example.com/`
`https://Example.com`
Si su política utiliza operadores que no tienen en cuenta estas variaciones de URL, un atacante puede eludir sus restricciones proporcionando variaciones de URL equivalentes.  
Debe comprobar que su política de IAM utiliza los operadores de condiciones adecuados para evitar que se eludan las vulnerabilidades y garantizar que solo los dominios a los que va destinados puedan acceder a los recursos integrados.

La siguiente política de ejemplo ofrece estos permisos para usar con `GenerateEmbedUrlForAnonymousUser`. Para que este enfoque funcione, también necesita un paquete de sesiones, o un precio por capacidad de sesión, para su Cuenta de AWS. De lo contrario, cuando un usuario intenta acceder al panel de control, se devuelve el error `UnsupportedPricingPlanException`. 

La identidad de IAM de su aplicación debe tener asociada una política de confianza para permitir el acceso al rol que acaba de crear. Esto significa que, cuando un usuario accede a su aplicación, esta puede asumir el rol en nombre del usuario para abrir el panel. En el siguiente ejemplo, se muestra una muestra de política de confianza.

------
#### [ 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 obtener más información sobre las políticas de confianza, consulte [Credenciales de seguridad temporales en IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_temp.html) en la *Guía del usuario de IAM*.

## Paso 2: generación de la URL con el código de autenticación adjunto
<a name="embedded-analytics-dashboards-with-anonymous-users-step-2"></a>


|  | 
| --- |
|  Se aplica a: Enterprise Edition  | 


|  | 
| --- |
|    Público objetivo: desarrolladores de Amazon Quick  | 

En la siguiente sección, puede obtener información sobre cómo autenticarse en nombre del visitante anónimo y obtener la URL del panel integrable en el servidor de su aplicación. 

Cuando un usuario accede a su aplicación, esta asume el rol de IAM en nombre del usuario. A continuación, añade el usuario a Amazon Quick Sight, si ese usuario aún no existe. A continuación, transfiere un identificador como ID de sesión de rol único. 

Los siguientes ejemplos realizan la autenticación de IAM en nombre del usuario. Transfiere un identificador como ID de sesión de rol único. Este código se ejecuta en el servidor de aplicaciones.

### Java
<a name="embedded-analytics-dashboards-with-anonymous-users-java"></a>

```
import java.util.List;
    import com.amazonaws.auth.AWSCredentials;
    import com.amazonaws.auth.AWSCredentialsProvider;
    import com.amazonaws.auth.BasicAWSCredentials;
    import com.amazonaws.regions.Regions;
    import com.amazonaws.services.quicksight.AmazonQuickSight;
    import com.amazonaws.services.quicksight.AmazonQuickSightClientBuilder;
    import com.amazonaws.services.quicksight.model.RegisteredUserDashboardEmbeddingConfiguration;
    import com.amazonaws.services.quicksight.model.AnonymousUserEmbeddingExperienceConfiguration;
    import com.amazonaws.services.quicksight.model.GenerateEmbedUrlForAnonymousUserRequest;
    import com.amazonaws.services.quicksight.model.GenerateEmbedUrlForAnonymousUserResult;
    import com.amazonaws.services.quicksight.model.SessionTag;


    /**
    * Class to call QuickSight AWS SDK to generate embed url for anonymous user.
    */
    public class GenerateEmbedUrlForAnonymousUserExample {

        private final AmazonQuickSight quickSightClient;

        public GenerateEmbedUrlForAnonymousUserExample() {
            quickSightClient = AmazonQuickSightClientBuilder
                .standard()
                .withRegion(Regions.US_EAST_1.getName())
                .withCredentials(new AWSCredentialsProvider() {
                        @Override
                        public AWSCredentials getCredentials() {
                            // provide actual IAM access key and secret key here
                            return new BasicAWSCredentials("access-key", "secret-key");
                        }

                        @Override
                        public void refresh() {
                        }
                    }
                )
                .build();
        }

        public String GenerateEmbedUrlForAnonymousUser(
            final String accountId, // YOUR AWS ACCOUNT ID
            final String initialDashboardId, // DASHBOARD ID TO WHICH THE CONSTRUCTED URL POINTS.
            final String namespace, // ANONYMOUS EMBEDDING REQUIRES SPECIFYING A VALID NAMESPACE FOR WHICH YOU WANT THE EMBEDDING URL
            final List<String> authorizedResourceArns, // DASHBOARD ARN LIST TO EMBED
            final List<String> allowedDomains, // RUNTIME ALLOWED DOMAINS FOR EMBEDDING
            final List<SessionTag> sessionTags // SESSION TAGS USED FOR ROW-LEVEL SECURITY
        ) throws Exception {
            AnonymousUserEmbeddingExperienceConfiguration experienceConfiguration = new AnonymousUserEmbeddingExperienceConfiguration();
            AnonymousUserDashboardEmbeddingConfiguration dashboardConfiguration = new AnonymousUserDashboardEmbeddingConfiguration();
            dashboardConfiguration.setInitialDashboardId(initialDashboardId);
            experienceConfiguration.setDashboard(dashboardConfiguration);

            GenerateEmbedUrlForAnonymousUserRequest generateEmbedUrlForAnonymousUserRequest = new GenerateEmbedUrlForAnonymousUserRequest()
                .withAwsAccountId(accountId)
                .withNamespace(namespace)
                .withAuthorizedResourceArns(authorizedResourceArns)
                .withExperienceConfiguration(experienceConfiguration)
                .withSessionTags(sessionTags)
                .withSessionLifetimeInMinutes(600L); // OPTIONAL: VALUE CAN BE [15-600]. DEFAULT: 600
                .withAllowedDomains(allowedDomains);

            GenerateEmbedUrlForAnonymousUserResult dashboardEmbedUrl = quickSightClient.generateEmbedUrlForAnonymousUser(generateEmbedUrlForAnonymousUserRequest);

            return dashboardEmbedUrl.getEmbedUrl();
        }

    }
```

### JavaScript
<a name="embedded-analytics-dashboards-with-anonymous-users-js"></a>

```
global.fetch = require('node-fetch');
const AWS = require('aws-sdk');

function generateEmbedUrlForAnonymousUser(
accountId, // YOUR AWS ACCOUNT ID
initialDashboardId, // DASHBOARD ID TO WHICH THE CONSTRUCTED URL POINTS
quicksightNamespace, // VALID NAMESPACE WHERE YOU WANT TO DO NOAUTH EMBEDDING
authorizedResourceArns, // DASHBOARD ARN LIST TO EMBED
allowedDomains, // RUNTIME ALLOWED DOMAINS FOR EMBEDDING
sessionTags, // SESSION TAGS USED FOR ROW-LEVEL SECURITY
generateEmbedUrlForAnonymousUserCallback, // GENERATEEMBEDURLFORANONYMOUSUSER SUCCESS CALLBACK METHOD
errorCallback // GENERATEEMBEDURLFORANONYMOUSUSER ERROR CALLBACK METHOD
) {
const experienceConfiguration = {
    "DashboardVisual": {
        "InitialDashboardVisualId": {
            "DashboardId": "dashboard_id",
            "SheetId": "sheet_id",
            "VisualId": "visual_id"
        }
    }
};

const generateEmbedUrlForAnonymousUserParams = {
    "AwsAccountId": accountId,
    "Namespace": quicksightNamespace,
    "AuthorizedResourceArns": authorizedResourceArns,
    "AllowedDomains": allowedDomains,
    "ExperienceConfiguration": experienceConfiguration,
    "SessionTags": sessionTags,
    "SessionLifetimeInMinutes": 600
};

const quicksightClient = new AWS.QuickSight({
    region: process.env.AWS_REGION,
    credentials: {
        accessKeyId: AccessKeyId,
        secretAccessKey: SecretAccessKey,
        sessionToken: SessionToken,
        expiration: Expiration
    }
});

quicksightClient.generateEmbedUrlForAnonymousUser(generateEmbedUrlForAnonymousUserParams, function(err, data) {
    if (err) {
        console.log(err, err.stack);
        errorCallback(err);
    } else {
        const result = {
            "statusCode": 200,
            "headers": {
                "Access-Control-Allow-Origin": "*", // USE YOUR WEBSITE DOMAIN TO SECURE ACCESS TO THIS API
                "Access-Control-Allow-Headers": "Content-Type"
            },
            "body": JSON.stringify(data),
            "isBase64Encoded": false
        }
        generateEmbedUrlForAnonymousUserCallback(result);
    }
});
}
```

### Python3
<a name="embedded-analytics-dashboards-with-anonymous-users-py"></a>

```
import json
import boto3
from botocore.exceptions import ClientError
import time

# Create QuickSight and STS clients
quicksightClient = boto3.client('quicksight',region_name='us-west-2')
sts = boto3.client('sts')

# Function to generate embedded URL for anonymous user
# accountId: YOUR AWS ACCOUNT ID
# quicksightNamespace: VALID NAMESPACE WHERE YOU WANT TO DO NOAUTH EMBEDDING
# authorizedResourceArns: DASHBOARD ARN LIST TO EMBED
# allowedDomains: RUNTIME ALLOWED DOMAINS FOR EMBEDDING
# dashboardId: DASHBOARD ID TO WHICH THE CONSTRUCTED URL POINTS
# sessionTags: SESSION TAGS USED FOR ROW-LEVEL SECURITY
def generateEmbedUrlForAnonymousUser(accountId, quicksightNamespace, authorizedResourceArns, allowedDomains, dashboardId, sessionTags):
try:
    response = quicksightClient.generate_embed_url_for_anonymous_user(
        AwsAccountId = accountId,
        Namespace = quicksightNamespace,
        AuthorizedResourceArns = authorizedResourceArns,
        AllowedDomains = allowedDomains,
            ExperienceConfiguration = {
                "Dashboard": {
                    "InitialDashboardId": dashboardId
                }
            },
        SessionTags = sessionTags,
        SessionLifetimeInMinutes = 600
    )
        
    return {
        'statusCode': 200,
        'headers': {"Access-Control-Allow-Origin": "*", "Access-Control-Allow-Headers": "Content-Type"},
        'body': json.dumps(response),
        'isBase64Encoded':  bool('false')
    }
except ClientError as e:
    print(e)
    return "Error generating embeddedURL: " + str(e)
```

### Node.js
<a name="embedded-analytics-dashboards-with-anonymous-users-node"></a>

El siguiente ejemplo muestra el archivo JavaScript (Node.js) que puede usar en el servidor de aplicaciones para generar la URL del panel integrado. Puede utilizar esta URL en su sitio web o aplicación para mostrar el panel. 

**Example**  

```
const AWS = require('aws-sdk');
    const https = require('https');

    var quicksightClient = new AWS.Service({
        apiConfig: require('./quicksight-2018-04-01.min.json'),
        region: 'us-east-1',
    });

    quicksightClient.generateEmbedUrlForAnonymousUser({
        'AwsAccountId': '111122223333',
        'Namespace' : 'default',
        'AuthorizedResourceArns': authorizedResourceArns,
        'AllowedDomains': allowedDomains,
        'ExperienceConfiguration': experienceConfiguration,
        'SessionTags': sessionTags,
        'SessionLifetimeInMinutes': 600

    }, function(err, data) {
        console.log('Errors: ');
        console.log(err);
        console.log('Response: ');
        console.log(data);
    });
```

**Example**  

```
//The URL returned is over 900 characters. For this example, we've shortened the string for
    //readability and added ellipsis to indicate that it's incomplete.
        { 
            Status: 200,
            EmbedUrl: 'https://{{quicksightdomain}}/embed/12345/dashboards/67890..',
            RequestId: '7bee030e-f191-45c4-97fe-d9faf0e03713' 
        }
```

### .NET/C\#
<a name="embedded-analytics-dashboards-with-anonymous-users-cs"></a>

En el siguiente ejemplo, se muestra el código .NET/C\# que puede usar en el servidor de aplicaciones para generar la URL del panel integrado. Puede utilizar esta URL en su sitio web o aplicación para mostrar el panel. 

**Example**  

```
using System;
    using Amazon.QuickSight;
    using Amazon.QuickSight.Model;

    var quicksightClient = new AmazonQuickSightClient(
        AccessKey,
        SecretAccessKey,
        sessionToken,
        Amazon.RegionEndpoint.USEast1);
        
    try
    {
        Console.WriteLine(
            quicksightClient.GenerateEmbedUrlForAnonymousUserAsync(new GenerateEmbedUrlForAnonymousUserRequest
            {
                AwsAccountId = "111122223333",
                Namespace = default,
                AuthorizedResourceArns = authorizedResourceArns,
                AllowedDomains = allowedDomains,
                ExperienceConfiguration = experienceConfiguration,
                SessionTags = sessionTags,
                SessionLifetimeInMinutes = 600,
            }).Result.EmbedUrl
        );
    } catch (Exception ex) {
        Console.WriteLine(ex.Message);
    }
```

### AWS CLI
<a name="embedded-analytics-dashboards-with-anonymous-users-cli"></a>

Para asumir la función, elija una de las siguientes AWS Security Token Service (AWS STS) operaciones de API:
+ [AssumeRole](https://docs.aws.amazon.com/STS/latest/APIReference/API_AssumeRole.html)— Utilice esta operación cuando utilice una identidad de IAM para asumir la función.
+ [AssumeRoleWithWebIdentity](https://docs.aws.amazon.com/STS/latest/APIReference/API_AssumeRoleWithWebIdentity.html)— Utilice esta operación cuando utilice un proveedor de identidad web para autenticar a su usuario. 
+ [AssumeRoleWithSaml](https://docs.aws.amazon.com/STS/latest/APIReference/API_AssumeRoleWithSAML.html)— Utilice esta operación cuando utilice el lenguaje de marcado de aserciones de seguridad (SAML) para autenticar a sus usuarios.

En el siguiente ejemplo, se muestra el comando de la CLI para definir el rol de IAM. El rol debe tener los permisos de `quicksight:GenerateEmbedUrlForAnonymousUser` habilitados. 

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

La operación `assume-role` devuelve tres parámetros de salida: la clave de acceso, la clave secreta y el token de sesión. 

**nota**  
Si se produce un error `ExpiredToken` al llamar a la operación `AssumeRole`, probablemente se debe a que el `SESSION TOKEN` anterior aún se encuentra en las variables de entorno. Para retirarlo, establezca las variables siguientes:  
*AWS\_ACCESS\_KEY\_ID* 
*AWS\_SECRET\_ACCESS\_KEY* 
*AWS\_SESSION\_TOKEN* 

En el siguiente ejemplo, se muestra cómo definir estos tres parámetros en la CLI. Si utiliza un equipo con Microsoft Windows, utilice `set` en lugar 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}}"
```

Al ejecutar estos comandos, se define el ID de sesión del rol del usuario que visita su sitio web como `embedding_quicksight_dashboard_role/QuickSightEmbeddingAnonymousPolicy`. El ID de sesión del rol está compuesto por el nombre del rol de `role-arn` y el valor de `role-session-name`. Al utilizar el ID de sesión del rol único para cada usuario, se garantiza que se definan los permisos correspondientes para cada usuario visitante. También mantiene cada sesión separada y distinta. Si utiliza una serie de servidores web, por ejemplo, para equilibrar la carga, y una sesión se vuelve a conectar a un servidor diferente, se inicia una nueva sesión.

Para obtener una URL firmada para el panel, llame a `generate-embed-url-for-anynymous-user` desde el servidor de aplicaciones. Esta operación devuelve la URL del panel integrable. En el siguiente ejemplo, se muestra cómo generar la URL de un panel integrado mediante una llamada desde el servidor para los usuarios que realizan visitas anónimas a su portal web o aplicación.

```
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 obtener más información sobre cómo usar esta operación, consulte [https://docs.aws.amazon.com/quicksight/latest/APIReference/API_GenerateEmbedUrlForAnonymousUser.html](https://docs.aws.amazon.com/quicksight/latest/APIReference/API_GenerateEmbedUrlForAnonymousUser.html). Puede utilizar esta y otras operaciones de la API en su propio código. 

## Paso 3 integración de la URL del panel
<a name="embedded-analytics-dashboards-with-anonymous-users-step-3"></a>


|  | 
| --- |
|  Se aplica a: Enterprise Edition  | 


|  | 
| --- |
|    Público objetivo: desarrolladores de Amazon Quick  | 

En la siguiente sección, encontrará información sobre cómo utilizar el [SDK de incrustación de Amazon Quick Sight](https://www.npmjs.com/package/amazon-quicksight-embedding-sdk) (JavaScript) para incrustar la URL del panel de control del paso 2 en su sitio web o página de aplicación. Con el SDK, puede hacer lo siguiente: 
+ Coloque el panel en una página HTML.
+ Transferir los parámetros al panel.
+ Resolver los estados de error con mensajes que se personalizan en su aplicación.

Llamar a la operación de la API `GenerateEmbedUrlForAnynymousUser` para generar la dirección URL que puede integrar en la aplicación. Esta URL es válida durante 5 minutos, y la sesión resultante es válida durante 10 horas. La operación de la API proporciona la URL con un `auth_code` que permite una sesión con inicio único. 

El siguiente es un ejemplo de respuesta de `generate-embed-url-for-anynymous-user`.

```
//The URL returned is over 900 characters. For this example, we've shortened the string for
//readability and added ellipsis to indicate that it's incomplete.
        {
            "Status": "200",
            "EmbedUrl": "https://{{quicksightdomain}}/embed/12345/dashboards/67890..",
            "RequestId": "7bee030e-f191-45c4-97fe-d9faf0e03713"
        }
```

Inserte este panel en su página web mediante el [SDK de incrustación de Amazon Quick Sight](https://www.npmjs.com/package/amazon-quicksight-embedding-sdk) o añadiendo esta URL a un iframe. Si estableces un número fijo de altura y anchura (en píxeles), Amazon Quick Sight los usará y no cambiará la imagen a medida que la ventana cambie de tamaño. Si establece un porcentaje relativo de altura y anchura, Amazon Quick Sight proporciona un diseño adaptable que se modifica a medida que cambia el tamaño de la ventana. Con el SDK de incrustación de Amazon Quick Sight, también puede controlar los parámetros del panel de control y recibir llamadas en términos de errores o de finalización de la carga de la página. 

El dominio que va a alojar paneles integrados deben estar incluido en la *lista de permitidos*, la lista de dominios aprobados de la suscripción a Quick . Este requisito protege los datos impidiendo que dominios no aprobados alojen paneles integrados. Para obtener más información sobre cómo añadir dominios para los paneles integrados, consulte [Permitir la publicación de dominios en tiempo de ejecución con la API de Amazon Quick Sight](https://docs.aws.amazon.com/quicksight/latest/user/embedding-run-time.html).

En el siguiente ejemplo, se muestra cómo utilizar la URL generada. Este código reside en el servidor de aplicaciones.

### SDK 2.0
<a name="embedded-analytics-dashboards-with-anonymous-users-sdkv2"></a>

```
<!DOCTYPE html>
<html>

<head>
    <title>Dashboard Embedding Example</title>
    <script src="https://unpkg.com/amazon-quicksight-embedding-sdk@2.0.0/dist/quicksight-embedding-js-sdk.min.js"></script>
    <script type="text/javascript">
        const embedDashboard = async() => {
            const {
                createEmbeddingContext,
            } = QuickSightEmbedding;

            const embeddingContext = await createEmbeddingContext({
                onChange: (changeEvent, metadata) => {
                    console.log('Context received a change', changeEvent, metadata);
                },
            });

            const frameOptions = {
                url: '<YOUR_EMBED_URL>',
                container: '#experience-container',
                height: "700px",
                width: "1000px",
                onChange: (changeEvent, metadata) => {
                    switch (changeEvent.eventName) {
                        case 'FRAME_MOUNTED': {
                            console.log("Do something when the experience frame is mounted.");
                            break;
                        }
                        case 'FRAME_LOADED': {
                            console.log("Do something when the experience frame is loaded.");
                            break;
                        }
                    }
                },
            };

            const contentOptions = {
                parameters: [
                    {
                        Name: 'country',
                        Values: [
                            'United States'
                        ],
                    },
                    {
                        Name: 'states',
                        Values: [
                            'California',
                            'Washington'
                        ]
                    }
                ],
                locale: "en-US",
                sheetOptions: {
                    initialSheetId: '<YOUR_SHEETID>',
                    singleSheet: false,                        
                    emitSizeChangedEventOnSheetChange: false,
                },
                toolbarOptions: {
                    export: false,
                    undoRedo: false,
                    reset: false
                },
                attributionOptions: {
                    overlayContent: false,
                },
                onMessage: async (messageEvent, experienceMetadata) => {
                    switch (messageEvent.eventName) {
                        case 'CONTENT_LOADED': {
                            console.log("All visuals are loaded. The title of the document:", messageEvent.message.title);
                            break;
                        }
                        case 'ERROR_OCCURRED': {
                            console.log("Error occurred while rendering the experience. Error code:", messageEvent.message.errorCode);
                            break;
                        }
                        case 'PARAMETERS_CHANGED': {
                            console.log("Parameters changed. Changed parameters:", messageEvent.message.changedParameters);
                            break;
                        }
                        case 'SELECTED_SHEET_CHANGED': {
                            console.log("Selected sheet changed. Selected sheet:", messageEvent.message.selectedSheet);
                            break;
                        }
                        case 'SIZE_CHANGED': {
                            console.log("Size changed. New dimensions:", messageEvent.message);
                            break;
                        }
                        case 'MODAL_OPENED': {
                            window.scrollTo({
                                top: 0 // iframe top position
                            });
                            break;
                        }
                    }
                },
            };
            const embeddedDashboardExperience = await embeddingContext.embedDashboard(frameOptions, contentOptions);

            const selectCountryElement = document.getElementById('country');
            selectCountryElement.addEventListener('change', (event) => {
                embeddedDashboardExperience.setParameters([
                    {
                        Name: 'country',
                        Values: event.target.value
                    }
                ]);
            });
        };
    </script>
</head>

<body onload="embedDashboard()">
    <span>
        <label for="country">Country</label>
        <select id="country" name="country">
            <option value="United States">United States</option>
            <option value="Mexico">Mexico</option>
            <option value="Canada">Canada</option>
        </select>
    </span>
    <div id="experience-container"></div>
</body>

</html>
```

### SDK 1.0
<a name="embedded-analytics-dashboards-with-anonymous-users-sdkv1"></a>

```
<!DOCTYPE html>
<html>

<head>
    <title>Basic Embed</title>
    <script src="https://unpkg.com/amazon-quicksight-embedding-sdk@1.0.15/dist/quicksight-embedding-js-sdk.min.js"></script>
    <script type="text/javascript">
        var dashboard
        function onDashboardLoad(payload) {
            console.log("Do something when the dashboard is fully loaded.");
        }

        function onError(payload) {
            console.log("Do something when the dashboard fails loading");
        }

        function embedDashboard() {
            var containerDiv = document.getElementById("embeddingContainer");
            var options = {
                // replace this dummy url with the one generated via embedding API
                url: "https://us-east-1.quicksight.aws.amazon.com/sn/dashboards/dashboardId?isauthcode=true&identityprovider=quicksight&code=authcode",
                container: containerDiv,
                parameters: {
                    country: "United States"
                },
                scrolling: "no",
                height: "700px",
                width: "1000px",
                locale: "en-US",
                footerPaddingEnabled: true
            };
            dashboard = QuickSightEmbedding.embedDashboard(options);
            dashboard.on("error", onError);
            dashboard.on("load", onDashboardLoad);
        }

        function onCountryChange(obj) {
            dashboard.setParameters({country: obj.value});
        }
    </script>
</head>

<body onload="embedDashboard()">
    <span>
        <label for="country">Country</label>
        <select id="country" name="country" onchange="onCountryChange(this)">
            <option value="United States">United States</option>
            <option value="Mexico">Mexico</option>
            <option value="Canada">Canada</option>
        </select>
    </span>
    <div id="embeddingContainer"></div>
</body>

</html>
```

Para que este ejemplo funcione, asegúrese de utilizar el SDK de incrustación de Amazon Quick Sight para cargar el panel integrado en su sitio web utilizando JavaScript. Para obtener su copia, siga uno de estos pasos:
+ Descargue el [SDK de incrustación de Amazon Quick Sight](https://github.com/awslabs/amazon-quicksight-embedding-sdk#step-3-create-the-quicksight-session-object) desde GitHub. Este repositorio lo mantiene un grupo de desarrolladores de Amazon Quick Sight.
+ Descargue la última versión del SDK de incrustación de Amazon Quick Sight desde [https://www.npmjs.com/package/amazon-quicksight-embedding-sdk](https://www.npmjs.com/package/amazon-quicksight-embedding-sdk).
+ Si lo usa `npm` para JavaScript dependencias, descárguelo e instálelo ejecutando el siguiente comando.

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